| blob | b2639fca4abc3a6489be90ff9fdc8f711c9f8d99 |
13 </pre>
17 <pre>
20 ABSTRACT
24 (Cover sheet to be provided by ISO Secretariat.)
26 This International Standard specifies the form and establishes the interpretation of
27 programs expressed in the programming language C. Its purpose is to promote
28 portability, reliability, maintainability, and efficient execution of C language programs on
29 a variety of computing systems.
31 Clauses are included that detail the C language itself and the contents of the C language
32 execution library. Annexes summarize aspects of both of them, and enumerate factors
33 that influence the portability of C programs.
35 Although this International Standard is intended to guide knowledgeable C language
36 programmers as well as implementors of C language translation systems, the document
37 itself is not designed to serve as a tutorial.
39 Recipients of this draft are invited to submit, with their comments, notification of any
40 relevant patent rights of which they are aware and to provide supporting documentation.
42 Changes from the previous draft (N1539) are indicated by ''diff marks'' in the right
43 margin: deleted text is marked with ''*'', new or changed text with '' ''.
44 <!--page 2 -->
45 <!--page 3 -->
46 </pre>
50 <ul>
58 <ul>
60 <ul>
63 </ul>
65 <ul>
70 </ul>
71 </ul>
73 <ul>
76 <ul>
85 </ul>
87 <ul>
90 </ul>
92 <ul>
102 <!--page 4 -->
103 </ul>
105 <ul>
123 </ul>
126 <ul>
137 </ul>
139 <ul>
146 </ul>
148 <ul>
151 </ul>
153 <ul>
157 <!--page 5 -->
164 </ul>
166 <ul>
176 </ul>
177 </ul>
179 <ul>
181 <ul>
186 </ul>
188 <ul>
190 </ul>
192 <ul>
202 </ul>
204 <ul>
207 </ul>
210 <ul>
215 </ul>
217 <!--page 6 -->
219 <ul>
222 </ul>
226 <ul>
229 </ul>
231 <ul>
246 </ul>
248 <ul>
251 </ul>
253 <ul>
256 </ul>
259 <ul>
261 </ul>
263 <ul>
272 </ul>
276 <!--page 7 -->
277 <ul>
282 </ul>
284 <ul>
295 </ul>
297 <ul>
306 </ul>
309 <ul>
316 </ul>
319 <ul>
326 </ul>
328 <ul>
332 <!--page 8 -->
333 </ul>
335 <ul>
337 </ul>
339 <ul>
344 <ul>
351 </ul>
354 <ul>
359 </ul>
360 </ul>
361 <li><a href="#7.30"> 7.30 Wide character classification and mapping utilities <wctype.h></a>
362 <ul>
365 <ul>
368 </ul>
370 <ul>
373 </ul>
374 </ul>
376 <ul>
389 <!--page 9 -->
393 <li><a href="#7.31.16"> 7.31.16 Extended multibyte and wide character utilities <wchar.h></a>
394 <li><a href="#7.31.17"> 7.31.17 Wide character classification and mapping utilities <wctype.h></a>
395 </ul>
396 </ul>
398 <ul>
402 </ul>
404 <ul>
433 <li><a href="#B.29"> B.29 Wide character classification and mapping utilities <wctype.h></a>
434 </ul>
436 <!--page 10 -->
438 <ul>
441 </ul>
444 <ul>
455 <ul>
467 </ul>
468 </ul>
470 <ul>
475 <ul>
479 </ul>
481 <ul>
484 </ul>
486 <ul>
491 </ul>
493 <!--page 11 -->
494 </ul>
496 <ul>
500 </ul>
503 <ul>
509 </ul>
511 <ul>
515 <ul>
517 <ul>
522 </ul>
527 <ul>
532 </ul>
534 <ul>
540 </ul>
542 <ul>
547 </ul>
549 <ul>
552 <!--page 12 -->
553 </ul>
555 <ul>
559 </ul>
560 </ul>
561 </ul>
563 <ul>
567 </ul>
570 <!--page 13 -->
571 </ul>
576 ISO (the International Organization for Standardization) and IEC (the International
577 Electrotechnical Commission) form the specialized system for worldwide
578 standardization. National bodies that are member of ISO or IEC participate in the
579 development of International Standards through technical committees established by the
580 respective organization to deal with particular fields of technical activity. ISO and IEC
581 technical committees collaborate in fields of mutual interest. Other international
582 organizations, governmental and non-governmental, in liaison with ISO and IEC, also
583 take part in the work.
585 International Standards are drafted in accordance with the rules given in the ISO/IEC
586 Directives, Part 2. This International Standard was drafted in accordance with the fifth
587 edition (2004).
589 In the field of information technology, ISO and IEC have established a joint technical
590 committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
591 committee are circulated to national bodies for voting. Publication as an International
592 Standard requires approval by at least 75% of the national bodies casting a vote.
594 Attention is drawn to the possibility that some of the elements of this document may be
595 the subject of patent rights. ISO and IEC shall not be held responsible for identifying any
596 or all such patent rights.
598 This International Standard was prepared by Joint Technical Committee ISO/IEC JTC 1,
599 Information technology, Subcommittee SC 22, Programming languages, their
600 environments and system software interfaces. The Working Group responsible for this
601 standard (WG 14) maintains a site on the World Wide Web at http://www.open-
602 std.org/JTC1/SC22/WG14/ containing additional information relevant to this
603 standard such as a Rationale for many of the decisions made during its preparation and a
604 log of Defect Reports and Responses.
609 <ul>
610 <li> conditional (optional) features (including some that were previously mandatory)
611 <li> support for multiple threads of execution including an improved memory sequencing
615 <li> querying and specifying alignment of objects (<a href="#7.15"><stdalign.h></a>, <a href="#7.22"><stdlib.h></a>)
616 <li> Unicode characters and strings (<a href="#7.28"><uchar.h></a>) (originally specified in
618 <li> type-generic expressions
619 <!--page 14 -->
620 <li> static assertions
621 <li> anonymous structures and unions
622 <li> no-return functions
624 <li> support for opening files for exclusive access
626 <li> added the aligned_alloc, at_quick_exit, and quick_exit functions
628 <li> (conditional) support for bounds-checking interfaces (originally specified in
630 <li> (conditional) support for analyzability
631 </ul>
633 Major changes in the second edition included:
634 <ul>
635 <li> restricted character set support via digraphs and <a href="#7.9"><iso646.h></a> (originally specified
636 in AMD1)
637 <li> wide character library support in <a href="#7.29"><wchar.h></a> and <a href="#7.30"><wctype.h></a> (originally
638 specified in AMD1)
639 <li> more precise aliasing rules via effective type
640 <li> restricted pointers
641 <li> variable length arrays
642 <li> flexible array members
643 <li> static and type qualifiers in parameter array declarators
646 <li> the long long int type and library functions
647 <li> increased minimum translation limits
649 <li> remove implicit int
650 <li> reliable integer division
651 <li> universal character names (\u and \U)
652 <li> extended identifiers
653 <li> hexadecimal floating-point constants and %a and %A printf/scanf conversion
654 specifiers
655 <!--page 15 -->
656 <li> compound literals
657 <li> designated initializers
658 <li> // comments
659 <li> extended integer types and library functions in <a href="#7.8"><inttypes.h></a> and <a href="#7.20"><stdint.h></a>
660 <li> remove implicit function declaration
661 <li> preprocessor arithmetic done in intmax_t/uintmax_t
662 <li> mixed declarations and code
663 <li> new block scopes for selection and iteration statements
664 <li> integer constant type rules
665 <li> integer promotion rules
666 <li> macros with a variable number of arguments
667 <li> the vscanf family of functions in <a href="#7.21"><stdio.h></a> and <a href="#7.29"><wchar.h></a>
669 <li> treatment of error conditions by math library functions (math_errhandling)
672 <li> trailing comma allowed in enum declaration
673 <li> %lf conversion specifier allowed in printf
674 <li> inline functions
677 <li> idempotent type qualifiers
678 <li> empty macro arguments
679 <li> new structure type compatibility rules (tag compatibility)
680 <li> additional predefined macro names
681 <li> _Pragma preprocessing operator
682 <li> standard pragmas
683 <li> __func__ predefined identifier
684 <li> va_copy macro
685 <li> additional strftime conversion specifiers
686 <li> LIA compatibility annex
687 <!--page 16 -->
688 <li> deprecate ungetc at the beginning of a binary file
689 <li> remove deprecation of aliased array parameters
690 <li> conversion of array to pointer not limited to lvalues
691 <li> relaxed constraints on aggregate and union initialization
692 <li> relaxed restrictions on portable header names
693 <li> return without expression not permitted in function that returns a value (and vice
694 versa)
695 </ul>
697 Annexes D, F, G, K, and L form a normative part of this standard; annexes A, B, C, E, H,
698 I, J, the bibliography, and the index are for information only. In accordance with Part 2 of
699 the ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples
700 are also for information only.
701 <!--page 17 -->
706 With the introduction of new devices and extended character sets, new features may be
707 added to this International Standard. Subclauses in the language and library clauses warn
708 implementors and programmers of usages which, though valid in themselves, may
709 conflict with future additions.
711 Certain features are obsolescent, which means that they may be considered for
712 withdrawal in future revisions of this International Standard. They are retained because
713 of their widespread use, but their use in new implementations (for implementation
714 features) or new programs (for language [<a href="#6.11">6.11</a>] or library features [<a href="#7.31">7.31</a>]) is discouraged.
716 This International Standard is divided into four major subdivisions:
717 <ul>
722 </ul>
724 Examples are provided to illustrate possible forms of the constructions described.
725 Footnotes are provided to emphasize consequences of the rules described in that
726 subclause or elsewhere in this International Standard. References are used to refer to
727 other related subclauses. Recommendations are provided to give advice or guidance to
728 implementors. Annexes provide additional information and summarize the information
729 contained in this International Standard. A bibliography lists documents that were
730 referred to during the preparation of the standard.
732 The language clause (clause 6) is derived from ''The C Reference Manual''.
735 <!--page 18 -->
736 <!--page 19 -->
747 This International Standard specifies the form and establishes the interpretation of
748 programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
749 <ul>
750 <li> the representation of C programs;
751 <li> the syntax and constraints of the C language;
752 <li> the semantic rules for interpreting C programs;
753 <li> the representation of input data to be processed by C programs;
754 <li> the representation of output data produced by C programs;
755 <li> the restrictions and limits imposed by a conforming implementation of C.
756 </ul>
758 This International Standard does not specify
759 <ul>
760 <li> the mechanism by which C programs are transformed for use by a data-processing
761 system;
762 <li> the mechanism by which C programs are invoked for use by a data-processing
763 system;
764 <li> the mechanism by which input data are transformed for use by a C program;
765 <li> the mechanism by which output data are transformed after being produced by a C
766 program;
767 <li> the size or complexity of a program and its data that will exceed the capacity of any
768 specific data-processing system or the capacity of a particular processor;
769 <li> all minimal requirements of a data-processing system that is capable of supporting a
770 conforming implementation.
773 <!--page 20 -->
774 </ul>
777 <p><small><a name="note1" href="#note1">1)</a> This International Standard is designed to promote the portability of C programs among a variety of
778 data-processing systems. It is intended for use by implementors and programmers.
779 </small>
784 The following referenced documents are indispensable for the application of this
785 document. For dated references, only the edition cited applies. For undated references,
786 the latest edition of the referenced document (including any amendments) applies.
789 use in the physical sciences and technology.
792 interchange.
795 terms.
797 ISO 4217, Codes for the representation of currencies and funds.
799 ISO 8601, Data elements and interchange formats -- Information interchange --
800 Representation of dates and times.
802 ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
803 Character Set (UCS).
807 <!--page 21 -->
812 For the purposes of this International Standard, the following definitions apply. Other
813 terms are defined where they appear in italic type or on the left side of a syntax rule.
814 Terms explicitly defined in this International Standard are not to be presumed to refer
815 implicitly to similar terms defined elsewhere. Terms not defined in this International
825 NOTE 1 Where only one of these two actions is meant, ''read'' or ''modify'' is used.
828 NOTE 2 ''Modify'' includes the case where the new value being stored is the same as the previous value.
831 NOTE 3 Expressions that are not evaluated do not access objects.
838 requirement that objects of a particular type be located on storage boundaries with
839 addresses that are particular multiples of a byte address
845 actual argument<br>
846 actual parameter (deprecated)<br>
847 expression in the comma-separated list bounded by the parentheses in a function call
848 expression, or a sequence of preprocessing tokens in the comma-separated list bounded
849 by the parentheses in a function-like macro invocation
855 external appearance or action
861 unspecified behavior where each implementation documents how the choice is made
863 EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
864 when a signed integer is shifted right.
871 behavior that depends on local conventions of nationality, culture, and language that each
872 implementation documents
873 <!--page 22 -->
875 EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
876 characters other than the 26 lowercase Latin letters.
883 behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
884 for which this International Standard imposes no requirements
886 NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
887 results, to behaving during translation or program execution in a documented manner characteristic of the
888 environment (with or without the issuance of a diagnostic message), to terminating a translation or
889 execution (with the issuance of a diagnostic message).
892 EXAMPLE An example of undefined behavior is the behavior on integer overflow.
899 use of an unspecified value, or other behavior where this International Standard provides
900 two or more possibilities and imposes no further requirements on which is chosen in any
901 instance
903 EXAMPLE An example of unspecified behavior is the order in which the arguments to a function are
904 evaluated.
911 unit of data storage in the execution environment large enough to hold an object that may
912 have one of two values
914 NOTE It need not be possible to express the address of each individual bit of an object.
921 addressable unit of data storage large enough to hold any member of the basic character
922 set of the execution environment
924 NOTE 1 It is possible to express the address of each individual byte of an object uniquely.
927 NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
928 defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
929 bit.
937 representation of data
943 single-byte character
945 <!--page 23 -->
951 sequence of one or more bytes representing a member of the extended character set of
952 either the source or the execution environment
954 NOTE The extended character set is a superset of the basic character set.
961 value representable by an object of type wchar_t, capable of representing any character
962 in the current locale
968 restriction, either syntactic or semantic, by which the exposition of language elements is
969 to be interpreted
975 representation in the result format that is nearest in value, subject to the current rounding
976 mode, to what the result would be given unlimited range and precision
982 message belonging to an implementation-defined subset of the implementation's message
983 output
989 reference to a later subclause of this International Standard that contains additional
990 information relevant to this subclause
996 particular set of software, running in a particular translation environment under particular
997 control options, that performs translation of programs for, and supports execution of
998 functions in, a particular execution environment
1004 restriction imposed upon programs by the implementation
1010 either an object of scalar type, or a maximal sequence of adjacent bit-fields all having
1011 nonzero width
1012 <!--page 24 -->
1014 NOTE 1 Two threads of execution can update and access separate memory locations without interfering
1015 with each other.
1018 NOTE 2 A bit-field and an adjacent non-bit-field member are in separate memory locations. The same
1019 applies to two bit-fields, if one is declared inside a nested structure declaration and the other is not, or if the
1020 two are separated by a zero-length bit-field declaration, or if they are separated by a non-bit-field member
1021 declaration. It is not safe to concurrently update two non-atomic bit-fields in the same structure if all
1022 members declared between them are also (non-zero-length) bit-fields, no matter what the sizes of those
1023 intervening bit-fields happen to be.
1026 EXAMPLE A structure declared as
1027 <pre>
1028 struct {
1029 char a;
1031 struct { int ee:8; } e;
1032 }
1033 </pre>
1034 contains four separate memory locations: The member a, and bit-fields d and e.ee are each separate
1035 memory locations, and can be modified concurrently without interfering with each other. The bit-fields b
1036 and c together constitute the fourth memory location. The bit-fields b and c cannot be concurrently
1037 modified, but b and a, for example, can be.
1044 region of data storage in the execution environment, the contents of which can represent
1045 values
1047 NOTE When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
1054 formal parameter
1055 formal argument (deprecated)
1056 object declared as part of a function declaration or definition that acquires a value on
1057 entry to the function, or an identifier from the comma-separated list bounded by the
1058 parentheses immediately following the macro name in a function-like macro definition
1064 specification that is strongly recommended as being in keeping with the intent of the
1065 standard, but that may be impractical for some implementations
1071 requirement on a program when calling a library function
1073 NOTE 1 Despite the similar terms, a runtime-constraint is not a kind of constraint as defined by <a href="#3.8">3.8</a>, and
1074 need not be diagnosed at translation time.
1077 NOTE 2 Implementations that support the extensions in <a href="#K">annex K</a> are required to verify that the runtime-
1078 constraints for a library function are not violated by the program; see <a href="#K.3.1.4">K.3.1.4</a>.
1079 <!--page 25 -->
1085 precise meaning of the contents of an object when interpreted as having a specific type
1091 unspecified value where each implementation documents how the choice is made
1097 either an unspecified value or a trap representation
1103 valid value of the relevant type where this International Standard imposes no
1104 requirements on which value is chosen in any instance
1106 NOTE An unspecified value cannot be a trap representation.
1113 an object representation that need not represent a value of the object type
1119 interrupt execution of the program such that no further operations are performed
1121 NOTE In this International Standard, when the word ''trap'' is not immediately followed by
1126 <p><small><a name="note2" href="#note2">2)</a> For example, ''Trapping or stopping (if supported) is disabled...'' (<a href="#F.8.2">F.8.2</a>). Note that fetching a trap
1127 representation might perform a trap but is not required to (see <a href="#6.2.6.1">6.2.6.1</a>).
1128 </small>
1134 ceiling of x: the least integer greater than or equal to x
1143 floor of x: the greatest integer less than or equal to x
1150 <!--page 26 -->
1155 In this International Standard, ''shall'' is to be interpreted as a requirement on an
1156 implementation or on a program; conversely, ''shall not'' is to be interpreted as a
1157 prohibition.
1159 If a ''shall'' or ''shall not'' requirement that appears outside of a constraint or runtime-
1160 constraint is violated, the behavior is undefined. Undefined behavior is otherwise
1161 indicated in this International Standard by the words ''undefined behavior'' or by the
1162 omission of any explicit definition of behavior. There is no difference in emphasis among
1163 these three; they all describe ''behavior that is undefined''.
1165 A program that is correct in all other aspects, operating on correct data, containing
1166 unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
1168 The implementation shall not successfully translate a preprocessing translation unit
1169 containing a #error preprocessing directive unless it is part of a group skipped by
1170 conditional inclusion.
1172 A strictly conforming program shall use only those features of the language and library
1173 specified in this International Standard.<sup><a href="#note3"><b>3)</b></a></sup> It shall not produce output dependent on any
1174 unspecified, undefined, or implementation-defined behavior, and shall not exceed any
1175 minimum implementation limit.
1177 The two forms of conforming implementation are hosted and freestanding. A conforming
1178 hosted implementation shall accept any strictly conforming program. A conforming
1179 freestanding implementation shall accept any strictly conforming program in which the
1180 use of the features specified in the library clause (clause 7) is confined to the contents of
1181 the standard headers <a href="#7.7"><float.h></a>, <a href="#7.9"><iso646.h></a>, <a href="#7.10"><limits.h></a>, <a href="#7.15"><stdalign.h></a>,
1182 <a href="#7.16"><stdarg.h></a>, <a href="#7.18"><stdbool.h></a>, <a href="#7.19"><stddef.h></a>, <a href="#7.20"><stdint.h></a>, and
1183 <a href="#7.23"><stdnoreturn.h></a>. A conforming implementation may have extensions (including
1184 additional library functions), provided they do not alter the behavior of any strictly
1189 <!--page 27 -->
1191 A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note5"><b>5)</b></a></sup>
1193 An implementation shall be accompanied by a document that defines all implementation-
1194 defined and locale-specific characteristics and all extensions.
1195 <p><b> Forward references</b>: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
1196 characteristics of floating types <a href="#7.7"><float.h></a> (<a href="#7.7">7.7</a>), alternative spellings <a href="#7.9"><iso646.h></a>
1197 (<a href="#7.9">7.9</a>), sizes of integer types <a href="#7.10"><limits.h></a> (<a href="#7.10">7.10</a>), alignment <a href="#7.15"><stdalign.h></a> (<a href="#7.15">7.15</a>),
1198 variable arguments <a href="#7.16"><stdarg.h></a> (<a href="#7.16">7.16</a>), boolean type and values <a href="#7.18"><stdbool.h></a>
1199 (<a href="#7.18">7.18</a>), common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>), integer types <a href="#7.20"><stdint.h></a> (<a href="#7.20">7.20</a>),
1205 <!--page 28 -->
1208 <p><small><a name="note3" href="#note3">3)</a> A strictly conforming program can use conditional features (see <a href="#6.10.8.3">6.10.8.3</a>) provided the use is guarded
1209 by an appropriate conditional inclusion preprocessing directive using the related macro. For example:
1211 <pre>
1212 #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
1213 /* ... */
1214 fesetround(FE_UPWARD);
1215 /* ... */
1216 #endif
1217 </pre>
1219 </small>
1220 <p><small><a name="note4" href="#note4">4)</a> This implies that a conforming implementation reserves no identifiers other than those explicitly
1221 reserved in this International Standard.
1222 </small>
1223 <p><small><a name="note5" href="#note5">5)</a> Strictly conforming programs are intended to be maximally portable among conforming
1224 implementations. Conforming programs may depend upon nonportable features of a conforming
1225 implementation.
1226 </small>
1231 An implementation translates C source files and executes C programs in two data-
1232 processing-system environments, which will be called the translation environment and
1233 the execution environment in this International Standard. Their characteristics define and
1234 constrain the results of executing conforming C programs constructed according to the
1235 syntactic and semantic rules for conforming implementations.
1237 have been noted.
1248 A C program need not all be translated at the same time. The text of the program is kept
1249 in units called source files, (or preprocessing files) in this International Standard. A
1250 source file together with all the headers and source files included via the preprocessing
1251 directive #include is known as a preprocessing translation unit. After preprocessing, a
1252 preprocessing translation unit is called a translation unit. Previously translated translation
1253 units may be preserved individually or in libraries. The separate translation units of a
1254 program communicate by (for example) calls to functions whose identifiers have external
1255 linkage, manipulation of objects whose identifiers have external linkage, or manipulation
1256 of data files. Translation units may be separately translated and then later linked to
1257 produce an executable program.
1258 <p><b> Forward references</b>: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
1264 The precedence among the syntax rules of translation is specified by the following
1266 <ol>
1267 <li> Physical source file multibyte characters are mapped, in an implementation-
1268 defined manner, to the source character set (introducing new-line characters for
1269 end-of-line indicators) if necessary. Trigraph sequences are replaced by
1270 corresponding single-character internal representations.
1274 <!--page 29 -->
1275 <li> Each instance of a backslash character (\) immediately followed by a new-line
1276 character is deleted, splicing physical source lines to form logical source lines.
1277 Only the last backslash on any physical source line shall be eligible for being part
1278 of such a splice. A source file that is not empty shall end in a new-line character,
1279 which shall not be immediately preceded by a backslash character before any such
1280 splicing takes place.
1281 <li> The source file is decomposed into preprocessing tokens<sup><a href="#note7"><b>7)</b></a></sup> and sequences of
1282 white-space characters (including comments). A source file shall not end in a
1283 partial preprocessing token or in a partial comment. Each comment is replaced by
1284 one space character. New-line characters are retained. Whether each nonempty
1285 sequence of white-space characters other than new-line is retained or replaced by
1286 one space character is implementation-defined.
1287 <li> Preprocessing directives are executed, macro invocations are expanded, and
1288 _Pragma unary operator expressions are executed. If a character sequence that
1289 matches the syntax of a universal character name is produced by token
1290 concatenation (<a href="#6.10.3.3">6.10.3.3</a>), the behavior is undefined. A #include preprocessing
1291 directive causes the named header or source file to be processed from phase 1
1292 through phase 4, recursively. All preprocessing directives are then deleted.
1293 <li> Each source character set member and escape sequence in character constants and
1294 string literals is converted to the corresponding member of the execution character
1295 set; if there is no corresponding member, it is converted to an implementation-
1297 <li> Adjacent string literal tokens are concatenated.
1298 <li> White-space characters separating tokens are no longer significant. Each
1299 preprocessing token is converted into a token. The resulting tokens are
1300 syntactically and semantically analyzed and translated as a translation unit.
1301 <li> All external object and function references are resolved. Library components are
1302 linked to satisfy external references to functions and objects not defined in the
1303 current translation. All such translator output is collected into a program image
1304 which contains information needed for execution in its execution environment.
1305 </ol>
1306 <p><b> Forward references</b>: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
1307 preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href="#5.2.1.1">5.2.1.1</a>), external definitions (<a href="#6.9">6.9</a>).
1311 <!--page 30 -->
1314 <p><small><a name="note6" href="#note6">6)</a> Implementations shall behave as if these separate phases occur, even though many are typically folded
1315 together in practice. Source files, translation units, and translated translation units need not
1316 necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
1317 and any external representation. The description is conceptual only, and does not specify any
1318 particular implementation.
1319 </small>
1320 <p><small><a name="note7" href="#note7">7)</a> As described in <a href="#6.4">6.4</a>, the process of dividing a source file's characters into preprocessing tokens is
1321 context-dependent. For example, see the handling of < within a #include preprocessing directive.
1322 </small>
1323 <p><small><a name="note8" href="#note8">8)</a> An implementation need not convert all non-corresponding source characters to the same execution
1324 character.
1325 </small>
1330 A conforming implementation shall produce at least one diagnostic message (identified in
1331 an implementation-defined manner) if a preprocessing translation unit or translation unit
1332 contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
1333 specified as undefined or implementation-defined. Diagnostic messages need not be
1336 EXAMPLE An implementation shall issue a diagnostic for the translation unit:
1337 <pre>
1338 char i;
1339 int i;
1340 </pre>
1341 because in those cases where wording in this International Standard describes the behavior for a construct
1342 as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
1346 <p><small><a name="note9" href="#note9">9)</a> The intent is that an implementation should identify the nature of, and where possible localize, each
1347 violation. Of course, an implementation is free to produce any number of diagnostics as long as a
1348 valid program is still correctly translated. It may also successfully translate an invalid program.
1349 </small>
1354 Two execution environments are defined: freestanding and hosted. In both cases,
1355 program startup occurs when a designated C function is called by the execution
1356 environment. All objects with static storage duration shall be initialized (set to their
1357 initial values) before program startup. The manner and timing of such initialization are
1358 otherwise unspecified. Program termination returns control to the execution
1359 environment.
1360 <p><b> Forward references</b>: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.9">6.7.9</a>).
1365 In a freestanding environment (in which C program execution may take place without any
1366 benefit of an operating system), the name and type of the function called at program
1367 startup are implementation-defined. Any library facilities available to a freestanding
1368 program, other than the minimal set required by clause 4, are implementation-defined.
1370 The effect of program termination in a freestanding environment is implementation-
1371 defined.
1376 A hosted environment need not be provided, but shall conform to the following
1377 specifications if present.
1382 <!--page 31 -->
1387 The function called at program startup is named main. The implementation declares no
1388 prototype for this function. It shall be defined with a return type of int and with no
1389 parameters:
1390 <pre>
1391 int main(void) { /* ... */ }
1392 </pre>
1393 or with two parameters (referred to here as argc and argv, though any names may be
1394 used, as they are local to the function in which they are declared):
1395 <pre>
1396 int main(int argc, char *argv[]) { /* ... */ }
1397 </pre>
1398 or equivalent;<sup><a href="#note10"><b>10)</b></a></sup> or in some other implementation-defined manner.
1400 If they are declared, the parameters to the main function shall obey the following
1401 constraints:
1402 <ul>
1403 <li> The value of argc shall be nonnegative.
1404 <li> argv[argc] shall be a null pointer.
1406 argv[argc-1] inclusive shall contain pointers to strings, which are given
1407 implementation-defined values by the host environment prior to program startup. The
1408 intent is to supply to the program information determined prior to program startup
1409 from elsewhere in the hosted environment. If the host environment is not capable of
1410 supplying strings with letters in both uppercase and lowercase, the implementation
1411 shall ensure that the strings are received in lowercase.
1414 program name is not available from the host environment. If the value of argc is
1416 represent the program parameters.
1417 <li> The parameters argc and argv and the strings pointed to by the argv array shall
1418 be modifiable by the program, and retain their last-stored values between program
1419 startup and program termination.
1420 </ul>
1423 <p><small><a name="note10" href="#note10">10)</a> Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
1424 char ** argv, and so on.
1425 </small>
1430 In a hosted environment, a program may use all the functions, macros, type definitions,
1431 and objects described in the library clause (clause 7).
1436 <!--page 32 -->
1441 If the return type of the main function is a type compatible with int, a return from the
1442 initial call to the main function is equivalent to calling the exit function with the value
1443 returned by the main function as its argument;<sup><a href="#note11"><b>11)</b></a></sup> reaching the } that terminates the
1444 main function returns a value of 0. If the return type is not compatible with int, the
1445 termination status returned to the host environment is unspecified.
1446 <p><b> Forward references</b>: definition of terms (<a href="#7.1.1">7.1.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>).
1449 <p><small><a name="note11" href="#note11">11)</a> In accordance with <a href="#6.2.4">6.2.4</a>, the lifetimes of objects with automatic storage duration declared in main
1450 will have ended in the former case, even where they would not have in the latter.
1451 </small>
1456 The semantic descriptions in this International Standard describe the behavior of an
1457 abstract machine in which issues of optimization are irrelevant.
1459 Accessing a volatile object, modifying an object, modifying a file, or calling a function
1460 that does any of those operations are all side effects,<sup><a href="#note12"><b>12)</b></a></sup> which are changes in the state of
1461 the execution environment. Evaluation of an expression in general includes both value
1462 computations and initiation of side effects. Value computation for an lvalue expression
1463 includes determining the identity of the designated object.
1465 Sequenced before is an asymmetric, transitive, pair-wise relation between evaluations
1466 executed by a single thread, which induces a partial order among those evaluations.
1467 Given any two evaluations A and B, if A is sequenced before B, then the execution of A
1468 shall precede the execution of B. (Conversely, if A is sequenced before B, then B is
1469 sequenced after A.) If A is not sequenced before or after B, then A and B are
1470 unsequenced. Evaluations A and B are indeterminately sequenced when A is sequenced
1471 either before or after B, but it is unspecified which.<sup><a href="#note13"><b>13)</b></a></sup> The presence of a sequence point
1472 between the evaluation of expressions A and B implies that every value computation and
1473 side effect associated with A is sequenced before every value computation and side effect
1476 In the abstract machine, all expressions are evaluated as specified by the semantics. An
1477 actual implementation need not evaluate part of an expression if it can deduce that its
1478 value is not used and that no needed side effects are produced (including any caused by
1480 <!--page 33 -->
1481 calling a function or accessing a volatile object).
1483 When the processing of the abstract machine is interrupted by receipt of a signal, the
1484 values of objects that are neither lock-free atomic objects nor of type volatile
1485 sig_atomic_t are unspecified, as is the state of the floating-point environment. The
1486 value of any object modified by the handler that is neither a lock-free atomic object nor of
1487 type volatile sig_atomic_t becomes indeterminate when the handler exits, as
1488 does the state of the floating-point environment if it is modified by the handler and not
1489 restored to its original state.
1491 The least requirements on a conforming implementation are:
1492 <ul>
1493 <li> Accesses to volatile objects are evaluated strictly according to the rules of the abstract
1494 machine.
1495 <li> At program termination, all data written into files shall be identical to the result that
1496 execution of the program according to the abstract semantics would have produced.
1497 <li> The input and output dynamics of interactive devices shall take place as specified in
1498 <a href="#7.21.3">7.21.3</a>. The intent of these requirements is that unbuffered or line-buffered output
1499 appear as soon as possible, to ensure that prompting messages actually appear prior to
1500 a program waiting for input.
1501 </ul>
1502 This is the observable behavior of the program.
1504 What constitutes an interactive device is implementation-defined.
1506 More stringent correspondences between abstract and actual semantics may be defined by
1507 each implementation.
1509 EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
1510 semantics: at every sequence point, the values of the actual objects would agree with those specified by the
1511 abstract semantics. The keyword volatile would then be redundant.
1513 Alternatively, an implementation might perform various optimizations within each translation unit, such
1514 that the actual semantics would agree with the abstract semantics only when making function calls across
1515 translation unit boundaries. In such an implementation, at the time of each function entry and function
1516 return where the calling function and the called function are in different translation units, the values of all
1517 externally linked objects and of all objects accessible via pointers therein would agree with the abstract
1518 semantics. Furthermore, at the time of each such function entry the values of the parameters of the called
1519 function and of all objects accessible via pointers therein would agree with the abstract semantics. In this
1520 type of implementation, objects referred to by interrupt service routines activated by the signal function
1521 would require explicit specification of volatile storage, as well as other implementation-defined
1522 restrictions.
1525 EXAMPLE 2 In executing the fragment
1526 <pre>
1527 char c1, c2;
1528 /* ... */
1529 c1 = c1 + c2;
1530 </pre>
1531 the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
1532 and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
1533 <!--page 34 -->
1534 overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
1535 produce the same result, possibly omitting the promotions.
1538 EXAMPLE 3 Similarly, in the fragment
1539 <pre>
1540 float f1, f2;
1541 double d;
1542 /* ... */
1543 f1 = f2 * d;
1544 </pre>
1545 the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
1546 that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
1547 were replaced by the constant 2.0, which has type double).
1550 EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
1551 semantics. Values are independent of whether they are represented in a register or in memory. For
1552 example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
1553 is required to round to the precision of the storage type. In particular, casts and assignments are required to
1554 perform their specified conversion. For the fragment
1555 <pre>
1556 double d1, d2;
1557 float f;
1558 d1 = f = expression;
1559 d2 = (float) expression;
1560 </pre>
1561 the values assigned to d1 and d2 are required to have been converted to float.
1564 EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
1565 precision as well as range. The implementation cannot generally apply the mathematical associative rules
1566 for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
1567 overflow and underflow. Likewise, implementations cannot generally replace decimal constants in order to
1568 rearrange expressions. In the following fragment, rearrangements suggested by mathematical rules for real
1570 <pre>
1571 double x, y, z;
1572 /* ... */
1573 x = (x * y) * z; // not equivalent to x *= y * z;
1574 z = (x - y) + y ; // not equivalent to z = x;
1575 z = x + x * y; // not equivalent to z = x * (1.0 + y);
1577 </pre>
1580 EXAMPLE 6 To illustrate the grouping behavior of expressions, in the following fragment
1581 <pre>
1582 int a, b;
1583 /* ... */
1585 </pre>
1586 the expression statement behaves exactly the same as
1587 <pre>
1589 </pre>
1590 due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
1591 next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
1592 which overflows produce an explicit trap and in which the range of values representable by an int is
1594 <pre>
1595 a = ((a + b) + 32765);
1596 </pre>
1597 since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
1598 <!--page 35 -->
1599 while the original expression would not; nor can the expression be rewritten either as
1600 <pre>
1601 a = ((a + 32765) + b);
1602 </pre>
1603 or
1604 <pre>
1605 a = (a + (b + 32765));
1606 </pre>
1607 since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
1608 in which overflow silently generates some value and where positive and negative overflows cancel, the
1609 above expression statement can be rewritten by the implementation in any of the above ways because the
1610 same result will occur.
1613 EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
1614 following fragment
1615 <pre>
1617 int sum;
1618 char *p;
1619 /* ... */
1621 </pre>
1622 the expression statement is grouped as if it were written as
1623 <pre>
1625 </pre>
1626 but the actual increment of p can occur at any time between the previous sequence point and the next
1627 sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
1628 value.
1630 <p><b> Forward references</b>: expressions (<a href="#6.5">6.5</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>), statements (<a href="#6.8">6.8</a>), floating-
1631 point environment <a href="#7.6"><fenv.h></a> (<a href="#7.6">7.6</a>), the signal function (<a href="#7.14">7.14</a>), files (<a href="#7.21.3">7.21.3</a>).
1634 <p><small><a name="note12" href="#note12">12)</a> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
1635 flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
1636 values of floating-point operations. Implementations that support such floating-point state are
1637 required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
1638 environment library <a href="#7.6"><fenv.h></a> provides a programming facility for indicating when these side
1639 effects matter, freeing the implementations in other cases.
1640 </small>
1641 <p><small><a name="note13" href="#note13">13)</a> The executions of unsequenced evaluations can interleave. Indeterminately sequenced evaluations
1642 cannot interleave, but can be executed in any order.
1643 </small>
1646 <h5><a name="5.1.2.4" href="#5.1.2.4">5.1.2.4 Multi-threaded executions and data races</a></h5>
1648 Under a hosted implementation, a program can have more than one thread of execution
1649 (or thread) running concurrently. The execution of each thread proceeds as defined by
1650 the remainder of this standard. The execution of the entire program consists of an
1651 execution of all of its threads.<sup><a href="#note14"><b>14)</b></a></sup> Under a freestanding implementation, it is
1652 implementation-defined whether a program can have more than one thread of execution.
1654 The value of an object visible to a thread T at a particular point is the initial value of the
1655 object, a value stored in the object by T , or a value stored in the object by another thread,
1656 according to the rules below.
1658 NOTE 1 In some cases, there may instead be undefined behavior. Much of this section is motivated by
1659 the desire to support atomic operations with explicit and detailed visibility constraints. However, it also
1660 implicitly supports a simpler view for more restricted programs.
1663 Two expression evaluations conflict if one of them modifies a memory location and the
1664 other one reads or modifies the same memory location.
1667 <!--page 36 -->
1669 The library defines a number of atomic operations (<a href="#7.17">7.17</a>) and operations on mutexes
1670 (<a href="#7.26.4">7.26.4</a>) that are specially identified as synchronization operations. These operations play
1671 a special role in making assignments in one thread visible to another. A synchronization
1672 operation on one or more memory locations is either an acquire operation, a release
1673 operation, both an acquire and release operation, or a consume operation. A
1674 synchronization operation without an associated memory location is a fence and can be
1675 either an acquire fence, a release fence, or both an acquire and release fence. In addition,
1676 there are relaxed atomic operations, which are not synchronization operations, and
1677 atomic read-modify-write operations, which have special characteristics.
1679 NOTE 2 For example, a call that acquires a mutex will perform an acquire operation on the locations
1680 composing the mutex. Correspondingly, a call that releases the same mutex will perform a release
1681 operation on those same locations. Informally, performing a release operation on A forces prior side effects
1682 on other memory locations to become visible to other threads that later perform an acquire or consume
1683 operation on A. We do not include relaxed atomic operations as synchronization operations although, like
1684 synchronization operations, they cannot contribute to data races.
1687 All modifications to a particular atomic object M occur in some particular total order,
1688 called the modification order of M. If A and B are modifications of an atomic object M,
1689 and A happens before B, then A shall precede B in the modification order of M, which is
1690 defined below.
1692 NOTE 3 This states that the modification orders must respect the ''happens before'' relation.
1695 NOTE 4 There is a separate order for each atomic object. There is no requirement that these can be
1696 combined into a single total order for all objects. In general this will be impossible since different threads
1697 may observe modifications to different variables in inconsistent orders.
1700 A release sequence headed by a release operation A on an atomic object M is a maximal
1701 contiguous sub-sequence of side effects in the modification order of M, where the first
1702 operation is A and every subsequent operation either is performed by the same thread that
1703 performed the release or is an atomic read-modify-write operation.
1705 Certain library calls synchronize with other library calls performed by another thread. In
1706 particular, an atomic operation A that performs a release operation on an object M
1707 synchronizes with an atomic operation B that performs an acquire operation on M and
1708 reads a value written by any side effect in the release sequence headed by A.
1710 NOTE 5 Except in the specified cases, reading a later value does not necessarily ensure visibility as
1711 described below. Such a requirement would sometimes interfere with efficient implementation.
1714 NOTE 6 The specifications of the synchronization operations define when one reads the value written by
1715 another. For atomic variables, the definition is clear. All operations on a given mutex occur in a single total
1716 order. Each mutex acquisition ''reads the value written'' by the last mutex release.
1719 An evaluation A carries a dependency <sup><a href="#note15"><b>15)</b></a></sup> to an evaluation B if:
1722 <!--page 37 -->
1723 <ul>
1724 <li> the value of A is used as an operand of B, unless:
1725 <ul>
1726 <li> B is an invocation of the kill_dependency macro,
1730 <li> A is the left operand of a ? : operator, or
1732 <li> A is the left operand of a , operator;
1733 </ul>
1734 or
1735 <li> A writes a scalar object or bit-field M, B reads from M the value written by A, and A
1736 is sequenced before B, or
1737 <li> for some evaluation X, A carries a dependency to X and X carries a dependency to B.
1738 </ul>
1740 An evaluation A is dependency-ordered before<sup><a href="#note16"><b>16)</b></a></sup> an evaluation B if:
1741 <ul>
1742 <li> A performs a release operation on an atomic object M, and, in another thread, B
1743 performs a consume operation on M and reads a value written by any side effect in
1744 the release sequence headed by A, or
1745 <li> for some evaluation X, A is dependency-ordered before X and X carries a
1746 dependency to B.
1747 </ul>
1749 An evaluation A inter-thread happens before an evaluation B if A synchronizes with B, A
1750 is dependency-ordered before B, or, for some evaluation X:
1751 <ul>
1752 <li> A synchronizes with X and X is sequenced before B,
1753 <li> A is sequenced before X and X inter-thread happens before B, or
1754 <li> A inter-thread happens before X and X inter-thread happens before B.
1755 </ul>
1757 NOTE 7 The ''inter-thread happens before'' relation describes arbitrary concatenations of ''sequenced
1758 before'', ''synchronizes with'', and ''dependency-ordered before'' relationships, with two exceptions. The
1759 first exception is that a concatenation is not permitted to end with ''dependency-ordered before'' followed
1760 by ''sequenced before''. The reason for this limitation is that a consume operation participating in a
1761 ''dependency-ordered before'' relationship provides ordering only with respect to operations to which this
1762 consume operation actually carries a dependency. The reason that this limitation applies only to the end of
1763 such a concatenation is that any subsequent release operation will provide the required ordering for a prior
1764 consume operation. The second exception is that a concatenation is not permitted to consist entirely of
1765 ''sequenced before''. The reasons for this limitation are (1) to permit ''inter-thread happens before'' to be
1766 transitively closed and (2) the ''happens before'' relation, defined below, provides for relationships
1767 consisting entirely of ''sequenced before''.
1770 An evaluation A happens before an evaluation B if A is sequenced before B or A inter-
1771 thread happens before B.
1775 <!--page 38 -->
1777 A visible side effect A on an object M with respect to a value computation B of M
1778 satisfies the conditions:
1779 <ul>
1780 <li> A happens before B, and
1781 <li> there is no other side effect X to M such that A happens before X and X happens
1782 before B.
1783 </ul>
1784 The value of a non-atomic scalar object M, as determined by evaluation B, shall be the
1785 value stored by the visible side effect A.
1787 NOTE 8 If there is ambiguity about which side effect to a non-atomic object is visible, then there is a data
1788 race and the behavior is undefined.
1791 NOTE 9 This states that operations on ordinary variables are not visibly reordered. This is not actually
1792 detectable without data races, but it is necessary to ensure that data races, as defined here, and with suitable
1793 restrictions on the use of atomics, correspond to data races in a simple interleaved (sequentially consistent)
1794 execution.
1797 The visible sequence of side effects on an atomic object M, with respect to a value
1798 computation B of M, is a maximal contiguous sub-sequence of side effects in the
1799 modification order of M, where the first side effect is visible with respect to B, and for
1800 every subsequent side effect, it is not the case that B happens before it. The value of an
1801 atomic object M, as determined by evaluation B, shall be the value stored by some
1802 operation in the visible sequence of M with respect to B. Furthermore, if a value
1803 computation A of an atomic object M happens before a value computation B of M, and
1804 the value computed by A corresponds to the value stored by side effect X, then the value
1805 computed by B shall either equal the value computed by A, or be the value stored by side
1806 effect Y , where Y follows X in the modification order of M.
1808 NOTE 10 This effectively disallows compiler reordering of atomic operations to a single object, even if
1809 both operations are ''relaxed'' loads. By doing so, we effectively make the ''cache coherence'' guarantee
1810 provided by most hardware available to C atomic operations.
1813 NOTE 11 The visible sequence depends on the ''happens before'' relation, which in turn depends on the
1814 values observed by loads of atomics, which we are restricting here. The intended reading is that there must
1815 exist an association of atomic loads with modifications they observe that, together with suitably chosen
1816 modification orders and the ''happens before'' relation derived as described above, satisfy the resulting
1817 constraints as imposed here.
1820 The execution of a program contains a data race if it contains two conflicting actions in
1821 different threads, at least one of which is not atomic, and neither happens before the
1822 other. Any such data race results in undefined behavior.
1824 NOTE 12 It can be shown that programs that correctly use simple mutexes and
1825 memory_order_seq_cst operations to prevent all data races, and use no other synchronization
1826 operations, behave as though the operations executed by their constituent threads were simply interleaved,
1827 with each value computation of an object being the last value stored in that interleaving. This is normally
1828 referred to as ''sequential consistency''. However, this applies only to data-race-free programs, and data-
1829 race-free programs cannot observe most program transformations that do not change single-threaded
1830 program semantics. In fact, most single-threaded program transformations continue to be allowed, since
1831 any program that behaves differently as a result must contain undefined behavior.
1832 <!--page 39 -->
1834 NOTE 13 Compiler transformations that introduce assignments to a potentially shared memory location
1835 that would not be modified by the abstract machine are generally precluded by this standard, since such an
1836 assignment might overwrite another assignment by a different thread in cases in which an abstract machine
1837 execution would not have encountered a data race. This includes implementations of data member
1838 assignment that overwrite adjacent members in separate memory locations. We also generally preclude
1839 reordering of atomic loads in cases in which the atomics in question may alias, since this may violate the
1840 "visible sequence" rules.
1843 NOTE 14 Transformations that introduce a speculative read of a potentially shared memory location may
1844 not preserve the semantics of the program as defined in this standard, since they potentially introduce a data
1845 race. However, they are typically valid in the context of an optimizing compiler that targets a specific
1846 machine with well-defined semantics for data races. They would be invalid for a hypothetical machine that
1847 is not tolerant of races or provides hardware race detection.
1848 <!--page 40 -->
1851 <p><small><a name="note14" href="#note14">14)</a> The execution can usually be viewed as an interleaving of all of the threads. However, some kinds of
1852 atomic operations, for example, allow executions inconsistent with a simple interleaving as described
1853 below.
1854 </small>
1855 <p><small><a name="note15" href="#note15">15)</a> The ''carries a dependency'' relation is a subset of the ''sequenced before'' relation, and is similarly
1856 strictly intra-thread.
1857 </small>
1858 <p><small><a name="note16" href="#note16">16)</a> The ''dependency-ordered before'' relation is analogous to the ''synchronizes with'' relation, but uses
1859 release/consume in place of release/acquire.
1860 </small>
1868 Two sets of characters and their associated collating sequences shall be defined: the set in
1869 which source files are written (the source character set), and the set interpreted in the
1870 execution environment (the execution character set). Each set is further divided into a
1871 basic character set, whose contents are given by this subclause, and a set of zero or more
1872 locale-specific members (which are not members of the basic character set) called
1873 extended characters. The combined set is also called the extended character set. The
1874 values of the members of the execution character set are implementation-defined.
1876 In a character constant or string literal, members of the execution character set shall be
1877 represented by corresponding members of the source character set or by escape
1878 sequences consisting of the backslash \ followed by one or more characters. A byte with
1879 all bits set to 0, called the null character, shall exist in the basic execution character set; it
1880 is used to terminate a character string.
1882 Both the basic source and basic execution character sets shall have the following
1883 members: the 26 uppercase letters of the Latin alphabet
1884 <pre>
1885 A B C D E F G H I J K L M
1886 N O P Q R S T U V W X Y Z
1887 </pre>
1888 the 26 lowercase letters of the Latin alphabet
1889 <pre>
1890 a b c d e f g h i j k l m
1891 n o p q r s t u v w x y z
1892 </pre>
1893 the 10 decimal digits
1894 <pre>
1895 0 1 2 3 4 5 6 7 8 9
1896 </pre>
1897 the following 29 graphic characters
1898 <pre>
1899 ! " # % & ' ( ) * + , - . / :
1900 ; < = > ? [ \ ] ^ _ { | } ~
1901 </pre>
1902 the space character, and control characters representing horizontal tab, vertical tab, and
1903 form feed. The representation of each member of the source and execution basic
1904 character sets shall fit in a byte. In both the source and execution basic character sets, the
1905 value of each character after 0 in the above list of decimal digits shall be one greater than
1906 the value of the previous. In source files, there shall be some way of indicating the end of
1907 each line of text; this International Standard treats such an end-of-line indicator as if it
1908 were a single new-line character. In the basic execution character set, there shall be
1909 control characters representing alert, backspace, carriage return, and new line. If any
1910 other characters are encountered in a source file (except in an identifier, a character
1911 constant, a string literal, a header name, a comment, or a preprocessing token that is never
1912 <!--page 41 -->
1913 converted to a token), the behavior is undefined.
1915 A letter is an uppercase letter or a lowercase letter as defined above; in this International
1916 Standard the term does not include other characters that are letters in other alphabets.
1918 The universal character name construct provides a way to name other characters.
1919 <p><b> Forward references</b>: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
1920 preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
1925 Before any other processing takes place, each occurrence of one of the following
1926 sequences of three characters (called trigraph sequences<sup><a href="#note17"><b>17)</b></a></sup>) is replaced with the
1927 corresponding single character.
1928 <pre>
1929 ??= # ??) ] ??! |
1930 ??( [ ??' ^ ??> }
1931 ??/ \ ??< { ??- ~
1932 </pre>
1933 No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
1934 above is not changed.
1936 EXAMPLE 1
1937 <pre>
1938 ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)
1939 </pre>
1940 becomes
1941 <pre>
1942 #define arraycheck(a, b) a[b] || b[a]
1943 </pre>
1946 EXAMPLE 2 The following source line
1947 <pre>
1949 </pre>
1950 becomes (after replacement of the trigraph sequence ??/)
1951 <pre>
1953 </pre>
1956 <p><b>Footnotes</b>
1957 <p><small><a name="note17" href="#note17">17)</a> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
1958 described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
1959 </small>
1964 The source character set may contain multibyte characters, used to represent members of
1965 the extended character set. The execution character set may also contain multibyte
1966 characters, which need not have the same encoding as for the source character set. For
1967 both character sets, the following shall hold:
1968 <ul>
1969 <li> The basic character set shall be present and each character shall be encoded as a
1970 single byte.
1971 <li> The presence, meaning, and representation of any additional members is locale-
1972 specific.
1974 <!--page 42 -->
1975 <li> A multibyte character set may have a state-dependent encoding, wherein each
1976 sequence of multibyte characters begins in an initial shift state and enters other
1977 locale-specific shift states when specific multibyte characters are encountered in the
1978 sequence. While in the initial shift state, all single-byte characters retain their usual
1979 interpretation and do not alter the shift state. The interpretation for subsequent bytes
1980 in the sequence is a function of the current shift state.
1981 <li> A byte with all bits zero shall be interpreted as a null character independent of shift
1982 state. Such a byte shall not occur as part of any other multibyte character.
1983 </ul>
1985 For source files, the following shall hold:
1986 <ul>
1987 <li> An identifier, comment, string literal, character constant, or header name shall begin
1988 and end in the initial shift state.
1989 <li> An identifier, comment, string literal, character constant, or header name shall consist
1990 of a sequence of valid multibyte characters.
1991 </ul>
1996 The active position is that location on a display device where the next character output by
1997 the fputc function would appear. The intent of writing a printing character (as defined
1998 by the isprint function) to a display device is to display a graphic representation of
1999 that character at the active position and then advance the active position to the next
2000 position on the current line. The direction of writing is locale-specific. If the active
2001 position is at the final position of a line (if there is one), the behavior of the display device
2002 is unspecified.
2004 Alphabetic escape sequences representing nongraphic characters in the execution
2005 character set are intended to produce actions on display devices as follows:
2006 <dl>
2007 <dt> \a <dd>(alert) Produces an audible or visible alert without changing the active position.
2008 <dt> \b <dd>(backspace) Moves the active position to the previous position on the current line. If
2009 the active position is at the initial position of a line, the behavior of the display
2010 device is unspecified.
2011 <dt> \f <dd>(form feed) Moves the active position to the initial position at the start of the next
2012 logical page.
2013 <dt> \n <dd>(new line) Moves the active position to the initial position of the next line.
2014 <dt> \r <dd>(carriage return) Moves the active position to the initial position of the current line.
2015 <dt> \t <dd>(horizontal tab) Moves the active position to the next horizontal tabulation position
2016 on the current line. If the active position is at or past the last defined horizontal
2017 tabulation position, the behavior of the display device is unspecified.
2018 <dt> \v <dd>(vertical tab) Moves the active position to the initial position of the next vertical
2019 <!--page 43 -->
2020 tabulation position. If the active position is at or past the last defined vertical
2021 tabulation position, the behavior of the display device is unspecified.
2022 </dl>
2024 Each of these escape sequences shall produce a unique implementation-defined value
2025 which can be stored in a single char object. The external representations in a text file
2026 need not be identical to the internal representations, and are outside the scope of this
2027 International Standard.
2028 <p><b> Forward references</b>: the isprint function (<a href="#7.4.1.8">7.4.1.8</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>).
2033 Functions shall be implemented such that they may be interrupted at any time by a signal,
2034 or may be called by a signal handler, or both, with no alteration to earlier, but still active,
2035 invocations' control flow (after the interruption), function return values, or objects with
2036 automatic storage duration. All such objects shall be maintained outside the function
2037 image (the instructions that compose the executable representation of a function) on a
2038 per-invocation basis.
2043 Both the translation and execution environments constrain the implementation of
2044 language translators and libraries. The following summarizes the language-related
2045 environmental limits on a conforming implementation; the library-related limits are
2046 discussed in clause 7.
2051 The implementation shall be able to translate and execute at least one program that
2052 contains at least one instance of every one of the following limits:<sup><a href="#note18"><b>18)</b></a></sup>
2053 <ul>
2054 <li> 127 nesting levels of blocks
2055 <li> 63 nesting levels of conditional inclusion
2056 <li> 12 pointer, array, and function declarators (in any combinations) modifying an
2057 arithmetic, structure, union, or void type in a declaration
2058 <li> 63 nesting levels of parenthesized declarators within a full declarator
2059 <li> 63 nesting levels of parenthesized expressions within a full expression
2060 <li> 63 significant initial characters in an internal identifier or a macro name (each
2061 universal character name or extended source character is considered a single
2062 character)
2063 <li> 31 significant initial characters in an external identifier (each universal character name
2064 specifying a short identifier of 0000FFFF or less is considered 6 characters, each
2065 <!--page 44 -->
2066 universal character name specifying a short identifier of 00010000 or more is
2067 considered 10 characters, and each extended source character is considered the same
2068 number of characters as the corresponding universal character name, if any)<sup><a href="#note19"><b>19)</b></a></sup>
2069 <li> 4095 external identifiers in one translation unit
2070 <li> 511 identifiers with block scope declared in one block
2071 <li> 4095 macro identifiers simultaneously defined in one preprocessing translation unit
2072 <li> 127 parameters in one function definition
2073 <li> 127 arguments in one function call
2074 <li> 127 parameters in one macro definition
2075 <li> 127 arguments in one macro invocation
2076 <li> 4095 characters in a logical source line
2077 <li> 4095 characters in a string literal (after concatenation)
2078 <li> 65535 bytes in an object (in a hosted environment only)
2079 <li> 15 nesting levels for #included files
2080 <li> 1023 case labels for a switch statement (excluding those for any nested switch
2081 statements)
2082 <li> 1023 members in a single structure or union
2083 <li> 1023 enumeration constants in a single enumeration
2084 <li> 63 levels of nested structure or union definitions in a single struct-declaration-list
2085 </ul>
2087 <p><b>Footnotes</b>
2088 <p><small><a name="note18" href="#note18">18)</a> Implementations should avoid imposing fixed translation limits whenever possible.
2089 </small>
2090 <p><small><a name="note19" href="#note19">19)</a> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
2091 </small>
2096 An implementation is required to document all the limits specified in this subclause,
2097 which are specified in the headers <a href="#7.10"><limits.h></a> and <a href="#7.7"><float.h></a>. Additional limits are
2099 <p><b> Forward references</b>: integer types <a href="#7.20"><stdint.h></a> (<a href="#7.20">7.20</a>).
2102 <h5><a name="5.2.4.2.1" href="#5.2.4.2.1">5.2.4.2.1 Sizes of integer types <limits.h></a></h5>
2104 The values given below shall be replaced by constant expressions suitable for use in #if
2105 preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
2106 following shall be replaced by expressions that have the same type as would an
2107 expression that is an object of the corresponding type converted according to the integer
2108 promotions. Their implementation-defined values shall be equal or greater in magnitude
2111 <!--page 45 -->
2112 (absolute value) to those shown, with the same sign.
2113 <ul>
2114 <li> number of bits for smallest object that is not a bit-field (byte)
2115 <pre>
2116 CHAR_BIT 8
2117 </pre>
2118 <li> minimum value for an object of type signed char
2119 <pre>
2120 SCHAR_MIN -127 // -(2<sup>7</sup> - 1)
2121 </pre>
2122 <li> maximum value for an object of type signed char
2123 <pre>
2124 SCHAR_MAX +127 // 2<sup>7</sup> - 1
2125 </pre>
2126 <li> maximum value for an object of type unsigned char
2127 <pre>
2128 UCHAR_MAX 255 // 2<sup>8</sup> - 1
2129 </pre>
2130 <li> minimum value for an object of type char
2131 <pre>
2132 CHAR_MIN see below
2133 </pre>
2134 <li> maximum value for an object of type char
2135 <pre>
2136 CHAR_MAX see below
2137 </pre>
2138 <li> maximum number of bytes in a multibyte character, for any supported locale
2139 <pre>
2140 MB_LEN_MAX 1
2141 </pre>
2142 <li> minimum value for an object of type short int
2143 <pre>
2144 SHRT_MIN -32767 // -(2<sup>15</sup> - 1)
2145 </pre>
2146 <li> maximum value for an object of type short int
2147 <pre>
2148 SHRT_MAX +32767 // 2<sup>15</sup> - 1
2149 </pre>
2150 <li> maximum value for an object of type unsigned short int
2151 <pre>
2152 USHRT_MAX 65535 // 2<sup>16</sup> - 1
2153 </pre>
2154 <li> minimum value for an object of type int
2155 <pre>
2156 INT_MIN -32767 // -(2<sup>15</sup> - 1)
2157 </pre>
2158 <li> maximum value for an object of type int
2159 <pre>
2160 INT_MAX +32767 // 2<sup>15</sup> - 1
2161 </pre>
2162 <li> maximum value for an object of type unsigned int
2163 <pre>
2164 UINT_MAX 65535 // 2<sup>16</sup> - 1
2165 </pre>
2166 <li> minimum value for an object of type long int
2167 <pre>
2168 LONG_MIN -2147483647 // -(2<sup>31</sup> - 1)
2169 </pre>
2170 <li> maximum value for an object of type long int
2171 <pre>
2172 LONG_MAX +2147483647 // 2<sup>31</sup> - 1
2173 </pre>
2174 <li> maximum value for an object of type unsigned long int
2175 <pre>
2176 ULONG_MAX 4294967295 // 2<sup>32</sup> - 1
2177 </pre>
2178 <!--page 46 -->
2179 <li> minimum value for an object of type long long int
2180 <pre>
2181 LLONG_MIN -9223372036854775807 // -(2<sup>63</sup> - 1)
2182 </pre>
2183 <li> maximum value for an object of type long long int
2184 <pre>
2185 LLONG_MAX +9223372036854775807 // 2<sup>63</sup> - 1
2186 </pre>
2187 <li> maximum value for an object of type unsigned long long int
2188 <pre>
2189 ULLONG_MAX 18446744073709551615 // 2<sup>64</sup> - 1
2190 </pre>
2191 </ul>
2193 If the value of an object of type char is treated as a signed integer when used in an
2194 expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
2195 value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
2196 CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
2197 UCHAR_MAX.<sup><a href="#note20"><b>20)</b></a></sup> The value UCHAR_MAX shall equal 2<sup>CHAR_BIT</sup> - 1.
2198 <p><b> Forward references</b>: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
2200 <p><b>Footnotes</b>
2202 </small>
2205 <h5><a name="5.2.4.2.2" href="#5.2.4.2.2">5.2.4.2.2 Characteristics of floating types <float.h></a></h5>
2207 The characteristics of floating types are defined in terms of a model that describes a
2208 representation of floating-point numbers and values that provide information about an
2209 implementation's floating-point arithmetic.<sup><a href="#note21"><b>21)</b></a></sup> The following parameters are used to
2210 define the model for each floating-point type:
2211 <pre>
2212 s sign ((+-)1)
2213 b base or radix of exponent representation (an integer > 1)
2214 e exponent (an integer between a minimum emin and a maximum emax )
2215 p precision (the number of base-b digits in the significand)
2216 f<sub>k</sub> nonnegative integers less than b (the significand digits)
2217 </pre>
2219 A floating-point number (x) is defined by the following model:
2220 <pre>
2221 p
2222 x = s b<sup>e</sup> (Sum) f<sub>k</sub> b<sup>-k</sup> , emin <= e <= emax
2223 k=1
2224 </pre>
2227 In addition to normalized floating-point numbers ( f<sub>1</sub> > 0 if x != 0), floating types may be
2228 able to contain other kinds of floating-point numbers, such as subnormal floating-point
2229 numbers (x != 0, e = emin , f<sub>1</sub> = 0) and unnormalized floating-point numbers (x != 0,
2230 e > emin , f<sub>1</sub> = 0), and values that are not floating-point numbers, such as infinities and
2231 NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates
2232 through almost every arithmetic operation without raising a floating-point exception; a
2233 signaling NaN generally raises a floating-point exception when occurring as an
2236 <!--page 47 -->
2239 An implementation may give zero and values that are not floating-point numbers (such as
2240 infinities and NaNs) a sign or may leave them unsigned. Wherever such values are
2241 unsigned, any requirement in this International Standard to retrieve the sign shall produce
2242 an unspecified sign, and any requirement to set the sign shall be ignored.
2244 The minimum range of representable values for a floating type is the most negative finite
2245 floating-point number representable in that type through the most positive finite floating-
2246 point number representable in that type. In addition, if negative infinity is representable
2247 in a type, the range of that type is extended to all negative real numbers; likewise, if
2248 positive infinity is representable in a type, the range of that type is extended to all positive
2249 real numbers.
2251 The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
2252 <a href="#7.12"><math.h></a> and <a href="#7.3"><complex.h></a> that return floating-point results is implementation-
2253 defined, as is the accuracy of the conversion between floating-point internal
2254 representations and string representations performed by the library functions in
2255 <a href="#7.21"><stdio.h></a>, <a href="#7.22"><stdlib.h></a>, and <a href="#7.29"><wchar.h></a>. The implementation may state that the
2256 accuracy is unknown.
2258 All integer values in the <a href="#7.7"><float.h></a> header, except FLT_ROUNDS, shall be constant
2259 expressions suitable for use in #if preprocessing directives; all floating values shall be
2260 constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
2261 and FLT_ROUNDS have separate names for all three floating-point types. The floating-point
2262 model representation is provided for all values except FLT_EVAL_METHOD and
2263 FLT_ROUNDS.
2265 The rounding mode for floating-point addition is characterized by the implementation-
2267 <pre>
2268 -1 indeterminable
2269 0 toward zero
2270 1 to nearest
2271 2 toward positive infinity
2272 3 toward negative infinity
2273 </pre>
2274 All other values for FLT_ROUNDS characterize implementation-defined rounding
2275 behavior.
2278 <!--page 48 -->
2280 Except for assignment and cast (which remove all extra range and precision), the values
2281 yielded by operators with floating operands and values subject to the usual arithmetic
2282 conversions and of floating constants are evaluated to a format whose range and precision
2283 may be greater than required by the type. The use of evaluation formats is characterized
2284 by the implementation-defined value of FLT_EVAL_METHOD:<sup><a href="#note24"><b>24)</b></a></sup>
2285 <pre>
2286 -1 indeterminable;
2287 0 evaluate all operations and constants just to the range and precision of the
2288 type;
2289 1 evaluate operations and constants of type float and double to the
2290 range and precision of the double type, evaluate long double
2291 operations and constants to the range and precision of the long double
2292 type;
2293 2 evaluate all operations and constants to the range and precision of the
2294 long double type.
2295 </pre>
2296 All other negative values for FLT_EVAL_METHOD characterize implementation-defined
2297 behavior.
2299 The presence or absence of subnormal numbers is characterized by the implementation-
2300 defined values of FLT_HAS_SUBNORM, DBL_HAS_SUBNORM, and
2301 LDBL_HAS_SUBNORM:
2302 <pre>
2305 1 present (type does support subnormal numbers)
2306 </pre>
2308 The values given in the following list shall be replaced by constant expressions with
2309 implementation-defined values that are greater or equal in magnitude (absolute value) to
2310 those shown, with the same sign:
2311 <ul>
2312 <li> radix of exponent representation, b
2313 <pre>
2314 FLT_RADIX 2
2315 </pre>
2316 <!--page 49 -->
2317 <li> number of base-FLT_RADIX digits in the floating-point significand, p
2318 <pre>
2319 FLT_MANT_DIG
2320 DBL_MANT_DIG
2321 LDBL_MANT_DIG
2322 </pre>
2323 <li> number of decimal digits, n, such that any floating-point number with p radix b digits
2324 can be rounded to a floating-point number with n decimal digits and back again
2325 without change to the value,
2326 <pre>
2327 { p log10 b if b is a power of 10
2328 {
2329 { [^1 + p log10 b^] otherwise
2330 </pre>
2331 <pre>
2332 FLT_DECIMAL_DIG 6
2333 DBL_DECIMAL_DIG 10
2334 LDBL_DECIMAL_DIG 10
2335 </pre>
2336 <li> number of decimal digits, n, such that any floating-point number in the widest
2337 supported floating type with pmax radix b digits can be rounded to a floating-point
2338 number with n decimal digits and back again without change to the value,
2339 <pre>
2340 { pmax log10 b if b is a power of 10
2341 {
2342 { [^1 + pmax log10 b^] otherwise
2343 </pre>
2344 <pre>
2345 DECIMAL_DIG 10
2346 </pre>
2347 <li> number of decimal digits, q, such that any floating-point number with q decimal digits
2348 can be rounded into a floating-point number with p radix b digits and back again
2349 without change to the q decimal digits,
2350 <pre>
2351 { p log10 b if b is a power of 10
2352 {
2353 { [_( p - 1) log10 b_] otherwise
2355 FLT_DIG 6
2356 DBL_DIG 10
2357 LDBL_DIG 10
2358 </pre>
2359 <li> minimum negative integer such that FLT_RADIX raised to one less than that power is
2360 a normalized floating-point number, emin
2361 <pre>
2362 FLT_MIN_EXP
2363 DBL_MIN_EXP
2364 LDBL_MIN_EXP
2365 </pre>
2366 <!--page 50 -->
2367 <li> minimum negative integer such that 10 raised to that power is in the range of
2368 normalized floating-point numbers, [^log10 b<sup>emin-1</sup>^]
2369 <pre>
2370 FLT_MIN_10_EXP -37
2371 DBL_MIN_10_EXP -37
2372 LDBL_MIN_10_EXP -37
2373 </pre>
2374 <li> maximum integer such that FLT_RADIX raised to one less than that power is a
2375 representable finite floating-point number, emax
2376 <pre>
2377 FLT_MAX_EXP
2378 DBL_MAX_EXP
2379 LDBL_MAX_EXP
2380 </pre>
2381 <li> maximum integer such that 10 raised to that power is in the range of representable
2382 finite floating-point numbers, [_log10 ((1 - b<sup>-p</sup>)b<sup>emax</sup>)_]
2383 <pre>
2384 FLT_MAX_10_EXP +37
2385 DBL_MAX_10_EXP +37
2386 LDBL_MAX_10_EXP +37
2387 </pre>
2388 </ul>
2390 The values given in the following list shall be replaced by constant expressions with
2391 implementation-defined values that are greater than or equal to those shown:
2392 <ul>
2393 <li> maximum representable finite floating-point number, (1 - b<sup>-p</sup>)b<sup>emax</sup>
2394 <pre>
2395 FLT_MAX 1E+37
2396 DBL_MAX 1E+37
2397 LDBL_MAX 1E+37
2398 </pre>
2399 </ul>
2401 The values given in the following list shall be replaced by constant expressions with
2402 implementation-defined (positive) values that are less than or equal to those shown:
2403 <ul>
2404 <li> the difference between 1 and the least value greater than 1 that is representable in the
2405 given floating point type, b<sup>1-p</sup>
2406 <pre>
2407 FLT_EPSILON 1E-5
2408 DBL_EPSILON 1E-9
2409 LDBL_EPSILON 1E-9
2410 </pre>
2411 <li> minimum normalized positive floating-point number, b<sup>emin-1</sup>
2412 <!--page 51 -->
2413 <pre>
2414 FLT_MIN 1E-37
2415 DBL_MIN 1E-37
2416 LDBL_MIN 1E-37
2417 </pre>
2419 FLT_TRUE_MIN 1E-37
2420 DBL_TRUE_MIN 1E-37
2421 LDBL_TRUE_MIN 1E-37
2422 </ul>
2423 <p><b>Recommended practice</b>
2425 Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
2426 should be the identity function.
2428 EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
2429 requirements of this International Standard, and the appropriate values in a <a href="#7.7"><float.h></a> header for type
2430 float:
2431 <pre>
2432 6
2433 x = s 16<sup>e</sup> (Sum) f<sub>k</sub> 16<sup>-k</sup> , -31 <= e <= +32
2434 k=1
2435 </pre>
2436 <pre>
2437 FLT_RADIX 16
2438 FLT_MANT_DIG 6
2439 FLT_EPSILON 9.53674316E-07F
2440 FLT_DECIMAL_DIG 9
2441 FLT_DIG 6
2442 FLT_MIN_EXP -31
2443 FLT_MIN 2.93873588E-39F
2444 FLT_MIN_10_EXP -38
2445 FLT_MAX_EXP +32
2446 FLT_MAX 3.40282347E+38F
2447 FLT_MAX_10_EXP +38
2448 </pre>
2451 EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
2452 single-precision and double-precision numbers in IEC 60559,<sup><a href="#note28"><b>28)</b></a></sup> and the appropriate values in a
2454 <pre>
2455 24
2456 xf = s 2<sup>e</sup> (Sum) f<sub>k</sub> 2<sup>-k</sup> , -125 <= e <= +128
2457 k=1
2458 </pre>
2459 <pre>
2460 53
2461 xd = s 2<sup>e</sup> (Sum) f<sub>k</sub> 2<sup>-k</sup> , -1021 <= e <= +1024
2462 k=1
2463 </pre>
2464 <pre>
2465 FLT_RADIX 2
2466 DECIMAL_DIG 17
2467 FLT_MANT_DIG 24
2468 FLT_EPSILON 1.19209290E-07F // decimal constant
2469 FLT_EPSILON 0X1P-23F // hex constant
2470 FLT_DECIMAL_DIG 9
2471 </pre>
2474 <!--page 52 -->
2475 <pre>
2476 FLT_DIG 6
2477 FLT_MIN_EXP -125
2478 FLT_MIN 1.17549435E-38F // decimal constant
2479 FLT_MIN 0X1P-126F // hex constant
2480 FLT_TRUE_MIN 1.40129846E-45F // decimal constant
2481 FLT_TRUE_MIN 0X1P-149F // hex constant
2482 FLT_HAS_SUBNORM 1
2483 FLT_MIN_10_EXP -37
2484 FLT_MAX_EXP +128
2485 FLT_MAX 3.40282347E+38F // decimal constant
2486 FLT_MAX 0X1.fffffeP127F // hex constant
2487 FLT_MAX_10_EXP +38
2488 DBL_MANT_DIG 53
2489 DBL_EPSILON 2.2204460492503131E-16 // decimal constant
2490 DBL_EPSILON 0X1P-52 // hex constant
2491 DBL_DECIMAL_DIG 17
2492 DBL_DIG 15
2493 DBL_MIN_EXP -1021
2494 DBL_MIN 2.2250738585072014E-308 // decimal constant
2495 DBL_MIN 0X1P-1022 // hex constant
2496 DBL_TRUE_MIN 4.9406564584124654E-324 // decimal constant
2497 DBL_TRUE_MIN 0X1P-1074 // hex constant
2498 DBL_HAS_SUBNORM 1
2499 DBL_MIN_10_EXP -307
2500 DBL_MAX_EXP +1024
2501 DBL_MAX 1.7976931348623157E+308 // decimal constant
2502 DBL_MAX 0X1.fffffffffffffP1023 // hex constant
2503 DBL_MAX_10_EXP +308
2504 </pre>
2505 If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
2506 example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
2507 precision), then DECIMAL_DIG would be 21.
2509 <p><b> Forward references</b>: conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
2510 <a href="#7.3"><complex.h></a> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <a href="#7.29"><wchar.h></a>
2511 (<a href="#7.29">7.29</a>), floating-point environment <a href="#7.6"><fenv.h></a> (<a href="#7.6">7.6</a>), general utilities <a href="#7.22"><stdlib.h></a>
2512 (<a href="#7.22">7.22</a>), input/output <a href="#7.21"><stdio.h></a> (<a href="#7.21">7.21</a>), mathematics <a href="#7.12"><math.h></a> (<a href="#7.12">7.12</a>).
2513 <!--page 53 -->
2515 <p><b>Footnotes</b>
2516 <p><small><a name="note21" href="#note21">21)</a> The floating-point model is intended to clarify the description of each floating-point characteristic and
2517 does not require the floating-point arithmetic of the implementation to be identical.
2518 </small>
2519 <p><small><a name="note22" href="#note22">22)</a> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
2520 IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
2521 similar behavior.
2522 </small>
2523 <p><small><a name="note23" href="#note23">23)</a> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
2525 </small>
2526 <p><small><a name="note24" href="#note24">24)</a> The evaluation method determines evaluation formats of expressions involving all floating types, not
2527 just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
2528 _Complex operands is represented in the double _Complex format, and its parts are evaluated to
2529 double.
2530 </small>
2531 <p><small><a name="note25" href="#note25">25)</a> Characterization as indeterminable is intended if floating-point operations do not consistently interpret
2532 subnormal representations as zero, nor as nonzero.
2533 </small>
2534 <p><small><a name="note26" href="#note26">26)</a> Characterization as absent is intended if no floating-point operations produce subnormal results from
2535 non-subnormal inputs, even if the type format includes representations of subnormal numbers.
2536 </small>
2537 <p><small><a name="note27" href="#note27">27)</a> If the presence or absence of subnormal numbers is indeterminable, then the value is intended to be a
2538 positive number no greater than the minimum normalized positive number for the type.
2539 </small>
2540 <p><small><a name="note28" href="#note28">28)</a> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
2541 limits are one less than shown here.
2542 </small>
2550 In the syntax notation used in this clause, syntactic categories (nonterminals) are
2551 indicated by italic type, and literal words and character set members (terminals) by bold
2552 type. A colon (:) following a nonterminal introduces its definition. Alternative
2553 definitions are listed on separate lines, except when prefaced by the words ''one of''. An
2554 optional symbol is indicated by the subscript ''opt'', so that
2555 <pre>
2556 { expression<sub>opt</sub> }
2557 </pre>
2558 indicates an optional expression enclosed in braces.
2560 When syntactic categories are referred to in the main text, they are not italicized and
2561 words are separated by spaces instead of hyphens.
2571 An identifier can denote an object; a function; a tag or a member of a structure, union, or
2572 enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
2573 same identifier can denote different entities at different points in the program. A member
2574 of an enumeration is called an enumeration constant. Macro names and macro
2575 parameters are not considered further here, because prior to the semantic phase of
2576 program translation any occurrences of macro names in the source file are replaced by the
2577 preprocessing token sequences that constitute their macro definitions.
2579 For each different entity that an identifier designates, the identifier is visible (i.e., can be
2580 used) only within a region of program text called its scope. Different entities designated
2581 by the same identifier either have different scopes, or are in different name spaces. There
2582 are four kinds of scopes: function, file, block, and function prototype. (A function
2583 prototype is a declaration of a function that declares the types of its parameters.)
2585 A label name is the only kind of identifier that has function scope. It can be used (in a
2586 goto statement) anywhere in the function in which it appears, and is declared implicitly
2587 by its syntactic appearance (followed by a : and a statement).
2589 Every other identifier has scope determined by the placement of its declaration (in a
2590 declarator or type specifier). If the declarator or type specifier that declares the identifier
2591 appears outside of any block or list of parameters, the identifier has file scope, which
2592 terminates at the end of the translation unit. If the declarator or type specifier that
2593 declares the identifier appears inside a block or within the list of parameter declarations in
2594 a function definition, the identifier has block scope, which terminates at the end of the
2595 associated block. If the declarator or type specifier that declares the identifier appears
2596 <!--page 54 -->
2597 within the list of parameter declarations in a function prototype (not part of a function
2598 definition), the identifier has function prototype scope, which terminates at the end of the
2599 function declarator. If an identifier designates two different entities in the same name
2600 space, the scopes might overlap. If so, the scope of one entity (the inner scope) will end
2601 strictly before the scope of the other entity (the outer scope). Within the inner scope, the
2602 identifier designates the entity declared in the inner scope; the entity declared in the outer
2603 scope is hidden (and not visible) within the inner scope.
2605 Unless explicitly stated otherwise, where this International Standard uses the term
2606 ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
2607 entity in the relevant name space whose declaration is visible at the point the identifier
2608 occurs.
2610 Two identifiers have the same scope if and only if their scopes terminate at the same
2611 point.
2613 Structure, union, and enumeration tags have scope that begins just after the appearance of
2614 the tag in a type specifier that declares the tag. Each enumeration constant has scope that
2615 begins just after the appearance of its defining enumerator in an enumerator list. Any
2616 other identifier has scope that begins just after the completion of its declarator.
2618 As a special case, a type name (which is not a declaration of an identifier) is considered to
2619 have a scope that begins just after the place within the type name where the omitted
2620 identifier would appear were it not omitted.
2621 <p><b> Forward references</b>: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
2622 (<a href="#6.9.1">6.9.1</a>), identifiers (<a href="#6.4.2">6.4.2</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), name spaces of identifiers (<a href="#6.2.3">6.2.3</a>),
2628 An identifier declared in different scopes or in the same scope more than once can be
2629 made to refer to the same object or function by a process called linkage.<sup><a href="#note29"><b>29)</b></a></sup> There are
2630 three kinds of linkage: external, internal, and none.
2632 In the set of translation units and libraries that constitutes an entire program, each
2633 declaration of a particular identifier with external linkage denotes the same object or
2634 function. Within one translation unit, each declaration of an identifier with internal
2635 linkage denotes the same object or function. Each declaration of an identifier with no
2636 linkage denotes a unique entity.
2638 If the declaration of a file scope identifier for an object or a function contains the storage-
2639 class specifier static, the identifier has internal linkage.<sup><a href="#note30"><b>30)</b></a></sup>
2643 <!--page 55 -->
2645 For an identifier declared with the storage-class specifier extern in a scope in which a
2646 prior declaration of that identifier is visible,<sup><a href="#note31"><b>31)</b></a></sup> if the prior declaration specifies internal or
2647 external linkage, the linkage of the identifier at the later declaration is the same as the
2648 linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
2649 declaration specifies no linkage, then the identifier has external linkage.
2651 If the declaration of an identifier for a function has no storage-class specifier, its linkage
2652 is determined exactly as if it were declared with the storage-class specifier extern. If
2653 the declaration of an identifier for an object has file scope and no storage-class specifier,
2654 its linkage is external.
2656 The following identifiers have no linkage: an identifier declared to be anything other than
2657 an object or a function; an identifier declared to be a function parameter; a block scope
2658 identifier for an object declared without the storage-class specifier extern.
2660 If, within a translation unit, the same identifier appears with both internal and external
2661 linkage, the behavior is undefined.
2662 <p><b> Forward references</b>: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
2665 <p><b>Footnotes</b>
2666 <p><small><a name="note29" href="#note29">29)</a> There is no linkage between different identifiers.
2667 </small>
2668 <p><small><a name="note30" href="#note30">30)</a> A function declaration can contain the storage-class specifier static only if it is at file scope; see
2670 </small>
2671 <p><small><a name="note31" href="#note31">31)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
2672 </small>
2677 If more than one declaration of a particular identifier is visible at any point in a
2678 translation unit, the syntactic context disambiguates uses that refer to different entities.
2679 Thus, there are separate name spaces for various categories of identifiers, as follows:
2680 <ul>
2681 <li> label names (disambiguated by the syntax of the label declaration and use);
2682 <li> the tags of structures, unions, and enumerations (disambiguated by following any<sup><a href="#note32"><b>32)</b></a></sup>
2683 of the keywords struct, union, or enum);
2684 <li> the members of structures or unions; each structure or union has a separate name
2685 space for its members (disambiguated by the type of the expression used to access the
2686 member via the . or -> operator);
2687 <li> all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
2688 enumeration constants).
2689 </ul>
2690 <p><b> Forward references</b>: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
2691 structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>), tags
2694 <!--page 56 -->
2696 <p><b>Footnotes</b>
2697 <p><small><a name="note32" href="#note32">32)</a> There is only one name space for tags even though three are possible.
2698 </small>
2703 An object has a storage duration that determines its lifetime. There are four storage
2704 durations: static, thread, automatic, and allocated. Allocated storage is described in
2707 The lifetime of an object is the portion of program execution during which storage is
2708 guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note33"><b>33)</b></a></sup> and retains
2709 its last-stored value throughout its lifetime.<sup><a href="#note34"><b>34)</b></a></sup> If an object is referred to outside of its
2710 lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
2711 the object it points to (or just past) reaches the end of its lifetime.
2713 An object whose identifier is declared without the storage-class specifier
2714 _Thread_local, and either with external or internal linkage or with the storage-class
2715 specifier static, has static storage duration. Its lifetime is the entire execution of the
2716 program and its stored value is initialized only once, prior to program startup.
2718 An object whose identifier is declared with the storage-class specifier _Thread_local
2719 has thread storage duration. Its lifetime is the entire execution of the thread for which it
2720 is created, and its stored value is initialized when the thread is started. There is a distinct
2721 object per thread, and use of the declared name in an expression refers to the object
2722 associated with the thread evaluating the expression. The result of attempting to
2723 indirectly access an object with thread storage duration from a thread other than the one
2724 with which the object is associated is implementation-defined.
2726 An object whose identifier is declared with no linkage and without the storage-class
2727 specifier static has automatic storage duration, as do some compound literals. The
2728 result of attempting to indirectly access an object with automatic storage duration from a
2729 thread other than the one with which the object is associated is implementation-defined.
2731 For such an object that does not have a variable length array type, its lifetime extends
2732 from entry into the block with which it is associated until execution of that block ends in
2733 any way. (Entering an enclosed block or calling a function suspends, but does not end,
2734 execution of the current block.) If the block is entered recursively, a new instance of the
2735 object is created each time. The initial value of the object is indeterminate. If an
2736 initialization is specified for the object, it is performed each time the declaration or
2737 compound literal is reached in the execution of the block; otherwise, the value becomes
2738 indeterminate each time the declaration is reached.
2742 <!--page 57 -->
2744 For such an object that does have a variable length array type, its lifetime extends from
2745 the declaration of the object until execution of the program leaves the scope of the
2746 declaration.<sup><a href="#note35"><b>35)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
2747 each time. The initial value of the object is indeterminate.
2749 A non-lvalue expression with structure or union type, where the structure or union
2750 contains a member with array type (including, recursively, members of all contained
2751 structures and unions) refers to an object with automatic storage duration and temporary
2752 lifetime.<sup><a href="#note36"><b>36)</b></a></sup> Its lifetime begins when the expression is evaluated and its initial value is the
2753 value of the expression. Its lifetime ends when the evaluation of the containing full
2754 expression or full declarator ends. Any attempt to modify an object with temporary
2755 lifetime results in undefined behavior.
2756 <p><b> Forward references</b>: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), compound literals (<a href="#6.5.2.5">6.5.2.5</a>), declarators
2757 (<a href="#6.7.6">6.7.6</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), initialization (<a href="#6.7.9">6.7.9</a>), statements (<a href="#6.8">6.8</a>).
2759 <p><b>Footnotes</b>
2760 <p><small><a name="note33" href="#note33">33)</a> The term ''constant address'' means that two pointers to the object constructed at possibly different
2761 times will compare equal. The address may be different during two different executions of the same
2762 program.
2763 </small>
2764 <p><small><a name="note34" href="#note34">34)</a> In the case of a volatile object, the last store need not be explicit in the program.
2765 </small>
2766 <p><small><a name="note35" href="#note35">35)</a> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
2767 embedded block prior to the declaration, leaves the scope of the declaration.
2768 </small>
2769 <p><small><a name="note36" href="#note36">36)</a> The address of such an object is taken implicitly when an array member is accessed.
2770 </small>
2775 The meaning of a value stored in an object or returned by a function is determined by the
2776 type of the expression used to access it. (An identifier declared to be an object is the
2777 simplest such expression; the type is specified in the declaration of the identifier.) Types
2778 are partitioned into object types (types that describe objects) and function types (types
2779 that describe functions). At various points within a translation unit an object type may be
2780 incomplete (lacking sufficient information to determine the size of objects of that type) or
2783 An object declared as type _Bool is large enough to store the values 0 and 1.
2785 An object declared as type char is large enough to store any member of the basic
2786 execution character set. If a member of the basic execution character set is stored in a
2787 char object, its value is guaranteed to be nonnegative. If any other character is stored in
2788 a char object, the resulting value is implementation-defined but shall be within the range
2789 of values that can be represented in that type.
2791 There are five standard signed integer types, designated as signed char, short
2792 int, int, long int, and long long int. (These and other types may be
2793 designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
2794 implementation-defined extended signed integer types.<sup><a href="#note38"><b>38)</b></a></sup> The standard and extended
2795 signed integer types are collectively called signed integer types.<sup><a href="#note39"><b>39)</b></a></sup>
2797 <!--page 58 -->
2799 An object declared as type signed char occupies the same amount of storage as a
2800 ''plain'' char object. A ''plain'' int object has the natural size suggested by the
2801 architecture of the execution environment (large enough to contain any value in the range
2804 For each of the signed integer types, there is a corresponding (but different) unsigned
2805 integer type (designated with the keyword unsigned) that uses the same amount of
2806 storage (including sign information) and has the same alignment requirements. The type
2807 _Bool and the unsigned integer types that correspond to the standard signed integer
2808 types are the standard unsigned integer types. The unsigned integer types that
2809 correspond to the extended signed integer types are the extended unsigned integer types.
2810 The standard and extended unsigned integer types are collectively called unsigned integer
2813 The standard signed integer types and standard unsigned integer types are collectively
2814 called the standard integer types, the extended signed integer types and extended
2815 unsigned integer types are collectively called the extended integer types.
2817 For any two integer types with the same signedness and different integer conversion rank
2818 (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
2819 subrange of the values of the other type.
2821 The range of nonnegative values of a signed integer type is a subrange of the
2822 corresponding unsigned integer type, and the representation of the same value in each
2823 type is the same.<sup><a href="#note41"><b>41)</b></a></sup> A computation involving unsigned operands can never overflow,
2824 because a result that cannot be represented by the resulting unsigned integer type is
2825 reduced modulo the number that is one greater than the largest value that can be
2826 represented by the resulting type.
2828 There are three real floating types, designated as float, double, and long
2829 double.<sup><a href="#note42"><b>42)</b></a></sup> The set of values of the type float is a subset of the set of values of the
2830 type double; the set of values of the type double is a subset of the set of values of the
2831 type long double.
2834 <!--page 59 -->
2836 There are three complex types, designated as float _Complex, double
2837 _Complex, and long double _Complex.<sup><a href="#note43"><b>43)</b></a></sup> (Complex types are a conditional
2838 feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.) The real floating and
2839 complex types are collectively called the floating types.
2841 For each floating type there is a corresponding real type, which is always a real floating
2842 type. For real floating types, it is the same type. For complex types, it is the type given
2843 by deleting the keyword _Complex from the type name.
2845 Each complex type has the same representation and alignment requirements as an array
2846 type containing exactly two elements of the corresponding real type; the first element is
2847 equal to the real part, and the second element to the imaginary part, of the complex
2848 number.
2850 The type char, the signed and unsigned integer types, and the floating types are
2851 collectively called the basic types. The basic types are complete object types. Even if the
2852 implementation defines two or more basic types to have the same representation, they are
2855 The three types char, signed char, and unsigned char are collectively called
2856 the character types. The implementation shall define char to have the same range,
2857 representation, and behavior as either signed char or unsigned char.<sup><a href="#note45"><b>45)</b></a></sup>
2859 An enumeration comprises a set of named integer constant values. Each distinct
2860 enumeration constitutes a different enumerated type.
2862 The type char, the signed and unsigned integer types, and the enumerated types are
2863 collectively called integer types. The integer and real floating types are collectively called
2864 real types.
2866 Integer and floating types are collectively called arithmetic types. Each arithmetic type
2867 belongs to one type domain: the real type domain comprises the real types, the complex
2868 type domain comprises the complex types.
2870 The void type comprises an empty set of values; it is an incomplete object type that
2871 cannot be completed.
2875 <!--page 60 -->
2877 Any number of derived types can be constructed from the object and function types, as
2878 follows:
2879 <ul>
2880 <li> An array type describes a contiguously allocated nonempty set of objects with a
2881 particular member object type, called the element type. The element type shall be
2882 complete whenever the array type is specified. Array types are characterized by their
2883 element type and by the number of elements in the array. An array type is said to be
2884 derived from its element type, and if its element type is T , the array type is sometimes
2885 called ''array of T ''. The construction of an array type from an element type is called
2886 ''array type derivation''.
2887 <li> A structure type describes a sequentially allocated nonempty set of member objects
2888 (and, in certain circumstances, an incomplete array), each of which has an optionally
2889 specified name and possibly distinct type.
2890 <li> A union type describes an overlapping nonempty set of member objects, each of
2891 which has an optionally specified name and possibly distinct type.
2892 <li> A function type describes a function with specified return type. A function type is
2893 characterized by its return type and the number and types of its parameters. A
2894 function type is said to be derived from its return type, and if its return type is T , the
2895 function type is sometimes called ''function returning T ''. The construction of a
2896 function type from a return type is called ''function type derivation''.
2897 <li> A pointer type may be derived from a function type or an object type, called the
2898 referenced type. A pointer type describes an object whose value provides a reference
2899 to an entity of the referenced type. A pointer type derived from the referenced type T
2900 is sometimes called ''pointer to T ''. The construction of a pointer type from a
2901 referenced type is called ''pointer type derivation''. A pointer type is a complete
2902 object type.
2903 <li> An atomic type describes the type designated by the construct _Atomic ( type-
2904 name ). (Atomic types are a conditional feature that implementations need not
2906 </ul>
2907 These methods of constructing derived types can be applied recursively.
2909 Arithmetic types and pointer types are collectively called scalar types. Array and
2910 structure types are collectively called aggregate types.<sup><a href="#note46"><b>46)</b></a></sup>
2912 An array type of unknown size is an incomplete type. It is completed, for an identifier of
2913 that type, by specifying the size in a later declaration (with internal or external linkage).
2914 A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
2917 <!--page 61 -->
2918 type. It is completed, for all declarations of that type, by declaring the same structure or
2919 union tag with its defining content later in the same scope.
2921 A type has known constant size if the type is not incomplete and is not a variable length
2922 array type.
2924 Array, function, and pointer types are collectively called derived declarator types. A
2925 declarator type derivation from a type T is the construction of a derived declarator type
2926 from T by the application of an array-type, a function-type, or a pointer-type derivation to
2927 T.
2929 A type is characterized by its type category, which is either the outermost derivation of a
2930 derived type (as noted above in the construction of derived types), or the type itself if the
2931 type consists of no derived types.
2933 Any type so far mentioned is an unqualified type. Each unqualified type has several
2934 qualified versions of its type,<sup><a href="#note47"><b>47)</b></a></sup> corresponding to the combinations of one, two, or all
2935 three of the const, volatile, and restrict qualifiers. The qualified or unqualified
2936 versions of a type are distinct types that belong to the same type category and have the
2937 same representation and alignment requirements.<sup><a href="#note48"><b>48)</b></a></sup> A derived type is not qualified by the
2938 qualifiers (if any) of the type from which it is derived.
2940 Further, there is the _Atomic qualifier. The presence of the _Atomic qualifier
2941 designates an atomic type. The size, representation, and alignment of an atomic type
2942 need not be the same as those of the corresponding unqualified type. Therefore, this
2943 Standard explicitly uses the phrase ''atomic, qualified or unqualified type'' whenever the
2944 atomic version of a type is permitted along with the other qualified versions of a type.
2945 The phrase ''qualified or unqualified type'', without specific mention of atomic, does not
2946 include the atomic types.
2948 A pointer to void shall have the same representation and alignment requirements as a
2949 pointer to a character type.<sup><a href="#note48"><b>48)</b></a></sup> Similarly, pointers to qualified or unqualified versions of
2950 compatible types shall have the same representation and alignment requirements. All
2951 pointers to structure types shall have the same representation and alignment requirements
2952 as each other. All pointers to union types shall have the same representation and
2953 alignment requirements as each other. Pointers to other types need not have the same
2954 representation or alignment requirements.
2956 EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
2957 pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
2958 whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
2961 <!--page 62 -->
2962 qualified float'' and is a pointer to a qualified type.
2965 EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
2966 function returning struct tag''. The array has length five and the function has a single parameter of type
2967 float. Its type category is array.
2969 <p><b> Forward references</b>: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
2971 <p><b>Footnotes</b>
2972 <p><small><a name="note37" href="#note37">37)</a> A type may be incomplete or complete throughout an entire translation unit, or it may change states at
2973 different points within a translation unit.
2974 </small>
2975 <p><small><a name="note38" href="#note38">38)</a> Implementation-defined keywords shall have the form of an identifier reserved for any use as
2977 </small>
2978 <p><small><a name="note39" href="#note39">39)</a> Therefore, any statement in this Standard about signed integer types also applies to the extended
2979 signed integer types.
2980 </small>
2981 <p><small><a name="note40" href="#note40">40)</a> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
2982 unsigned integer types.
2983 </small>
2984 <p><small><a name="note41" href="#note41">41)</a> The same representation and alignment requirements are meant to imply interchangeability as
2985 arguments to functions, return values from functions, and members of unions.
2986 </small>
2987 <p><small><a name="note42" href="#note42">42)</a> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
2988 </small>
2989 <p><small><a name="note43" href="#note43">43)</a> A specification for imaginary types is in <a href="#G">annex G</a>.
2990 </small>
2991 <p><small><a name="note44" href="#note44">44)</a> An implementation may define new keywords that provide alternative ways to designate a basic (or
2992 any other) type; this does not violate the requirement that all basic types be different.
2993 Implementation-defined keywords shall have the form of an identifier reserved for any use as
2995 </small>
2996 <p><small><a name="note45" href="#note45">45)</a> CHAR_MIN, defined in <a href="#7.10"><limits.h></a>, will have one of the values 0 or SCHAR_MIN, and this can be
2997 used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
2998 other two and is not compatible with either.
2999 </small>
3000 <p><small><a name="note46" href="#note46">46)</a> Note that aggregate type does not include union type because an object with union type can only
3001 contain one member at a time.
3002 </small>
3003 <p><small><a name="note47" href="#note47">47)</a> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
3004 </small>
3005 <p><small><a name="note48" href="#note48">48)</a> The same representation and alignment requirements are meant to imply interchangeability as
3006 arguments to functions, return values from functions, and members of unions.
3007 </small>
3015 The representations of all types are unspecified except as stated in this subclause.
3017 Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
3018 the number, order, and encoding of which are either explicitly specified or
3019 implementation-defined.
3021 Values stored in unsigned bit-fields and objects of type unsigned char shall be
3024 Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
3025 bits, where n is the size of an object of that type, in bytes. The value may be copied into
3026 an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
3027 called the object representation of the value. Values stored in bit-fields consist of m bits,
3028 where m is the size specified for the bit-field. The object representation is the set of m
3029 bits the bit-field comprises in the addressable storage unit holding it. Two values (other
3030 than NaNs) with the same object representation compare equal, but values that compare
3031 equal may have different object representations.
3033 Certain object representations need not represent a value of the object type. If the stored
3034 value of an object has such a representation and is read by an lvalue expression that does
3035 not have character type, the behavior is undefined. If such a representation is produced
3036 by a side effect that modifies all or any part of the object by an lvalue expression that
3037 does not have character type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup> Such a representation is called
3038 a trap representation.
3040 When a value is stored in an object of structure or union type, including in a member
3041 object, the bytes of the object representation that correspond to any padding bytes take
3042 unspecified values.<sup><a href="#note51"><b>51)</b></a></sup> The value of a structure or union object is never a trap
3045 <!--page 63 -->
3046 representation, even though the value of a member of the structure or union object may be
3047 a trap representation.
3049 When a value is stored in a member of an object of union type, the bytes of the object
3050 representation that do not correspond to that member but do correspond to other members
3051 take unspecified values.
3053 Where an operator is applied to a value that has more than one object representation,
3054 which object representation is used shall not affect the value of the result.<sup><a href="#note52"><b>52)</b></a></sup> Where a
3055 value is stored in an object using a type that has more than one object representation for
3056 that value, it is unspecified which representation is used, but a trap representation shall
3057 not be generated.
3059 Loads and stores of objects with atomic types are done with
3060 memory_order_seq_cst semantics.
3061 <p><b> Forward references</b>: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
3062 designators (<a href="#6.3.2.1">6.3.2.1</a>), order and consistency (<a href="#7.17.3">7.17.3</a>).
3064 <p><b>Footnotes</b>
3065 <p><small><a name="note49" href="#note49">49)</a> A positional representation for integers that uses the binary digits 0 and 1, in which the values
3066 represented by successive bits are additive, begin with 1, and are multiplied by successive integral
3067 powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
3068 Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
3069 type unsigned char range from 0 to 2<sup>CHAR_BIT</sup> - 1.
3070 </small>
3071 <p><small><a name="note50" href="#note50">50)</a> Thus, an automatic variable can be initialized to a trap representation without causing undefined
3072 behavior, but the value of the variable cannot be used until a proper value is stored in it.
3073 </small>
3074 <p><small><a name="note51" href="#note51">51)</a> Thus, for example, structure assignment need not copy any padding bits.
3075 </small>
3076 <p><small><a name="note52" href="#note52">52)</a> It is possible for objects x and y with the same effective type T to have the same value when they are
3077 accessed as objects of type T, but to have different values in other contexts. In particular, if == is
3078 defined for type T, then x == y does not imply that memcmp(&x, &y, sizeof (T)) == 0.
3079 Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
3080 on values of type T may distinguish between them.
3081 </small>
3086 For unsigned integer types other than unsigned char, the bits of the object
3087 representation shall be divided into two groups: value bits and padding bits (there need
3088 not be any of the latter). If there are N value bits, each bit shall represent a different
3089 power of 2 between 1 and 2<sup>N - 1</sup>, so that objects of that type shall be capable of
3090 representing values from 0 to 2<sup>N</sup> - 1 using a pure binary representation; this shall be
3091 known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note53"><b>53)</b></a></sup>
3093 For signed integer types, the bits of the object representation shall be divided into three
3094 groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
3095 signed char shall not have any padding bits. There shall be exactly one sign bit.
3096 Each bit that is a value bit shall have the same value as the same bit in the object
3097 representation of the corresponding unsigned type (if there are M value bits in the signed
3098 type and N in the unsigned type, then M <= N ). If the sign bit is zero, it shall not affect
3100 <!--page 64 -->
3101 the resulting value. If the sign bit is one, the value shall be modified in one of the
3102 following ways:
3103 <ul>
3104 <li> the corresponding value with sign bit 0 is negated (sign and magnitude);
3105 <li> the sign bit has the value -(2<sup>M</sup>) (two's complement);
3106 <li> the sign bit has the value -(2<sup>M</sup>- 1) (ones' complement).
3107 </ul>
3108 Which of these applies is implementation-defined, as is whether the value with sign bit 1
3109 and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones'
3110 complement), is a trap representation or a normal value. In the case of sign and
3111 magnitude and ones' complement, if this representation is a normal value it is called a
3112 negative zero.
3114 If the implementation supports negative zeros, they shall be generated only by:
3115 <ul>
3116 <li> the &, |, ^, ~, <<, and >> operators with operands that produce such a value;
3117 <li> the +, -, *, /, and % operators where one operand is a negative zero and the result is
3118 zero;
3119 <li> compound assignment operators based on the above cases.
3120 </ul>
3121 It is unspecified whether these cases actually generate a negative zero or a normal zero,
3122 and whether a negative zero becomes a normal zero when stored in an object.
3124 If the implementation does not support negative zeros, the behavior of the &, |, ^, ~, <<,
3125 and >> operators with operands that would produce such a value is undefined.
3127 The values of any padding bits are unspecified.<sup><a href="#note54"><b>54)</b></a></sup> A valid (non-trap) object representation
3128 of a signed integer type where the sign bit is zero is a valid object representation of the
3129 corresponding unsigned type, and shall represent the same value. For any integer type,
3130 the object representation where all the bits are zero shall be a representation of the value
3131 zero in that type.
3133 The precision of an integer type is the number of bits it uses to represent values,
3134 excluding any sign and padding bits. The width of an integer type is the same but
3135 including any sign bit; thus for unsigned integer types the two values are the same, while
3136 for signed integer types the width is one greater than the precision.
3141 <!--page 65 -->
3143 <p><b>Footnotes</b>
3144 <p><small><a name="note53" href="#note53">53)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
3145 bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
3146 representation other than as part of an exceptional condition such as an overflow, and this cannot occur
3147 with unsigned types. All other combinations of padding bits are alternative object representations of
3148 the value specified by the value bits.
3149 </small>
3150 <p><small><a name="note54" href="#note54">54)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
3151 bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
3152 representation other than as part of an exceptional condition such as an overflow. All other
3153 combinations of padding bits are alternative object representations of the value specified by the value
3154 bits.
3155 </small>
3160 Two types have compatible type if their types are the same. Additional rules for
3161 determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
3162 in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.6">6.7.6</a> for declarators.<sup><a href="#note55"><b>55)</b></a></sup> Moreover, two structure,
3163 union, or enumerated types declared in separate translation units are compatible if their
3164 tags and members satisfy the following requirements: If one is declared with a tag, the
3165 other shall be declared with the same tag. If both are completed anywhere within their
3166 respective translation units, then the following additional requirements apply: there shall
3167 be a one-to-one correspondence between their members such that each pair of
3168 corresponding members are declared with compatible types; if one member of the pair is
3169 declared with an alignment specifier, the other is declared with an equivalent alignment
3170 specifier; and if one member of the pair is declared with a name, the other is declared
3171 with the same name. For two structures, corresponding members shall be declared in the
3172 same order. For two structures or unions, corresponding bit-fields shall have the same
3173 widths. For two enumerations, corresponding members shall have the same values.
3175 All declarations that refer to the same object or function shall have compatible type;
3176 otherwise, the behavior is undefined.
3178 A composite type can be constructed from two types that are compatible; it is a type that
3179 is compatible with both of the two types and satisfies the following conditions:
3180 <ul>
3181 <li> If both types are array types, the following rules are applied:
3182 <ul>
3183 <li> If one type is an array of known constant size, the composite type is an array of
3184 that size.
3185 <li> Otherwise, if one type is a variable length array whose size is specified by an
3186 expression that is not evaluated, the behavior is undefined.
3187 <li> Otherwise, if one type is a variable length array whose size is specified, the
3188 composite type is a variable length array of that size.
3189 <li> Otherwise, if one type is a variable length array of unspecified size, the composite
3190 type is a variable length array of unspecified size.
3191 <li> Otherwise, both types are arrays of unknown size and the composite type is an
3192 array of unknown size.
3193 </ul>
3194 The element type of the composite type is the composite type of the two element
3195 types.
3196 <li> If only one type is a function type with a parameter type list (a function prototype),
3197 the composite type is a function prototype with the parameter type list.
3200 <!--page 66 -->
3201 <li> If both types are function types with parameter type lists, the type of each parameter
3202 in the composite parameter type list is the composite type of the corresponding
3203 parameters.
3204 </ul>
3205 These rules apply recursively to the types from which the two types are derived.
3207 For an identifier with internal or external linkage declared in a scope in which a prior
3208 declaration of that identifier is visible,<sup><a href="#note56"><b>56)</b></a></sup> if the prior declaration specifies internal or
3209 external linkage, the type of the identifier at the later declaration becomes the composite
3210 type.
3213 EXAMPLE Given the following two file scope declarations:
3214 <pre>
3215 int f(int (*)(), double (*)[3]);
3216 int f(int (*)(char *), double (*)[]);
3217 </pre>
3218 The resulting composite type for the function is:
3219 <pre>
3220 int f(int (*)(char *), double (*)[3]);
3221 </pre>
3224 <p><b>Footnotes</b>
3225 <p><small><a name="note55" href="#note55">55)</a> Two types need not be identical to be compatible.
3226 </small>
3227 <p><small><a name="note56" href="#note56">56)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
3228 </small>
3233 Complete object types have alignment requirements which place restrictions on the
3234 addresses at which objects of that type may be allocated. An alignment is an
3235 implementation-defined integer value representing the number of bytes between
3236 successive addresses at which a given object can be allocated. An object type imposes an
3237 alignment requirement on every object of that type: stricter alignment can be requested
3238 using the _Alignas keyword.
3240 A fundamental alignment is represented by an alignment less than or equal to the greatest
3241 alignment supported by the implementation in all contexts, which is equal to
3242 _Alignof (max_align_t).
3244 An extended alignment is represented by an alignment greater than
3245 _Alignof (max_align_t). It is implementation-defined whether any extended
3246 alignments are supported and the contexts in which they are supported. A type having an
3247 extended alignment requirement is an over-aligned type.<sup><a href="#note57"><b>57)</b></a></sup>
3249 Alignments are represented as values of the type size_t. Valid alignments include only
3250 those values returned by an _Alignof expression for fundamental types, plus an
3251 additional implementation-defined set of values, which may be empty. Every valid
3252 alignment value shall be a nonnegative integral power of two.
3255 <!--page 67 -->
3257 Alignments have an order from weaker to stronger or stricter alignments. Stricter
3258 alignments have larger alignment values. An address that satisfies an alignment
3259 requirement also satisfies any weaker valid alignment requirement.
3261 The alignment requirement of a complete type can be queried using an _Alignof
3262 expression. The types char, signed char, and unsigned char shall have the
3263 weakest alignment requirement.
3265 Comparing alignments is meaningful and provides the obvious results:
3266 <ul>
3267 <li> Two alignments are equal when their numeric values are equal.
3268 <li> Two alignments are different when their numeric values are not equal.
3269 <li> When an alignment is larger than another it represents a stricter alignment.
3270 <!--page 68 -->
3271 </ul>
3273 <p><b>Footnotes</b>
3274 <p><small><a name="note57" href="#note57">57)</a> Every over-aligned type is, or contains, a structure or union type with a member to which an extended
3275 alignment has been applied.
3276 </small>
3281 Several operators convert operand values from one type to another automatically. This
3282 subclause specifies the result required from such an implicit conversion, as well as those
3283 that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
3284 the conversions performed by most ordinary operators; it is supplemented as required by
3287 Conversion of an operand value to a compatible type causes no change to the value or the
3288 representation.
3297 Every integer type has an integer conversion rank defined as follows:
3298 <ul>
3299 <li> No two signed integer types shall have the same rank, even if they have the same
3300 representation.
3301 <li> The rank of a signed integer type shall be greater than the rank of any signed integer
3302 type with less precision.
3303 <li> The rank of long long int shall be greater than the rank of long int, which
3304 shall be greater than the rank of int, which shall be greater than the rank of short
3305 int, which shall be greater than the rank of signed char.
3306 <li> The rank of any unsigned integer type shall equal the rank of the corresponding
3307 signed integer type, if any.
3308 <li> The rank of any standard integer type shall be greater than the rank of any extended
3309 integer type with the same width.
3310 <li> The rank of char shall equal the rank of signed char and unsigned char.
3311 <li> The rank of _Bool shall be less than the rank of all other standard integer types.
3312 <li> The rank of any enumerated type shall equal the rank of the compatible integer type
3314 <li> The rank of any extended signed integer type relative to another extended signed
3315 integer type with the same precision is implementation-defined, but still subject to the
3316 other rules for determining the integer conversion rank.
3317 <li> For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
3318 greater rank than T3, then T1 has greater rank than T3.
3319 </ul>
3321 The following may be used in an expression wherever an int or unsigned int may
3322 be used:
3323 <!--page 69 -->
3324 <ul>
3325 <li> An object or expression with an integer type (other than int or unsigned int)
3326 whose integer conversion rank is less than or equal to the rank of int and
3327 unsigned int.
3328 <li> A bit-field of type _Bool, int, signed int, or unsigned int.
3329 </ul>
3330 If an int can represent all values of the original type (as restricted by the width, for a
3331 bit-field), the value is converted to an int; otherwise, it is converted to an unsigned
3332 int. These are called the integer promotions.<sup><a href="#note58"><b>58)</b></a></sup> All other types are unchanged by the
3333 integer promotions.
3335 The integer promotions preserve value including sign. As discussed earlier, whether a
3336 ''plain'' char is treated as signed is implementation-defined.
3337 <p><b> Forward references</b>: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
3340 <p><b>Footnotes</b>
3341 <p><small><a name="note58" href="#note58">58)</a> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
3342 argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
3343 shift operators, as specified by their respective subclauses.
3344 </small>
3349 When any scalar value is converted to _Bool, the result is 0 if the value compares equal
3352 <p><b>Footnotes</b>
3353 <p><small><a name="note59" href="#note59">59)</a> NaNs do not compare equal to 0 and thus convert to 1.
3354 </small>
3359 When a value with integer type is converted to another integer type other than _Bool, if
3360 the value can be represented by the new type, it is unchanged.
3362 Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
3363 subtracting one more than the maximum value that can be represented in the new type
3366 Otherwise, the new type is signed and the value cannot be represented in it; either the
3367 result is implementation-defined or an implementation-defined signal is raised.
3369 <p><b>Footnotes</b>
3370 <p><small><a name="note60" href="#note60">60)</a> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
3371 </small>
3376 When a finite value of real floating type is converted to an integer type other than _Bool,
3377 the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
3378 the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note61"><b>61)</b></a></sup>
3381 <!--page 70 -->
3383 When a value of integer type is converted to a real floating type, if the value being
3384 converted can be represented exactly in the new type, it is unchanged. If the value being
3385 converted is in the range of values that can be represented but cannot be represented
3386 exactly, the result is either the nearest higher or nearest lower representable value, chosen
3387 in an implementation-defined manner. If the value being converted is outside the range of
3388 values that can be represented, the behavior is undefined. Results of some implicit
3389 conversions may be represented in greater range and precision than that required by the
3392 <p><b>Footnotes</b>
3393 <p><small><a name="note61" href="#note61">61)</a> The remaindering operation performed when a value of integer type is converted to unsigned type
3394 need not be performed when a value of real floating type is converted to unsigned type. Thus, the
3395 range of portable real floating values is (-1, Utype_MAX+1).
3396 </small>
3401 When a value of real floating type is converted to a real floating type, if the value being
3402 converted can be represented exactly in the new type, it is unchanged. If the value being
3403 converted is in the range of values that can be represented but cannot be represented
3404 exactly, the result is either the nearest higher or nearest lower representable value, chosen
3405 in an implementation-defined manner. If the value being converted is outside the range of
3406 values that can be represented, the behavior is undefined. Results of some implicit
3407 conversions may be represented in greater range and precision than that required by the
3413 When a value of complex type is converted to another complex type, both the real and
3414 imaginary parts follow the conversion rules for the corresponding real types.
3419 When a value of real type is converted to a complex type, the real part of the complex
3420 result value is determined by the rules of conversion to the corresponding real type and
3421 the imaginary part of the complex result value is a positive zero or an unsigned zero.
3423 When a value of complex type is converted to a real type, the imaginary part of the
3424 complex value is discarded and the value of the real part is converted according to the
3425 conversion rules for the corresponding real type.
3430 Many operators that expect operands of arithmetic type cause conversions and yield result
3431 types in a similar way. The purpose is to determine a common real type for the operands
3432 and result. For the specified operands, each operand is converted, without change of type
3433 domain, to a type whose corresponding real type is the common real type. Unless
3434 explicitly stated otherwise, the common real type is also the corresponding real type of
3435 the result, whose type domain is the type domain of the operands if they are the same,
3436 and complex otherwise. This pattern is called the usual arithmetic conversions:
3437 <!--page 71 -->
3438 <ul>
3439 <li> First, if the corresponding real type of either operand is long double, the other
3440 operand is converted, without change of type domain, to a type whose
3441 corresponding real type is long double.
3442 <li> Otherwise, if the corresponding real type of either operand is double, the other
3443 operand is converted, without change of type domain, to a type whose
3444 corresponding real type is double.
3445 <li> Otherwise, if the corresponding real type of either operand is float, the other
3446 operand is converted, without change of type domain, to a type whose
3448 <li> Otherwise, the integer promotions are performed on both operands. Then the
3449 following rules are applied to the promoted operands:
3450 <ul>
3451 <li> If both operands have the same type, then no further conversion is needed.
3452 <li> Otherwise, if both operands have signed integer types or both have unsigned
3453 integer types, the operand with the type of lesser integer conversion rank is
3454 converted to the type of the operand with greater rank.
3455 <li> Otherwise, if the operand that has unsigned integer type has rank greater or
3456 equal to the rank of the type of the other operand, then the operand with
3457 signed integer type is converted to the type of the operand with unsigned
3458 integer type.
3459 <li> Otherwise, if the type of the operand with signed integer type can represent
3460 all of the values of the type of the operand with unsigned integer type, then
3461 the operand with unsigned integer type is converted to the type of the
3462 operand with signed integer type.
3463 <li> Otherwise, both operands are converted to the unsigned integer type
3464 corresponding to the type of the operand with signed integer type.
3465 </ul>
3466 </ul>
3468 The values of floating operands and of the results of floating expressions may be
3469 represented in greater range and precision than that required by the type; the types are not
3475 <!--page 72 -->
3477 <p><b>Footnotes</b>
3478 <p><small><a name="note62" href="#note62">62)</a> For example, addition of a double _Complex and a float entails just the conversion of the
3479 float operand to double (and yields a double _Complex result).
3480 </small>
3481 <p><small><a name="note63" href="#note63">63)</a> The cast and assignment operators are still required to remove extra range and precision.
3482 </small>
3488 <h5><a name="6.3.2.1" href="#6.3.2.1">6.3.2.1 Lvalues, arrays, and function designators</a></h5>
3490 An lvalue is an expression (with an object type other than void) that potentially
3491 designates an object;<sup><a href="#note64"><b>64)</b></a></sup> if an lvalue does not designate an object when it is evaluated, the
3492 behavior is undefined. When an object is said to have a particular type, the type is
3493 specified by the lvalue used to designate the object. A modifiable lvalue is an lvalue that
3494 does not have array type, does not have an incomplete type, does not have a const-
3495 qualified type, and if it is a structure or union, does not have any member (including,
3496 recursively, any member or element of all contained aggregates or unions) with a const-
3497 qualified type.
3499 Except when it is the operand of the sizeof operator, the _Alignof operator, the
3500 unary & operator, the ++ operator, the -- operator, or the left operand of the . operator
3501 or an assignment operator, an lvalue that does not have array type is converted to the
3502 value stored in the designated object (and is no longer an lvalue); this is called lvalue
3503 conversion. If the lvalue has qualified type, the value has the unqualified version of the
3504 type of the lvalue; additionally, if the lvalue has atomic type, the value has the non-atomic
3505 version of the type of the lvalue; otherwise, the value has the type of the lvalue. If the
3506 lvalue has an incomplete type and does not have array type, the behavior is undefined. If
3507 the lvalue designates an object of automatic storage duration that could have been
3508 declared with the register storage class (never had its address taken), and that object
3509 is uninitialized (not declared with an initializer and no assignment to it has been
3510 performed prior to use), the behavior is undefined.
3512 Except when it is the operand of the sizeof operator, the _Alignof operator, or the
3513 unary & operator, or is a string literal used to initialize an array, an expression that has
3514 type ''array of type'' is converted to an expression with type ''pointer to type'' that points
3515 to the initial element of the array object and is not an lvalue. If the array object has
3516 register storage class, the behavior is undefined.
3518 A function designator is an expression that has function type. Except when it is the
3519 operand of the sizeof operator, the _Alignof operator,<sup><a href="#note65"><b>65)</b></a></sup> or the unary & operator, a
3520 function designator with type ''function returning type'' is converted to an expression that
3523 <!--page 73 -->
3524 has type ''pointer to function returning type''.
3525 <p><b> Forward references</b>: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
3526 (<a href="#6.5.16">6.5.16</a>), common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>), initialization (<a href="#6.7.9">6.7.9</a>), postfix
3527 increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
3528 (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof and _Alignof operators (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members
3531 <p><b>Footnotes</b>
3532 <p><small><a name="note64" href="#note64">64)</a> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
3533 operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
3534 object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
3535 as the ''value of an expression''.
3536 An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
3537 expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
3538 </small>
3539 <p><small><a name="note65" href="#note65">65)</a> Because this conversion does not occur, the operand of the sizeof or _Alignof operator remains
3541 </small>
3546 The (nonexistent) value of a void expression (an expression that has type void) shall not
3547 be used in any way, and implicit or explicit conversions (except to void) shall not be
3548 applied to such an expression. If an expression of any other type is evaluated as a void
3549 expression, its value or designator is discarded. (A void expression is evaluated for its
3550 side effects.)
3555 A pointer to void may be converted to or from a pointer to any object type. A pointer to
3556 any object type may be converted to a pointer to void and back again; the result shall
3557 compare equal to the original pointer.
3559 For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
3560 the q-qualified version of the type; the values stored in the original and converted pointers
3561 shall compare equal.
3563 An integer constant expression with the value 0, or such an expression cast to type
3564 void *, is called a null pointer constant.<sup><a href="#note66"><b>66)</b></a></sup> If a null pointer constant is converted to a
3565 pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
3566 to a pointer to any object or function.
3568 Conversion of a null pointer to another pointer type yields a null pointer of that type.
3569 Any two null pointers shall compare equal.
3571 An integer may be converted to any pointer type. Except as previously specified, the
3572 result is implementation-defined, might not be correctly aligned, might not point to an
3573 entity of the referenced type, and might be a trap representation.<sup><a href="#note67"><b>67)</b></a></sup>
3575 Any pointer type may be converted to an integer type. Except as previously specified, the
3576 result is implementation-defined. If the result cannot be represented in the integer type,
3577 the behavior is undefined. The result need not be in the range of values of any integer
3578 type.
3581 <!--page 74 -->
3583 A pointer to an object type may be converted to a pointer to a different object type. If the
3584 resulting pointer is not correctly aligned<sup><a href="#note68"><b>68)</b></a></sup> for the referenced type, the behavior is
3585 undefined. Otherwise, when converted back again, the result shall compare equal to the
3586 original pointer. When a pointer to an object is converted to a pointer to a character type,
3587 the result points to the lowest addressed byte of the object. Successive increments of the
3588 result, up to the size of the object, yield pointers to the remaining bytes of the object.
3590 A pointer to a function of one type may be converted to a pointer to a function of another
3591 type and back again; the result shall compare equal to the original pointer. If a converted
3592 pointer is used to call a function whose type is not compatible with the referenced type,
3593 the behavior is undefined.
3594 <p><b> Forward references</b>: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
3595 capable of holding object pointers (<a href="#7.20.1.4">7.20.1.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
3600 <!--page 75 -->
3602 <p><b>Footnotes</b>
3603 <p><small><a name="note66" href="#note66">66)</a> The macro NULL is defined in <a href="#7.19"><stddef.h></a> (and other headers) as a null pointer constant; see <a href="#7.19">7.19</a>.
3604 </small>
3605 <p><small><a name="note67" href="#note67">67)</a> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
3606 be consistent with the addressing structure of the execution environment.
3607 </small>
3608 <p><small><a name="note68" href="#note68">68)</a> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
3609 pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
3610 correctly aligned for a pointer to type C.
3611 </small>
3615 <p><b>Syntax</b>
3617 <pre>
3618 token:
3619 keyword
3620 identifier
3621 constant
3622 string-literal
3623 punctuator
3624 preprocessing-token:
3625 header-name
3626 identifier
3627 pp-number
3628 character-constant
3629 string-literal
3630 punctuator
3631 each non-white-space character that cannot be one of the above
3632 </pre>
3633 <p><b>Constraints</b>
3635 Each preprocessing token that is converted to a token shall have the lexical form of a
3636 keyword, an identifier, a constant, a string literal, or a punctuator.
3637 <p><b>Semantics</b>
3639 A token is the minimal lexical element of the language in translation phases 7 and 8. The
3640 categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
3641 A preprocessing token is the minimal lexical element of the language in translation
3642 phases 3 through 6. The categories of preprocessing tokens are: header names,
3643 identifiers, preprocessing numbers, character constants, string literals, punctuators, and
3644 single non-white-space characters that do not lexically match the other preprocessing
3645 token categories.<sup><a href="#note69"><b>69)</b></a></sup> If a ' or a " character matches the last category, the behavior is
3646 undefined. Preprocessing tokens can be separated by white space; this consists of
3647 comments (described later), or white-space characters (space, horizontal tab, new-line,
3648 vertical tab, and form-feed), or both. As described in <a href="#6.10">6.10</a>, in certain circumstances
3649 during translation phase 4, white space (or the absence thereof) serves as more than
3650 preprocessing token separation. White space may appear within a preprocessing token
3651 only as part of a header name or between the quotation characters in a character constant
3652 or string literal.
3656 <!--page 76 -->
3658 If the input stream has been parsed into preprocessing tokens up to a given character, the
3659 next preprocessing token is the longest sequence of characters that could constitute a
3660 preprocessing token. There is one exception to this rule: header name preprocessing
3661 tokens are recognized only within #include preprocessing directives and in
3662 implementation-defined locations within #pragma directives. In such contexts, a
3663 sequence of characters that could be either a header name or a string literal is recognized
3664 as the former.
3666 EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
3667 valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
3668 might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
3669 fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
3670 not E is a macro name.
3673 EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
3674 increment operators, even though the parse x ++ + ++ y might yield a correct expression.
3676 <p><b> Forward references</b>: character constants (<a href="#6.4.4.4">6.4.4.4</a>), comments (<a href="#6.4.9">6.4.9</a>), expressions (<a href="#6.5">6.5</a>),
3677 floating constants (<a href="#6.4.4.2">6.4.4.2</a>), header names (<a href="#6.4.7">6.4.7</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), postfix
3678 increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
3679 (<a href="#6.5.3.1">6.5.3.1</a>), preprocessing directives (<a href="#6.10">6.10</a>), preprocessing numbers (<a href="#6.4.8">6.4.8</a>), string literals
3683 <p><small><a name="note69" href="#note69">69)</a> An additional category, placemarkers, is used internally in translation phase 4 (see <a href="#6.10.3.3">6.10.3.3</a>); it cannot
3684 occur in source files.
3685 </small>
3691 <pre>
3692 keyword: one of
3693 auto if unsigned
3694 break inline void
3695 case int volatile
3696 char long while
3697 const register _Alignas
3698 continue restrict _Alignof
3699 default return _Atomic
3700 do short _Bool
3701 double signed _Complex
3702 else sizeof _Generic
3703 enum static _Imaginary
3704 extern struct _Noreturn
3705 float switch _Static_assert
3706 for typedef _Thread_local
3707 goto union
3708 </pre>
3712 keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
3713 <!--page 77 -->
3717 <p><small><a name="note70" href="#note70">70)</a> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
3718 </small>
3727 <pre>
3728 identifier:
3729 identifier-nondigit
3730 identifier identifier-nondigit
3731 identifier digit
3732 identifier-nondigit:
3733 nondigit
3734 universal-character-name
3735 other implementation-defined characters
3736 nondigit: one of
3737 _ a b c d e f g h i j k l m
3738 n o p q r s t u v w x y z
3739 A B C D E F G H I J K L M
3740 N O P Q R S T U V W X Y Z
3741 digit: one of
3742 0 1 2 3 4 5 6 7 8 9
3743 </pre>
3746 An identifier is a sequence of nondigit characters (including the underscore _, the
3747 lowercase and uppercase Latin letters, and other characters) and digits, which designates
3748 one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
3749 There is no specific limit on the maximum length of an identifier.
3751 Each universal character name in an identifier shall designate a character whose encoding
3752 in ISO/IEC 10646 falls into one of the ranges specified in D.1.<sup><a href="#note71"><b>71)</b></a></sup> The initial character
3753 shall not be a universal character name designating a character whose encoding falls into
3754 one of the ranges specified in <a href="#D.2">D.2</a>. An implementation may allow multibyte characters
3755 that are not part of the basic source character set to appear in identifiers; which characters
3756 and their correspondence to universal character names is implementation-defined.
3760 <!--page 78 -->
3762 When preprocessing tokens are converted to tokens during translation phase 7, if a
3763 preprocessing token could be converted to either a keyword or an identifier, it is converted
3764 to a keyword.
3767 As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
3768 characters in an identifier; the limit for an external name (an identifier that has external
3769 linkage) may be more restrictive than that for an internal name (a macro name or an
3770 identifier that does not have external linkage). The number of significant characters in an
3771 identifier is implementation-defined.
3773 Any identifiers that differ in a significant character are different identifiers. If two
3774 identifiers differ only in nonsignificant characters, the behavior is undefined.
3775 <p><b> Forward references</b>: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
3778 <p><small><a name="note71" href="#note71">71)</a> On systems in which linkers cannot accept extended characters, an encoding of the universal character
3779 name may be used in forming valid external identifiers. For example, some otherwise unused
3780 character or sequence of characters may be used to encode the \u in a universal character name.
3781 Extended characters may produce a long external identifier.
3782 </small>
3788 The identifier __func__ shall be implicitly declared by the translator as if,
3789 immediately following the opening brace of each function definition, the declaration
3790 <pre>
3791 static const char __func__[] = "function-name";
3792 </pre>
3793 appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note72"><b>72)</b></a></sup>
3795 This name is encoded as if the implicit declaration had been written in the source
3796 character set and then translated into the execution character set as indicated in translation
3797 phase 5.
3799 EXAMPLE Consider the code fragment:
3800 <pre>
3802 void myfunc(void)
3803 {
3804 printf("%s\n", __func__);
3805 /* ... */
3806 }
3807 </pre>
3808 Each time the function is called, it will print to the standard output stream:
3809 <pre>
3810 myfunc
3811 </pre>
3818 <!--page 79 -->
3821 <p><small><a name="note72" href="#note72">72)</a> Since the name __func__ is reserved for any use by the implementation (<a href="#7.1.3">7.1.3</a>), if any other
3822 identifier is explicitly declared using the name __func__, the behavior is undefined.
3823 </small>
3829 <pre>
3830 universal-character-name:
3831 \u hex-quad
3832 \U hex-quad hex-quad
3833 hex-quad:
3834 hexadecimal-digit hexadecimal-digit
3835 hexadecimal-digit hexadecimal-digit
3836 </pre>
3839 A universal character name shall not specify a character whose short identifier is less than
3844 Universal character names may be used in identifiers, character constants, and string
3845 literals to designate characters that are not in the basic character set.
3848 The universal character name \Unnnnnnnn designates the character whose eight-digit
3849 short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note74"><b>74)</b></a></sup> Similarly, the universal
3850 character name \unnnn designates the character whose four-digit short identifier is nnnn
3851 (and whose eight-digit short identifier is 0000nnnn).
3856 <!--page 80 -->
3859 <p><small><a name="note73" href="#note73">73)</a> The disallowed characters are the characters in the basic character set and the code positions reserved
3860 by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
3861 UTF-16).
3863 </small>
3864 <p><small><a name="note74" href="#note74">74)</a> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
3865 </small>
3871 <pre>
3872 constant:
3873 integer-constant
3874 floating-constant
3875 enumeration-constant
3876 character-constant
3877 </pre>
3880 Each constant shall have a type and the value of a constant shall be in the range of
3881 representable values for its type.
3884 Each constant has a type, determined by its form and value, as detailed later.
3890 <!--page 81 -->
3891 <pre>
3892 integer-constant:
3896 decimal-constant:
3897 nonzero-digit
3898 decimal-constant digit
3899 octal-constant:
3900 0
3901 octal-constant octal-digit
3902 hexadecimal-constant:
3903 hexadecimal-prefix hexadecimal-digit
3904 hexadecimal-constant hexadecimal-digit
3905 hexadecimal-prefix: one of
3907 nonzero-digit: one of
3908 1 2 3 4 5 6 7 8 9
3909 octal-digit: one of
3910 0 1 2 3 4 5 6 7
3911 hexadecimal-digit: one of
3912 0 1 2 3 4 5 6 7 8 9
3913 a b c d e f
3914 A B C D E F
3915 integer-suffix:
3917 unsigned-suffix long-long-suffix
3920 unsigned-suffix: one of
3921 u U
3922 long-suffix: one of
3923 l L
3924 long-long-suffix: one of
3925 ll LL
3926 </pre>
3929 An integer constant begins with a digit, but has no period or exponent part. It may have a
3930 prefix that specifies its base and a suffix that specifies its type.
3932 A decimal constant begins with a nonzero digit and consists of a sequence of decimal
3933 digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
3935 by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
3940 that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
3942 The type of an integer constant is the first of the corresponding list in which its value can
3943 be represented.
3944 <!--page 82 -->
3947 <tr><td> none
3948 <td><pre>
3949 int
3950 long int
3951 long long int
3952 </pre>
3953 <td><pre>
3954 int
3955 unsigned int
3956 long int
3957 unsigned long int
3958 long long int
3959 unsigned long long int
3960 </pre>
3961 <tr><td> u or U
3962 <td><pre>
3963 unsigned int
3964 unsigned long int
3965 unsigned long long int
3966 </pre>
3967 <td><pre>
3968 unsigned int
3969 unsigned long int
3970 unsigned long long int
3971 </pre>
3972 <tr><td> l or L
3973 <td><pre>
3974 long int
3975 long long int
3976 </pre>
3977 <td><pre>
3978 long int
3979 unsigned long int
3980 long long int
3981 unsigned long long int
3982 </pre>
3983 <tr><td> Both u or U and l or L
3984 <td><pre>
3985 unsigned long int
3986 unsigned long long int
3987 </pre>
3988 <td><pre>
3989 unsigned long int
3990 unsigned long long int
3991 </pre>
3992 <tr><td> ll or LL
3993 <td><pre>
3994 long long int
3995 </pre>
3996 <td><pre>
3997 long long int
3998 unsigned long long int
3999 </pre>
4000 <tr><td> Both u or U and ll or LL
4001 <td><pre>
4002 unsigned long long int
4003 </pre>
4004 <td><pre>
4005 unsigned long long int
4006 </pre>
4007 </table>
4009 If an integer constant cannot be represented by any type in its list, it may have an
4010 extended integer type, if the extended integer type can represent its value. If all of the
4011 types in the list for the constant are signed, the extended integer type shall be signed. If
4012 all of the types in the list for the constant are unsigned, the extended integer type shall be
4013 unsigned. If the list contains both signed and unsigned types, the extended integer type
4014 may be signed or unsigned. If an integer constant cannot be represented by any type in
4015 its list and has no extended integer type, then the integer constant has no type.
4016 <!--page 83 -->
4022 <!--page 84 -->
4023 <pre>
4024 floating-constant:
4025 decimal-floating-constant
4026 hexadecimal-floating-constant
4027 decimal-floating-constant:
4030 hexadecimal-floating-constant:
4031 hexadecimal-prefix hexadecimal-fractional-constant
4033 hexadecimal-prefix hexadecimal-digit-sequence
4035 fractional-constant:
4037 digit-sequence .
4038 exponent-part:
4041 sign: one of
4042 + -
4043 digit-sequence:
4044 digit
4045 digit-sequence digit
4046 hexadecimal-fractional-constant:
4048 hexadecimal-digit-sequence
4049 hexadecimal-digit-sequence .
4050 binary-exponent-part:
4053 hexadecimal-digit-sequence:
4054 hexadecimal-digit
4055 hexadecimal-digit-sequence hexadecimal-digit
4056 floating-suffix: one of
4057 f l F L
4058 </pre>
4061 A floating constant has a significand part that may be followed by an exponent part and a
4062 suffix that specifies its type. The components of the significand part may include a digit
4063 sequence representing the whole-number part, followed by a period (.), followed by a
4064 digit sequence representing the fraction part. The components of the exponent part are an
4065 e, E, p, or P followed by an exponent consisting of an optionally signed digit sequence.
4066 Either the whole-number part or the fraction part has to be present; for decimal floating
4067 constants, either the period or the exponent part has to be present.
4070 The significand part is interpreted as a (decimal or hexadecimal) rational number; the
4071 digit sequence in the exponent part is interpreted as a decimal integer. For decimal
4072 floating constants, the exponent indicates the power of 10 by which the significand part is
4073 to be scaled. For hexadecimal floating constants, the exponent indicates the power of 2
4074 by which the significand part is to be scaled. For decimal floating constants, and also for
4075 hexadecimal floating constants when FLT_RADIX is not a power of 2, the result is either
4076 the nearest representable value, or the larger or smaller representable value immediately
4077 adjacent to the nearest representable value, chosen in an implementation-defined manner.
4078 For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
4079 correctly rounded.
4081 An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
4082 type float. If suffixed by the letter l or L, it has type long double.
4084 Floating constants are converted to internal format as if at translation-time. The
4085 conversion of a floating constant shall not raise an exceptional condition or a floating-
4086 point exception at execution time. All floating constants of the same source form<sup><a href="#note75"><b>75)</b></a></sup> shall
4087 convert to the same internal format with the same value.
4090 The implementation should produce a diagnostic message if a hexadecimal constant
4091 cannot be represented exactly in its evaluation format; the implementation should then
4092 proceed with the translation of the program.
4094 The translation-time conversion of floating constants should match the execution-time
4095 conversion of character strings by library functions, such as strtod, given matching
4096 inputs suitable for both conversions, the same result format, and default execution-time
4099 <!--page 85 -->
4102 <p><small><a name="note75" href="#note75">75)</a> <a href="#1.23">1.23</a>, 1.230, 123e-2, 123e-02, and 1.23L are all different source forms and thus need not
4103 convert to the same internal format and value.
4104 </small>
4105 <p><small><a name="note76" href="#note76">76)</a> The specification for the library functions recommends more accurate conversion than required for
4107 </small>
4113 <pre>
4114 enumeration-constant:
4115 identifier
4116 </pre>
4119 An identifier declared as an enumeration constant has type int.
4126 <!--page 86 -->
4127 <pre>
4128 character-constant:
4129 ' c-char-sequence '
4130 L' c-char-sequence '
4131 u' c-char-sequence '
4132 U' c-char-sequence '
4133 c-char-sequence:
4134 c-char
4135 c-char-sequence c-char
4136 c-char:
4137 any member of the source character set except
4138 the single-quote ', backslash \, or new-line character
4139 escape-sequence
4140 escape-sequence:
4141 simple-escape-sequence
4142 octal-escape-sequence
4143 hexadecimal-escape-sequence
4144 universal-character-name
4145 simple-escape-sequence: one of
4146 \' \" \? \\
4147 \a \b \f \n \r \t \v
4148 octal-escape-sequence:
4149 \ octal-digit
4150 \ octal-digit octal-digit
4151 \ octal-digit octal-digit octal-digit
4152 hexadecimal-escape-sequence:
4153 \x hexadecimal-digit
4154 hexadecimal-escape-sequence hexadecimal-digit
4155 </pre>
4156 <p><b>Description</b>
4158 An integer character constant is a sequence of one or more multibyte characters enclosed
4159 in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
4160 letter L, u, or U. With a few exceptions detailed later, the elements of the sequence are
4161 any members of the source character set; they are mapped in an implementation-defined
4162 manner to members of the execution character set.
4164 The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
4165 arbitrary integer values are representable according to the following table of escape
4166 sequences:
4167 <pre>
4168 single quote ' \'
4169 double quote " \"
4170 question mark ? \?
4171 backslash \ \\
4172 octal character \octal digits
4173 hexadecimal character \x hexadecimal digits
4174 </pre>
4176 The double-quote " and question-mark ? are representable either by themselves or by the
4177 escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
4178 shall be represented, respectively, by the escape sequences \' and \\.
4180 The octal digits that follow the backslash in an octal escape sequence are taken to be part
4181 of the construction of a single character for an integer character constant or of a single
4182 wide character for a wide character constant. The numerical value of the octal integer so
4183 formed specifies the value of the desired character or wide character.
4185 The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
4186 sequence are taken to be part of the construction of a single character for an integer
4187 character constant or of a single wide character for a wide character constant. The
4188 numerical value of the hexadecimal integer so formed specifies the value of the desired
4189 character or wide character.
4191 Each octal or hexadecimal escape sequence is the longest sequence of characters that can
4192 constitute the escape sequence.
4194 In addition, characters not in the basic character set are representable by universal
4195 character names and certain nongraphic characters are representable by escape sequences
4196 consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
4198 <!--page 87 -->
4201 The value of an octal or hexadecimal escape sequence shall be in the range of
4202 representable values for the corresponding type:
4209 </table>
4212 An integer character constant has type int. The value of an integer character constant
4213 containing a single character that maps to a single-byte execution character is the
4214 numerical value of the representation of the mapped character interpreted as an integer.
4215 The value of an integer character constant containing more than one character (e.g.,
4216 'ab'), or containing a character or escape sequence that does not map to a single-byte
4217 execution character, is implementation-defined. If an integer character constant contains
4218 a single character or escape sequence, its value is the one that results when an object with
4219 type char whose value is that of the single character or escape sequence is converted to
4220 type int.
4222 A wide character constant prefixed by the letter L has type wchar_t, an integer type
4223 defined in the <a href="#7.19"><stddef.h></a> header; a wide character constant prefixed by the letter u or
4224 U has type char16_t or char32_t, respectively, unsigned integer types defined in the
4225 <a href="#7.28"><uchar.h></a> header. The value of a wide character constant containing a single
4226 multibyte character that maps to a single member of the extended execution character set
4227 is the wide character corresponding to that multibyte character, as defined by the
4228 mbtowc, mbrtoc16, or mbrtoc32 function as appropriate for its type, with an
4229 implementation-defined current locale. The value of a wide character constant containing
4230 more than one multibyte character or a single multibyte character that maps to multiple
4231 members of the extended execution character set, or containing a multibyte character or
4232 escape sequence not represented in the extended execution character set, is
4233 implementation-defined.
4238 EXAMPLE 2 Consider implementations that use two's complement representation for integers and eight
4239 bits for objects that have type char. In an implementation in which type char has the same range of
4240 values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
4241 same range of values as unsigned char, the character constant '\xFF' has the value +255.
4246 <!--page 88 -->
4248 EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
4249 specifies an integer character constant containing only one character, since a hexadecimal escape sequence
4250 is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
4251 two characters whose values are '\x12' and '3', the construction '\0223' may be used, since an octal
4252 escape sequence is terminated after three octal digits. (The value of this two-character integer character
4253 constant is implementation-defined.)
4256 EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
4257 L'\1234' specifies the implementation-defined value that results from the combination of the values
4260 <p><b> Forward references</b>: common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>), the mbtowc function
4261 (<a href="#7.22.7.2">7.22.7.2</a>), Unicode utilities <a href="#7.28"><uchar.h></a> (<a href="#7.28">7.28</a>).
4264 <p><small><a name="note77" href="#note77">77)</a> The semantics of these characters were discussed in <a href="#5.2.2">5.2.2</a>. If any other character follows a backslash,
4265 the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
4266 </small>
4272 <pre>
4273 string-literal:
4275 encoding-prefix:
4276 u8
4277 u
4278 U
4279 L
4280 s-char-sequence:
4281 s-char
4282 s-char-sequence s-char
4283 s-char:
4284 any member of the source character set except
4285 the double-quote ", backslash \, or new-line character
4286 escape-sequence
4287 </pre>
4288 <p><b>Constraints</b>
4290 A sequence of adjacent string literal tokens shall not include both a wide string literal and
4291 a UTF-8 string literal.
4292 <p><b>Description</b>
4294 A character string literal is a sequence of zero or more multibyte characters enclosed in
4296 A wide string literal is the same, except prefixed by the letter L, u, or U.
4298 The same considerations apply to each element of the sequence in a string literal as if it
4299 were in an integer character constant (for a character or UTF-8 string literal) or a wide
4300 character constant (for a wide string literal), except that the single-quote ' is
4301 representable either by itself or by the escape sequence \', but the double-quote " shall
4302 <!--page 89 -->
4303 be represented by the escape sequence \".
4304 <p><b>Semantics</b>
4306 In translation phase 6, the multibyte character sequences specified by any sequence of
4307 adjacent character and identically-prefixed string literal tokens are concatenated into a
4308 single multibyte character sequence. If any of the tokens has an encoding prefix, the
4309 resulting multibyte character sequence is treated as having the same prefix; otherwise, it
4310 is treated as a character string literal. Whether differently-prefixed wide string literal
4311 tokens can be concatenated and, if so, the treatment of the resulting multibyte character
4312 sequence are implementation-defined.
4314 In translation phase 7, a byte or code of value zero is appended to each multibyte
4315 character sequence that results from a string literal or literals.<sup><a href="#note78"><b>78)</b></a></sup> The multibyte character
4316 sequence is then used to initialize an array of static storage duration and length just
4317 sufficient to contain the sequence. For character string literals, the array elements have
4318 type char, and are initialized with the individual bytes of the multibyte character
4319 sequence. For UTF-8 string literals, the array elements have type char, and are
4320 initialized with the characters of the multibyte character sequence, as encoded in UTF-8.
4321 For wide string literals prefixed by the letter L, the array elements have type wchar_t
4322 and are initialized with the sequence of wide characters corresponding to the multibyte
4323 character sequence, as defined by the mbstowcs function with an implementation-
4324 defined current locale. For wide string literals prefixed by the letter u or U, the array
4325 elements have type char16_t or char32_t, respectively, and are initialized with the
4326 sequence of wide characters corresponding to the multibyte character sequence, as
4327 defined by successive calls to the mbrtoc16, or mbrtoc32 function as appropriate for
4328 its type, with an implementation-defined current locale. The value of a string literal
4329 containing a multibyte character or escape sequence not represented in the execution
4330 character set is implementation-defined.
4332 It is unspecified whether these arrays are distinct provided their elements have the
4333 appropriate values. If the program attempts to modify such an array, the behavior is
4334 undefined.
4336 EXAMPLE 1 This pair of adjacent character string literals
4337 <pre>
4339 </pre>
4340 produces a single character string literal containing the two characters whose values are '\x12' and '3',
4341 because escape sequences are converted into single members of the execution character set just prior to
4342 adjacent string literal concatenation.
4345 EXAMPLE 2 Each of the sequences of adjacent string literal tokens
4349 <!--page 90 -->
4350 <pre>
4355 </pre>
4356 is equivalent to the string literal
4357 <pre>
4359 </pre>
4360 Likewise, each of the sequences
4361 <pre>
4366 </pre>
4367 is equivalent to
4368 <pre>
4370 </pre>
4372 <p><b> Forward references</b>: common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>), the mbstowcs
4373 function (<a href="#7.22.8.1">7.22.8.1</a>), Unicode utilities <a href="#7.28"><uchar.h></a> (<a href="#7.28">7.28</a>).
4375 <p><b>Footnotes</b>
4376 <p><small><a name="note78" href="#note78">78)</a> A string literal need not be a string (see <a href="#7.1.1">7.1.1</a>), because a null character may be embedded in it by a
4377 \0 escape sequence.
4378 </small>
4382 <p><b>Syntax</b>
4384 <pre>
4385 punctuator: one of
4386 [ ] ( ) { } . ->
4387 ++ -- & * + - ~ !
4388 / % << >> < > <= >= == != ^ | && ||
4389 ? : ; ...
4390 = *= /= %= += -= <<= >>= &= ^= |=
4391 , # ##
4392 <: :> <% %> %: %:%:
4393 </pre>
4394 <p><b>Semantics</b>
4396 A punctuator is a symbol that has independent syntactic and semantic significance.
4397 Depending on context, it may specify an operation to be performed (which in turn may
4398 yield a value or a function designator, produce a side effect, or some combination thereof)
4399 in which case it is known as an operator (other forms of operator also exist in some
4400 contexts). An operand is an entity on which an operator acts.
4401 <!--page 91 -->
4404 <pre>
4405 <: :> <% %> %: %:%:
4406 </pre>
4407 behave, respectively, the same as the six tokens
4408 <pre>
4409 [ ] { } # ##
4410 </pre>
4412 <p><b> Forward references</b>: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
4415 <p><b>Footnotes</b>
4416 <p><small><a name="note79" href="#note79">79)</a> These tokens are sometimes called ''digraphs''.
4417 </small>
4418 <p><small><a name="note80" href="#note80">80)</a> Thus [ and <: behave differently when ''stringized'' (see <a href="#6.10.3.2">6.10.3.2</a>), but can otherwise be freely
4419 interchanged.
4420 </small>
4424 <p><b>Syntax</b>
4426 <pre>
4427 header-name:
4428 < h-char-sequence >
4430 h-char-sequence:
4431 h-char
4432 h-char-sequence h-char
4433 h-char:
4434 any member of the source character set except
4435 the new-line character and >
4436 q-char-sequence:
4437 q-char
4438 q-char-sequence q-char
4439 q-char:
4440 any member of the source character set except
4441 the new-line character and "
4442 </pre>
4445 The sequences in both forms of header names are mapped in an implementation-defined
4448 If the characters ', \, ", //, or /* occur in the sequence between the < and > delimiters,
4449 the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
4454 <!--page 92 -->
4455 sequence between the " delimiters, the behavior is undefined.<sup><a href="#note81"><b>81)</b></a></sup> Header name
4456 preprocessing tokens are recognized only within #include preprocessing directives and
4457 in implementation-defined locations within #pragma directives.<sup><a href="#note82"><b>82)</b></a></sup>
4459 EXAMPLE The following sequence of characters:
4460 <pre>
4463 #define const.member@$
4464 </pre>
4465 forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
4466 by a { on the left and a } on the right).
4467 <pre>
4470 {#}{define} {const}{.}{member}{@}{$}
4471 </pre>
4476 <p><small><a name="note81" href="#note81">81)</a> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
4477 </small>
4478 <p><small><a name="note82" href="#note82">82)</a> For an example of a header name preprocessing token used in a #pragma directive, see <a href="#6.10.9">6.10.9</a>.
4479 </small>
4485 <pre>
4486 pp-number:
4487 digit
4488 . digit
4489 pp-number digit
4490 pp-number identifier-nondigit
4491 pp-number e sign
4492 pp-number E sign
4493 pp-number p sign
4494 pp-number P sign
4495 pp-number .
4496 </pre>
4499 A preprocessing number begins with a digit optionally preceded by a period (.) and may
4500 be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
4501 p+, p-, P+, or P-.
4503 Preprocessing number tokens lexically include all floating and integer constant tokens.
4506 A preprocessing number does not have type or a value; it acquires both after a successful
4507 conversion (as part of translation phase 7) to a floating constant token or an integer
4508 constant token.
4511 <!--page 93 -->
4516 Except within a character constant, a string literal, or a comment, the characters /*
4517 introduce a comment. The contents of such a comment are examined only to identify
4518 multibyte characters and to find the characters */ that terminate it.<sup><a href="#note83"><b>83)</b></a></sup>
4520 Except within a character constant, a string literal, or a comment, the characters //
4521 introduce a comment that includes all multibyte characters up to, but not including, the
4522 next new-line character. The contents of such a comment are examined only to identify
4523 multibyte characters and to find the terminating new-line character.
4525 EXAMPLE
4526 <pre>
4527 "a//b" // four-character string literal
4528 #include "//e" // undefined behavior
4529 // */ // comment, not syntax error
4530 f = g/**//h; // equivalent to f = g / h;
4531 //\
4532 i(); // part of a two-line comment
4533 /\
4534 / j(); // part of a two-line comment
4535 #define glue(x,y) x##y
4536 glue(/,/) k(); // syntax error, not comment
4537 /*//*/ l(); // equivalent to l();
4538 m = n//**/o
4539 + p; // equivalent to m = n + p;
4540 </pre>
4545 <!--page 94 -->
4549 </small>
4554 An expression is a sequence of operators and operands that specifies computation of a
4555 value, or that designates an object or a function, or that generates side effects, or that
4556 performs a combination thereof. The value computations of the operands of an operator
4557 are sequenced before the value computation of the result of the operator.
4559 If a side effect on a scalar object is unsequenced relative to either a different side effect
4560 on the same scalar object or a value computation using the value of the same scalar
4561 object, the behavior is undefined. If there are multiple allowable orderings of the
4562 subexpressions of an expression, the behavior is undefined if such an unsequenced side
4565 The grouping of operators and operands is indicated by the syntax.<sup><a href="#note85"><b>85)</b></a></sup> Except as specified
4566 later, side effects and value computations of subexpressions are unsequenced.<sup><a href="#note86"><b>86)</b></a></sup>
4568 Some operators (the unary operator ~, and the binary operators <<, >>, &, ^, and |,
4569 collectively described as bitwise operators) are required to have operands that have
4570 integer type. These operators yield values that depend on the internal representations of
4571 integers, and have implementation-defined and undefined aspects for signed types.
4573 If an exceptional condition occurs during the evaluation of an expression (that is, if the
4574 result is not mathematically defined or not in the range of representable values for its
4575 type), the behavior is undefined.
4579 <!--page 95 -->
4581 The effective type of an object for an access to its stored value is the declared type of the
4582 object, if any.<sup><a href="#note87"><b>87)</b></a></sup> If a value is stored into an object having no declared type through an
4583 lvalue having a type that is not a character type, then the type of the lvalue becomes the
4584 effective type of the object for that access and for subsequent accesses that do not modify
4585 the stored value. If a value is copied into an object having no declared type using
4586 memcpy or memmove, or is copied as an array of character type, then the effective type
4587 of the modified object for that access and for subsequent accesses that do not modify the
4588 value is the effective type of the object from which the value is copied, if it has one. For
4589 all other accesses to an object having no declared type, the effective type of the object is
4590 simply the type of the lvalue used for the access.
4592 An object shall have its stored value accessed only by an lvalue expression that has one of
4594 <ul>
4595 <li> a type compatible with the effective type of the object,
4596 <li> a qualified version of a type compatible with the effective type of the object,
4597 <li> a type that is the signed or unsigned type corresponding to the effective type of the
4598 object,
4599 <li> a type that is the signed or unsigned type corresponding to a qualified version of the
4600 effective type of the object,
4601 <li> an aggregate or union type that includes one of the aforementioned types among its
4602 members (including, recursively, a member of a subaggregate or contained union), or
4603 <li> a character type.
4604 </ul>
4606 A floating expression may be contracted, that is, evaluated as though it were a single
4607 operation, thereby omitting rounding errors implied by the source code and the
4608 expression evaluation method.<sup><a href="#note89"><b>89)</b></a></sup> The FP_CONTRACT pragma in <a href="#7.12"><math.h></a> provides a
4609 way to disallow contracted expressions. Otherwise, whether and how expressions are
4611 <p><b> Forward references</b>: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.24.2">7.24.2</a>).
4614 <!--page 96 -->
4617 <p><small><a name="note84" href="#note84">84)</a> This paragraph renders undefined statement expressions such as
4619 <pre>
4620 i = ++i + 1;
4621 a[i++] = i;
4622 </pre>
4623 while allowing
4625 <pre>
4626 i = i + 1;
4627 a[i] = i;
4628 </pre>
4630 </small>
4631 <p><small><a name="note85" href="#note85">85)</a> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
4632 as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
4633 expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
4634 <a href="#6.5.1">6.5.1</a> through <a href="#6.5.6">6.5.6</a>. The exceptions are cast expressions (<a href="#6.5.4">6.5.4</a>) as operands of unary operators
4635 (<a href="#6.5.3">6.5.3</a>), and an operand contained between any of the following pairs of operators: grouping
4636 parentheses () (<a href="#6.5.1">6.5.1</a>), subscripting brackets [] (<a href="#6.5.2.1">6.5.2.1</a>), function-call parentheses () (<a href="#6.5.2.2">6.5.2.2</a>), and
4638 Within each major subclause, the operators have the same precedence. Left- or right-associativity is
4639 indicated in each subclause by the syntax for the expressions discussed therein.
4640 </small>
4641 <p><small><a name="note86" href="#note86">86)</a> In an expression that is evaluated more than once during the execution of a program, unsequenced and
4642 indeterminately sequenced evaluations of its subexpressions need not be performed consistently in
4643 different evaluations.
4644 </small>
4646 </small>
4647 <p><small><a name="note88" href="#note88">88)</a> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
4648 </small>
4649 <p><small><a name="note89" href="#note89">89)</a> The intermediate operations in the contracted expression are evaluated as if to infinite range and
4650 precision, while the final operation is rounded to the format determined by the expression evaluation
4651 method. A contracted expression might also omit the raising of floating-point exceptions.
4652 </small>
4653 <p><small><a name="note90" href="#note90">90)</a> This license is specifically intended to allow implementations to exploit fast machine instructions that
4654 combine multiple C operators. As contractions potentially undermine predictability, and can even
4655 decrease accuracy for containing expressions, their use needs to be well-defined and clearly
4656 documented.
4657 </small>
4663 <pre>
4664 primary-expression:
4665 identifier
4666 constant
4667 string-literal
4668 ( expression )
4669 generic-selection
4670 </pre>
4673 An identifier is a primary expression, provided it has been declared as designating an
4674 object (in which case it is an lvalue) or a function (in which case it is a function
4677 A constant is a primary expression. Its type depends on its form and value, as detailed in
4680 A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
4682 A parenthesized expression is a primary expression. Its type and value are identical to
4683 those of the unparenthesized expression. It is an lvalue, a function designator, or a void
4684 expression if the unparenthesized expression is, respectively, an lvalue, a function
4685 designator, or a void expression.
4687 A generic selection is a primary expression. Its type and value depend on the selected
4688 generic association, as detailed in the following subclause.
4692 <p><small><a name="note91" href="#note91">91)</a> Thus, an undeclared identifier is a violation of the syntax.
4693 </small>
4699 <pre>
4700 generic-selection:
4701 _Generic ( assignment-expression , generic-assoc-list )
4702 generic-assoc-list:
4703 generic-association
4704 generic-assoc-list , generic-association
4705 generic-association:
4706 type-name : assignment-expression
4707 default : assignment-expression
4708 </pre>
4712 <!--page 97 -->
4715 A generic selection shall have no more than one default generic association. The type
4716 name in a generic association shall specify a complete object type other than a variably
4717 modified type. No two generic associations in the same generic selection shall specify
4718 compatible types. The controlling expression of a generic selection shall have type
4719 compatible with at most one of the types named in its generic association list. If a
4720 generic selection has no default generic association, its controlling expression shall
4721 have type compatible with exactly one of the types named in its generic association list.
4724 The controlling expression of a generic selection is not evaluated. If a generic selection
4725 has a generic association with a type name that is compatible with the type of the
4726 controlling expression, then the result expression of the generic selection is the
4727 expression in that generic association. Otherwise, the result expression of the generic
4728 selection is the expression in the default generic association. None of the expressions
4729 from any other generic association of the generic selection is evaluated.
4731 The type and value of a generic selection are identical to those of its result expression. It
4732 is an lvalue, a function designator, or a void expression if its result expression is,
4733 respectively, an lvalue, a function designator, or a void expression.
4735 EXAMPLE The cbrt type-generic macro could be implemented as follows:
4736 <pre>
4737 #define cbrt(X) _Generic((X), \
4738 long double: cbrtl, \
4739 default: cbrt, \
4740 float: cbrtf \
4741 )(X)
4742 </pre>
4749 <!--page 98 -->
4750 <pre>
4751 postfix-expression:
4752 primary-expression
4753 postfix-expression [ expression ]
4755 postfix-expression . identifier
4756 postfix-expression -> identifier
4757 postfix-expression ++
4758 postfix-expression --
4759 ( type-name ) { initializer-list }
4760 ( type-name ) { initializer-list , }
4761 argument-expression-list:
4762 assignment-expression
4763 argument-expression-list , assignment-expression
4764 </pre>
4770 One of the expressions shall have type ''pointer to complete object type'', the other
4771 expression shall have integer type, and the result has type ''type''.
4774 A postfix expression followed by an expression in square brackets [] is a subscripted
4775 designation of an element of an array object. The definition of the subscript operator []
4776 is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
4777 apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
4778 initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
4779 element of E1 (counting from zero).
4781 Successive subscript operators designate an element of a multidimensional array object.
4783 other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
4784 dimensions j x . . . x k. If the unary * operator is applied to this pointer explicitly, or
4785 implicitly as a result of subscripting, the result is the referenced (n - 1)-dimensional
4786 array, which itself is converted into a pointer if used as other than an lvalue. It follows
4787 from this that arrays are stored in row-major order (last subscript varies fastest).
4789 EXAMPLE Consider the array object defined by the declaration
4790 <pre>
4792 </pre>
4793 Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
4794 array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
4795 a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
4796 entails multiplying i by the size of the object to which the pointer points, namely an array of five int
4797 objects. The results are added and indirection is applied to yield an array of five ints. When used in the
4798 expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
4799 yields an int.
4801 <p><b> Forward references</b>: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
4803 <!--page 99 -->
4809 The expression that denotes the called function<sup><a href="#note92"><b>92)</b></a></sup> shall have type pointer to function
4810 returning void or returning a complete object type other than an array type.
4812 If the expression that denotes the called function has a type that includes a prototype, the
4813 number of arguments shall agree with the number of parameters. Each argument shall
4814 have a type such that its value may be assigned to an object with the unqualified version
4815 of the type of its corresponding parameter.
4818 A postfix expression followed by parentheses () containing a possibly empty, comma-
4819 separated list of expressions is a function call. The postfix expression denotes the called
4820 function. The list of expressions specifies the arguments to the function.
4822 An argument may be an expression of any complete object type. In preparing for the call
4823 to a function, the arguments are evaluated, and each parameter is assigned the value of the
4826 If the expression that denotes the called function has type pointer to function returning an
4827 object type, the function call expression has the same type as that object type, and has the
4828 value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void.
4830 If the expression that denotes the called function has a type that does not include a
4831 prototype, the integer promotions are performed on each argument, and arguments that
4832 have type float are promoted to double. These are called the default argument
4833 promotions. If the number of arguments does not equal the number of parameters, the
4834 behavior is undefined. If the function is defined with a type that includes a prototype, and
4835 either the prototype ends with an ellipsis (, ...) or the types of the arguments after
4836 promotion are not compatible with the types of the parameters, the behavior is undefined.
4837 If the function is defined with a type that does not include a prototype, and the types of
4838 the arguments after promotion are not compatible with those of the parameters after
4839 promotion, the behavior is undefined, except for the following cases:
4840 <ul>
4841 <li> one promoted type is a signed integer type, the other promoted type is the
4842 corresponding unsigned integer type, and the value is representable in both types;
4846 <!--page 100 -->
4847 <li> both types are pointers to qualified or unqualified versions of a character type or
4848 void.
4849 </ul>
4851 If the expression that denotes the called function has a type that does include a prototype,
4852 the arguments are implicitly converted, as if by assignment, to the types of the
4853 corresponding parameters, taking the type of each parameter to be the unqualified version
4854 of its declared type. The ellipsis notation in a function prototype declarator causes
4855 argument type conversion to stop after the last declared parameter. The default argument
4856 promotions are performed on trailing arguments.
4858 No other conversions are performed implicitly; in particular, the number and types of
4859 arguments are not compared with those of the parameters in a function definition that
4860 does not include a function prototype declarator.
4862 If the function is defined with a type that is not compatible with the type (of the
4863 expression) pointed to by the expression that denotes the called function, the behavior is
4864 undefined.
4866 There is a sequence point after the evaluations of the function designator and the actual
4867 arguments but before the actual call. Every evaluation in the calling function (including
4868 other function calls) that is not otherwise specifically sequenced before or after the
4869 execution of the body of the called function is indeterminately sequenced with respect to
4872 Recursive function calls shall be permitted, both directly and indirectly through any chain
4873 of other functions.
4875 EXAMPLE In the function call
4876 <pre>
4877 (*pf[f1()]) (f2(), f3() + f4())
4878 </pre>
4879 the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
4880 the function pointed to by pf[f1()] is called.
4882 <p><b> Forward references</b>: function declarators (including prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), function
4883 definitions (<a href="#6.9.1">6.9.1</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
4886 <p><small><a name="note92" href="#note92">92)</a> Most often, this is the result of converting an identifier that is a function designator.
4887 </small>
4888 <p><small><a name="note93" href="#note93">93)</a> A function may change the values of its parameters, but these changes cannot affect the values of the
4889 arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
4890 change the value of the object pointed to. A parameter declared to have array or function type is
4892 </small>
4893 <p><small><a name="note94" href="#note94">94)</a> In other words, function executions do not ''interleave'' with each other.
4894 </small>
4900 The first operand of the . operator shall have an atomic, qualified, or unqualified
4901 structure or union type, and the second operand shall name a member of that type.
4903 The first operand of the -> operator shall have type ''pointer to atomic, qualified, or
4904 unqualified structure'' or ''pointer to atomic, qualified, or unqualified union'', and the
4905 second operand shall name a member of the type pointed to.
4908 <!--page 101 -->
4911 A postfix expression followed by the . operator and an identifier designates a member of
4912 a structure or union object. The value is that of the named member,<sup><a href="#note95"><b>95)</b></a></sup> and is an lvalue if
4913 the first expression is an lvalue. If the first expression has qualified type, the result has
4914 the so-qualified version of the type of the designated member.
4916 A postfix expression followed by the -> operator and an identifier designates a member
4917 of a structure or union object. The value is that of the named member of the object to
4918 which the first expression points, and is an lvalue.<sup><a href="#note96"><b>96)</b></a></sup> If the first expression is a pointer to
4919 a qualified type, the result has the so-qualified version of the type of the designated
4920 member.
4922 Accessing a member of an atomic structure or union object results in undefined
4925 One special guarantee is made in order to simplify the use of unions: if a union contains
4926 several structures that share a common initial sequence (see below), and if the union
4927 object currently contains one of these structures, it is permitted to inspect the common
4928 initial part of any of them anywhere that a declaration of the completed type of the union
4929 is visible. Two structures share a common initial sequence if corresponding members
4930 have compatible types (and, for bit-fields, the same widths) for a sequence of one or more
4931 initial members.
4933 EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
4934 union, f().x is a valid postfix expression but is not an lvalue.
4937 EXAMPLE 2 In:
4938 <pre>
4939 struct s { int i; const int ci; };
4940 struct s s;
4941 const struct s cs;
4942 volatile struct s vs;
4943 </pre>
4944 the various members have the types:
4949 <!--page 102 -->
4950 <pre>
4951 s.i int
4952 s.ci const int
4953 cs.i const int
4954 cs.ci const int
4955 vs.i volatile int
4956 vs.ci volatile const int
4957 </pre>
4960 EXAMPLE 3 The following is a valid fragment:
4961 <pre>
4962 union {
4963 struct {
4964 int alltypes;
4965 } n;
4966 struct {
4967 int type;
4968 int intnode;
4969 } ni;
4970 struct {
4971 int type;
4972 double doublenode;
4973 } nf;
4974 } u;
4975 u.nf.type = 1;
4977 /* ... */
4978 if (u.n.alltypes == 1)
4979 if (sin(u.nf.doublenode) == 0.0)
4980 /* ... */
4981 </pre>
4982 The following is not a valid fragment (because the union type is not visible within function f):
4983 <pre>
4984 struct t1 { int m; };
4985 struct t2 { int m; };
4986 int f(struct t1 *p1, struct t2 *p2)
4987 {
4990 return p1->m;
4991 }
4992 int g()
4993 {
4994 union {
4995 struct t1 s1;
4996 struct t2 s2;
4997 } u;
4998 /* ... */
5000 }
5001 </pre>
5003 <p><b> Forward references</b>: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
5005 <!--page 103 -->
5008 <p><small><a name="note95" href="#note95">95)</a> If the member used to read the contents of a union object is not the same as the member last used to
5009 store a value in the object, the appropriate part of the object representation of the value is reinterpreted
5010 as an object representation in the new type as described in <a href="#6.2.6">6.2.6</a> (a process sometimes called ''type
5011 punning''). This might be a trap representation.
5012 </small>
5013 <p><small><a name="note96" href="#note96">96)</a> If &E is a valid pointer expression (where & is the ''address-of '' operator, which generates a pointer to
5015 </small>
5016 <p><small><a name="note97" href="#note97">97)</a> For example, a data race would occur if access to the entire structure or union in one thread conflicts
5017 with access to a member from another thread, where at least one access is a modification. Members
5018 can be safely accessed using a non-atomic object which is assigned to or from the atomic object.
5019 </small>
5022 <h5><a name="6.5.2.4" href="#6.5.2.4">6.5.2.4 Postfix increment and decrement operators</a></h5>
5025 The operand of the postfix increment or decrement operator shall have atomic, qualified,
5026 or unqualified real or pointer type, and shall be a modifiable lvalue.
5029 The result of the postfix ++ operator is the value of the operand. As a side effect, the
5030 value of the operand object is incremented (that is, the value 1 of the appropriate type is
5031 added to it). See the discussions of additive operators and compound assignment for
5032 information on constraints, types, and conversions and the effects of operations on
5033 pointers. The value computation of the result is sequenced before the side effect of
5034 updating the stored value of the operand. With respect to an indeterminately-sequenced
5035 function call, the operation of postfix ++ is a single evaluation. Postfix ++ on an object
5036 with atomic type is a read-modify-write operation with memory_order_seq_cst
5039 The postfix -- operator is analogous to the postfix ++ operator, except that the value of
5040 the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
5041 it).
5042 <p><b> Forward references</b>: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
5045 <p><small><a name="note98" href="#note98">98)</a> Where a pointer to an atomic object can be formed and E has integer type, E++ is equivalent to the
5046 following code sequence where T is the type of E:
5048 <pre>
5049 T *addr = &E;
5050 T old = *addr;
5051 T new;
5052 do {
5053 new = old + 1;
5054 } while (!atomic_compare_exchange_strong(addr, &old, new));
5055 </pre>
5056 with old being the result of the operation.
5058 </small>
5064 The type name shall specify a complete object type or an array of unknown size, but not a
5065 variable length array type.
5067 All the constraints for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.
5070 A postfix expression that consists of a parenthesized type name followed by a brace-
5071 enclosed list of initializers is a compound literal. It provides an unnamed object whose
5073 <!--page 104 -->
5076 If the type name specifies an array of unknown size, the size is determined by the
5077 initializer list as specified in <a href="#6.7.9">6.7.9</a>, and the type of the compound literal is that of the
5078 completed array type. Otherwise (when the type name specifies an object type), the type
5079 of the compound literal is that specified by the type name. In either case, the result is an
5080 lvalue.
5082 The value of the compound literal is that of an unnamed object initialized by the
5083 initializer list. If the compound literal occurs outside the body of a function, the object
5084 has static storage duration; otherwise, it has automatic storage duration associated with
5085 the enclosing block.
5087 All the semantic rules for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.<sup><a href="#note100"><b>100)</b></a></sup>
5089 String literals, and compound literals with const-qualified types, need not designate
5092 EXAMPLE 1 The file scope definition
5093 <pre>
5095 </pre>
5096 initializes p to point to the first element of an array of two ints, the first having the value two and the
5097 second, four. The expressions in this compound literal are required to be constant. The unnamed object
5098 has static storage duration.
5101 EXAMPLE 2 In contrast, in
5102 <pre>
5103 void f(void)
5104 {
5105 int *p;
5106 /*...*/
5107 p = (int [2]){*p};
5108 /*...*/
5109 }
5110 </pre>
5111 p is assigned the address of the first element of an array of two ints, the first having the value previously
5112 pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
5113 unnamed object has automatic storage duration.
5116 EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
5117 created using compound literals can be passed to functions without depending on member order:
5118 <pre>
5121 </pre>
5125 <!--page 105 -->
5126 Or, if drawline instead expected pointers to struct point:
5127 <pre>
5130 </pre>
5133 EXAMPLE 4 A read-only compound literal can be specified through constructions like:
5134 <pre>
5136 </pre>
5139 EXAMPLE 5 The following three expressions have different meanings:
5140 <pre>
5141 "/tmp/fileXXXXXX"
5142 (char []){"/tmp/fileXXXXXX"}
5143 (const char []){"/tmp/fileXXXXXX"}
5144 </pre>
5145 The first always has static storage duration and has type array of char, but need not be modifiable; the last
5146 two have automatic storage duration when they occur within the body of a function, and the first of these
5147 two is modifiable.
5150 EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
5151 and can even be shared. For example,
5152 <pre>
5154 </pre>
5155 might yield 1 if the literals' storage is shared.
5158 EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
5159 linked object. For example, there is no way to write a self-referential compound literal that could be used
5160 as the function argument in place of the named object endless_zeros below:
5161 <pre>
5162 struct int_list { int car; struct int_list *cdr; };
5164 eval(endless_zeros);
5165 </pre>
5168 EXAMPLE 8 Each compound literal creates only a single object in a given scope:
5169 <pre>
5170 struct s { int i; };
5171 int f (void)
5172 {
5173 struct s *p = 0, *q;
5174 int j = 0;
5175 again:
5176 q = p, p = &((struct s){ j++ });
5179 }
5180 </pre>
5181 The function f() always returns the value 1.
5183 Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
5184 lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
5185 have an indeterminate value, which would result in undefined behavior.
5187 <p><b> Forward references</b>: type names (<a href="#6.7.7">6.7.7</a>), initialization (<a href="#6.7.9">6.7.9</a>).
5188 <!--page 106 -->
5191 <p><small><a name="note99" href="#note99">99)</a> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
5192 or void only, and the result of a cast expression is not an lvalue.
5193 </small>
5194 <p><small><a name="note100" href="#note100">100)</a> For example, subobjects without explicit initializers are initialized to zero.
5195 </small>
5196 <p><small><a name="note101" href="#note101">101)</a> This allows implementations to share storage for string literals and constant compound literals with
5197 the same or overlapping representations.
5198 </small>
5204 <pre>
5205 unary-expression:
5206 postfix-expression
5207 ++ unary-expression
5208 -- unary-expression
5209 unary-operator cast-expression
5210 sizeof unary-expression
5211 sizeof ( type-name )
5212 _Alignof ( type-name )
5213 unary-operator: one of
5214 & * + - ~ !
5215 </pre>
5218 <h5><a name="6.5.3.1" href="#6.5.3.1">6.5.3.1 Prefix increment and decrement operators</a></h5>
5221 The operand of the prefix increment or decrement operator shall have atomic, qualified,
5222 or unqualified real or pointer type, and shall be a modifiable lvalue.
5225 The value of the operand of the prefix ++ operator is incremented. The result is the new
5226 value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
5227 See the discussions of additive operators and compound assignment for information on
5228 constraints, types, side effects, and conversions and the effects of operations on pointers.
5230 The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
5231 operand is decremented.
5232 <p><b> Forward references</b>: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
5238 The operand of the unary & operator shall be either a function designator, the result of a
5239 [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
5240 not declared with the register storage-class specifier.
5242 The operand of the unary * operator shall have pointer type.
5245 The unary & operator yields the address of its operand. If the operand has type ''type'',
5246 the result has type ''pointer to type''. If the operand is the result of a unary * operator,
5247 neither that operator nor the & operator is evaluated and the result is as if both were
5248 omitted, except that the constraints on the operators still apply and the result is not an
5249 <!--page 107 -->
5250 lvalue. Similarly, if the operand is the result of a [] operator, neither the & operator nor
5251 the unary * that is implied by the [] is evaluated and the result is as if the & operator
5252 were removed and the [] operator were changed to a + operator. Otherwise, the result is
5253 a pointer to the object or function designated by its operand.
5255 The unary * operator denotes indirection. If the operand points to a function, the result is
5256 a function designator; if it points to an object, the result is an lvalue designating the
5257 object. If the operand has type ''pointer to type'', the result has type ''type''. If an
5258 invalid value has been assigned to the pointer, the behavior of the unary * operator is
5260 <p><b> Forward references</b>: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
5264 <p><small><a name="note102" href="#note102">102)</a> Thus, &*E is equivalent to E (even if E is a null pointer), and &(E1[E2]) to ((E1)+(E2)). It is
5265 always true that if E is a function designator or an lvalue that is a valid operand of the unary &
5266 operator, *&E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
5267 an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
5268 Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
5269 address inappropriately aligned for the type of object pointed to, and the address of an object after the
5270 end of its lifetime.
5271 </small>
5277 The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
5278 integer type; of the ! operator, scalar type.
5281 The result of the unary + operator is the value of its (promoted) operand. The integer
5282 promotions are performed on the operand, and the result has the promoted type.
5284 The result of the unary - operator is the negative of its (promoted) operand. The integer
5285 promotions are performed on the operand, and the result has the promoted type.
5287 The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
5288 each bit in the result is set if and only if the corresponding bit in the converted operand is
5289 not set). The integer promotions are performed on the operand, and the result has the
5290 promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
5291 to the maximum value representable in that type minus E.
5293 The result of the logical negation operator ! is 0 if the value of its operand compares
5295 The expression !E is equivalent to (0==E).
5299 <!--page 108 -->
5305 The sizeof operator shall not be applied to an expression that has function type or an
5306 incomplete type, to the parenthesized name of such a type, or to an expression that
5307 designates a bit-field member. The _Alignof operator shall not be applied to a
5308 function type or an incomplete type.
5311 The sizeof operator yields the size (in bytes) of its operand, which may be an
5312 expression or the parenthesized name of a type. The size is determined from the type of
5313 the operand. The result is an integer. If the type of the operand is a variable length array
5314 type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
5315 integer constant.
5317 The _Alignof operator yields the alignment requirement of its operand type. The
5318 operand is not evaluated and the result is an integer constant. When applied to an array
5319 type, the result is the alignment requirement of the element type.
5321 When sizeof is applied to an operand that has type char, unsigned char, or
5322 signed char, (or a qualified version thereof) the result is 1. When applied to an
5323 operand that has array type, the result is the total number of bytes in the array.<sup><a href="#note103"><b>103)</b></a></sup> When
5324 applied to an operand that has structure or union type, the result is the total number of
5325 bytes in such an object, including internal and trailing padding.
5327 The value of the result of both operators is implementation-defined, and its type (an
5328 unsigned integer type) is size_t, defined in <a href="#7.19"><stddef.h></a> (and other headers).
5330 EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
5331 allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
5332 allocate and return a pointer to void. For example:
5333 <pre>
5334 extern void *alloc(size_t);
5335 double *dp = alloc(sizeof *dp);
5336 </pre>
5337 The implementation of the alloc function should ensure that its return value is aligned suitably for
5338 conversion to a pointer to double.
5341 EXAMPLE 2 Another use of the sizeof operator is to compute the number of elements in an array:
5342 <pre>
5343 sizeof array / sizeof array[0]
5344 </pre>
5347 EXAMPLE 3 In this example, the size of a variable length array is computed and returned from a
5348 function:
5349 <pre>
5351 </pre>
5355 <!--page 109 -->
5356 <pre>
5357 size_t fsize3(int n)
5358 {
5359 char b[n+3]; // variable length array
5360 return sizeof b; // execution time sizeof
5361 }
5362 int main()
5363 {
5364 size_t size;
5366 return 0;
5367 }
5368 </pre>
5370 <p><b> Forward references</b>: common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>), declarations (<a href="#6.7">6.7</a>),
5371 structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.7">6.7.7</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
5374 <p><small><a name="note103" href="#note103">103)</a> When applied to a parameter declared to have array or function type, the sizeof operator yields the
5376 </small>
5382 <pre>
5383 cast-expression:
5384 unary-expression
5385 ( type-name ) cast-expression
5386 </pre>
5389 Unless the type name specifies a void type, the type name shall specify atomic, qualified,
5390 or unqualified scalar type, and the operand shall have scalar type.
5392 Conversions that involve pointers, other than where permitted by the constraints of
5395 A pointer type shall not be converted to any floating type. A floating type shall not be
5396 converted to any pointer type.
5399 Preceding an expression by a parenthesized type name converts the value of the
5400 expression to the named type. This construction is called a cast.<sup><a href="#note104"><b>104)</b></a></sup> A cast that specifies
5401 no conversion has no effect on the type or value of an expression.
5403 If the value of the expression is represented with greater range or precision than required
5404 by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
5405 type of the expression is the same as the named type and removes any extra range and
5406 precision.
5407 <p><b> Forward references</b>: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
5408 prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
5410 <!--page 110 -->
5413 <p><small><a name="note104" href="#note104">104)</a> A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the
5414 unqualified version of the type.
5415 </small>
5421 <pre>
5422 multiplicative-expression:
5423 cast-expression
5424 multiplicative-expression * cast-expression
5425 multiplicative-expression / cast-expression
5426 multiplicative-expression % cast-expression
5427 </pre>
5430 Each of the operands shall have arithmetic type. The operands of the % operator shall
5431 have integer type.
5434 The usual arithmetic conversions are performed on the operands.
5436 The result of the binary * operator is the product of the operands.
5438 The result of the / operator is the quotient from the division of the first operand by the
5439 second; the result of the % operator is the remainder. In both operations, if the value of
5440 the second operand is zero, the behavior is undefined.
5442 When integers are divided, the result of the / operator is the algebraic quotient with any
5443 fractional part discarded.<sup><a href="#note105"><b>105)</b></a></sup> If the quotient a/b is representable, the expression
5444 (a/b)*b + a%b shall equal a; otherwise, the behavior of both a/b and a%b is
5445 undefined.
5448 <p><small><a name="note105" href="#note105">105)</a> This is often called ''truncation toward zero''.
5449 </small>
5455 <pre>
5456 additive-expression:
5457 multiplicative-expression
5458 additive-expression + multiplicative-expression
5459 additive-expression - multiplicative-expression
5460 </pre>
5463 For addition, either both operands shall have arithmetic type, or one operand shall be a
5464 pointer to a complete object type and the other shall have integer type. (Incrementing is
5465 equivalent to adding 1.)
5467 For subtraction, one of the following shall hold:
5472 <!--page 111 -->
5473 <ul>
5474 <li> both operands have arithmetic type;
5475 <li> both operands are pointers to qualified or unqualified versions of compatible complete
5476 object types; or
5477 <li> the left operand is a pointer to a complete object type and the right operand has
5478 integer type.
5479 </ul>
5480 (Decrementing is equivalent to subtracting 1.)
5483 If both operands have arithmetic type, the usual arithmetic conversions are performed on
5484 them.
5486 The result of the binary + operator is the sum of the operands.
5488 The result of the binary - operator is the difference resulting from the subtraction of the
5489 second operand from the first.
5491 For the purposes of these operators, a pointer to an object that is not an element of an
5492 array behaves the same as a pointer to the first element of an array of length one with the
5493 type of the object as its element type.
5495 When an expression that has integer type is added to or subtracted from a pointer, the
5496 result has the type of the pointer operand. If the pointer operand points to an element of
5497 an array object, and the array is large enough, the result points to an element offset from
5498 the original element such that the difference of the subscripts of the resulting and original
5499 array elements equals the integer expression. In other words, if the expression P points to
5500 the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and
5501 (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of
5502 the array object, provided they exist. Moreover, if the expression P points to the last
5503 element of an array object, the expression (P)+1 points one past the last element of the
5504 array object, and if the expression Q points one past the last element of an array object,
5505 the expression (Q)-1 points to the last element of the array object. If both the pointer
5506 operand and the result point to elements of the same array object, or one past the last
5507 element of the array object, the evaluation shall not produce an overflow; otherwise, the
5508 behavior is undefined. If the result points one past the last element of the array object, it
5509 shall not be used as the operand of a unary * operator that is evaluated.
5511 When two pointers are subtracted, both shall point to elements of the same array object,
5512 or one past the last element of the array object; the result is the difference of the
5513 subscripts of the two array elements. The size of the result is implementation-defined,
5514 and its type (a signed integer type) is ptrdiff_t defined in the <a href="#7.19"><stddef.h></a> header.
5515 If the result is not representable in an object of that type, the behavior is undefined. In
5516 other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
5517 an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
5518 <!--page 112 -->
5519 object of type ptrdiff_t. Moreover, if the expression P points either to an element of
5520 an array object or one past the last element of an array object, and the expression Q points
5521 to the last element of the same array object, the expression ((Q)+1)-(P) has the same
5523 expression P points one past the last element of the array object, even though the
5524 expression (Q)+1 does not point to an element of the array object.<sup><a href="#note106"><b>106)</b></a></sup>
5526 EXAMPLE Pointer arithmetic is well defined with pointers to variable length array types.
5527 <pre>
5528 {
5530 int a[n][m];
5534 n = p - a; // n == 1
5535 }
5536 </pre>
5538 If array a in the above example were declared to be an array of known constant size, and pointer p were
5539 declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
5540 the same.
5542 <p><b> Forward references</b>: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), common definitions <a href="#7.19"><stddef.h></a>
5546 <p><small><a name="note106" href="#note106">106)</a> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
5547 this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
5548 by the size of the object originally pointed to, and the resulting pointer is converted back to the
5549 original type. For pointer subtraction, the result of the difference between the character pointers is
5550 similarly divided by the size of the object originally pointed to.
5551 When viewed in this way, an implementation need only provide one extra byte (which may overlap
5552 another object in the program) just after the end of the object in order to satisfy the ''one past the last
5553 element'' requirements.
5554 </small>
5560 <pre>
5561 shift-expression:
5562 additive-expression
5563 shift-expression << additive-expression
5564 shift-expression >> additive-expression
5565 </pre>
5568 Each of the operands shall have integer type.
5571 The integer promotions are performed on each of the operands. The type of the result is
5572 that of the promoted left operand. If the value of the right operand is negative or is
5574 <!--page 113 -->
5575 greater than or equal to the width of the promoted left operand, the behavior is undefined.
5577 The result of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
5578 zeros. If E1 has an unsigned type, the value of the result is E1 x 2<sup>E2</sup> , reduced modulo
5579 one more than the maximum value representable in the result type. If E1 has a signed
5580 type and nonnegative value, and E1 x 2<sup>E2</sup> is representable in the result type, then that is
5581 the resulting value; otherwise, the behavior is undefined.
5583 The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
5584 or if E1 has a signed type and a nonnegative value, the value of the result is the integral
5585 part of the quotient of E1 / 2<sup>E2</sup> . If E1 has a signed type and a negative value, the
5586 resulting value is implementation-defined.
5592 <pre>
5593 relational-expression:
5594 shift-expression
5595 relational-expression < shift-expression
5596 relational-expression > shift-expression
5597 relational-expression <= shift-expression
5598 relational-expression >= shift-expression
5599 </pre>
5602 One of the following shall hold:
5603 <ul>
5604 <li> both operands have real type; or
5605 <li> both operands are pointers to qualified or unqualified versions of compatible object
5606 types.
5607 </ul>
5610 If both of the operands have arithmetic type, the usual arithmetic conversions are
5611 performed.
5613 For the purposes of these operators, a pointer to an object that is not an element of an
5614 array behaves the same as a pointer to the first element of an array of length one with the
5615 type of the object as its element type.
5617 When two pointers are compared, the result depends on the relative locations in the
5618 address space of the objects pointed to. If two pointers to object types both point to the
5619 same object, or both point one past the last element of the same array object, they
5620 compare equal. If the objects pointed to are members of the same aggregate object,
5621 pointers to structure members declared later compare greater than pointers to members
5622 declared earlier in the structure, and pointers to array elements with larger subscript
5623 values compare greater than pointers to elements of the same array with lower subscript
5624 <!--page 114 -->
5625 values. All pointers to members of the same union object compare equal. If the
5626 expression P points to an element of an array object and the expression Q points to the
5627 last element of the same array object, the pointer expression Q+1 compares greater than
5628 P. In all other cases, the behavior is undefined.
5630 Each of the operators < (less than), > (greater than), <= (less than or equal to), and >=
5635 <p><small><a name="note107" href="#note107">107)</a> The expression a<b<c is not interpreted as in ordinary mathematics. As the syntax indicates, it
5636 means (a<b)<c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
5637 </small>
5643 <pre>
5644 equality-expression:
5645 relational-expression
5646 equality-expression == relational-expression
5647 equality-expression != relational-expression
5648 </pre>
5651 One of the following shall hold:
5652 <ul>
5653 <li> both operands have arithmetic type;
5654 <li> both operands are pointers to qualified or unqualified versions of compatible types;
5655 <li> one operand is a pointer to an object type and the other is a pointer to a qualified or
5656 unqualified version of void; or
5657 <li> one operand is a pointer and the other is a null pointer constant.
5658 </ul>
5661 The == (equal to) and != (not equal to) operators are analogous to the relational
5662 operators except for their lower precedence.<sup><a href="#note108"><b>108)</b></a></sup> Each of the operators yields 1 if the
5663 specified relation is true and 0 if it is false. The result has type int. For any pair of
5664 operands, exactly one of the relations is true.
5666 If both of the operands have arithmetic type, the usual arithmetic conversions are
5667 performed. Values of complex types are equal if and only if both their real parts are equal
5668 and also their imaginary parts are equal. Any two values of arithmetic types from
5669 different type domains are equal if and only if the results of their conversions to the
5670 (complex) result type determined by the usual arithmetic conversions are equal.
5674 <!--page 115 -->
5676 Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
5677 null pointer constant, the null pointer constant is converted to the type of the pointer. If
5678 one operand is a pointer to an object type and the other is a pointer to a qualified or
5679 unqualified version of void, the former is converted to the type of the latter.
5681 Two pointers compare equal if and only if both are null pointers, both are pointers to the
5682 same object (including a pointer to an object and a subobject at its beginning) or function,
5683 both are pointers to one past the last element of the same array object, or one is a pointer
5684 to one past the end of one array object and the other is a pointer to the start of a different
5685 array object that happens to immediately follow the first array object in the address
5688 For the purposes of these operators, a pointer to an object that is not an element of an
5689 array behaves the same as a pointer to the first element of an array of length one with the
5690 type of the object as its element type.
5693 <p><small><a name="note108" href="#note108">108)</a> Because of the precedences, a<b == c<d is 1 whenever a<b and c<d have the same truth-value.
5694 </small>
5695 <p><small><a name="note109" href="#note109">109)</a> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
5696 adjacent members of a structure with no padding between them, or because the implementation chose
5697 to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
5698 outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
5699 behavior.
5700 </small>
5706 <pre>
5707 AND-expression:
5708 equality-expression
5709 AND-expression & equality-expression
5710 </pre>
5713 Each of the operands shall have integer type.
5716 The usual arithmetic conversions are performed on the operands.
5718 The result of the binary & operator is the bitwise AND of the operands (that is, each bit in
5719 the result is set if and only if each of the corresponding bits in the converted operands is
5720 set).
5725 <!--page 116 -->
5731 <pre>
5732 exclusive-OR-expression:
5733 AND-expression
5734 exclusive-OR-expression ^ AND-expression
5735 </pre>
5738 Each of the operands shall have integer type.
5741 The usual arithmetic conversions are performed on the operands.
5743 The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
5744 in the result is set if and only if exactly one of the corresponding bits in the converted
5745 operands is set).
5751 <pre>
5752 inclusive-OR-expression:
5753 exclusive-OR-expression
5754 inclusive-OR-expression | exclusive-OR-expression
5755 </pre>
5758 Each of the operands shall have integer type.
5761 The usual arithmetic conversions are performed on the operands.
5763 The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
5764 the result is set if and only if at least one of the corresponding bits in the converted
5765 operands is set).
5766 <!--page 117 -->
5772 <pre>
5773 logical-AND-expression:
5774 inclusive-OR-expression
5775 logical-AND-expression && inclusive-OR-expression
5776 </pre>
5779 Each of the operands shall have scalar type.
5782 The && operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
5783 yields 0. The result has type int.
5785 Unlike the bitwise binary & operator, the && operator guarantees left-to-right evaluation;
5786 if the second operand is evaluated, there is a sequence point between the evaluations of
5787 the first and second operands. If the first operand compares equal to 0, the second
5788 operand is not evaluated.
5794 <pre>
5795 logical-OR-expression:
5796 logical-AND-expression
5797 logical-OR-expression || logical-AND-expression
5798 </pre>
5801 Each of the operands shall have scalar type.
5805 yields 0. The result has type int.
5807 Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; if the
5808 second operand is evaluated, there is a sequence point between the evaluations of the first
5809 and second operands. If the first operand compares unequal to 0, the second operand is
5810 not evaluated.
5811 <!--page 118 -->
5817 <pre>
5818 conditional-expression:
5819 logical-OR-expression
5820 logical-OR-expression ? expression : conditional-expression
5821 </pre>
5824 The first operand shall have scalar type.
5826 One of the following shall hold for the second and third operands:
5827 <ul>
5828 <li> both operands have arithmetic type;
5829 <li> both operands have the same structure or union type;
5830 <li> both operands have void type;
5831 <li> both operands are pointers to qualified or unqualified versions of compatible types;
5832 <li> one operand is a pointer and the other is a null pointer constant; or
5833 <li> one operand is a pointer to an object type and the other is a pointer to a qualified or
5834 unqualified version of void.
5835 </ul>
5838 The first operand is evaluated; there is a sequence point between its evaluation and the
5839 evaluation of the second or third operand (whichever is evaluated). The second operand
5840 is evaluated only if the first compares unequal to 0; the third operand is evaluated only if
5841 the first compares equal to 0; the result is the value of the second or third operand
5842 (whichever is evaluated), converted to the type described below.<sup><a href="#note110"><b>110)</b></a></sup>
5844 If both the second and third operands have arithmetic type, the result type that would be
5845 determined by the usual arithmetic conversions, were they applied to those two operands,
5846 is the type of the result. If both the operands have structure or union type, the result has
5847 that type. If both operands have void type, the result has void type.
5849 If both the second and third operands are pointers or one is a null pointer constant and the
5850 other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
5851 of the types referenced by both operands. Furthermore, if both operands are pointers to
5852 compatible types or to differently qualified versions of compatible types, the result type is
5853 a pointer to an appropriately qualified version of the composite type; if one operand is a
5854 null pointer constant, the result has the type of the other operand; otherwise, one operand
5855 is a pointer to void or a qualified version of void, in which case the result type is a
5856 pointer to an appropriately qualified version of void.
5858 <!--page 119 -->
5860 EXAMPLE The common type that results when the second and third operands are pointers is determined
5861 in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
5862 pointers have compatible types.
5864 Given the declarations
5865 <pre>
5866 const void *c_vp;
5867 void *vp;
5868 const int *c_ip;
5869 volatile int *v_ip;
5870 int *ip;
5871 const char *c_cp;
5872 </pre>
5873 the third column in the following table is the common type that is the result of a conditional expression in
5874 which the first two columns are the second and third operands (in either order):
5875 <pre>
5876 c_vp c_ip const void *
5877 v_ip 0 volatile int *
5878 c_ip v_ip const volatile int *
5879 vp c_cp const void *
5880 ip c_ip const int *
5881 vp ip void *
5882 </pre>
5886 <p><small><a name="note110" href="#note110">110)</a> A conditional expression does not yield an lvalue.
5887 </small>
5893 <pre>
5894 assignment-expression:
5895 conditional-expression
5896 unary-expression assignment-operator assignment-expression
5897 assignment-operator: one of
5899 </pre>
5902 An assignment operator shall have a modifiable lvalue as its left operand.
5905 An assignment operator stores a value in the object designated by the left operand. An
5906 assignment expression has the value of the left operand after the assignment,<sup><a href="#note111"><b>111)</b></a></sup> but is not
5907 an lvalue. The type of an assignment expression is the type the left operand would have
5908 after lvalue conversion. The side effect of updating the stored value of the left operand is
5909 sequenced after the value computations of the left and right operands. The evaluations of
5910 the operands are unsequenced.
5915 <!--page 120 -->
5918 <p><small><a name="note111" href="#note111">111)</a> The implementation is permitted to read the object to determine the value but is not required to, even
5919 when the object has volatile-qualified type.
5920 </small>
5927 <ul>
5928 <li> the left operand has atomic, qualified, or unqualified arithmetic type, and the right has
5929 arithmetic type;
5930 <li> the left operand has an atomic, qualified, or unqualified version of a structure or union
5931 type compatible with the type of the right;
5932 <li> the left operand has atomic, qualified, or unqualified pointer type, and (considering
5933 the type the left operand would have after lvalue conversion) both operands are
5934 pointers to qualified or unqualified versions of compatible types, and the type pointed
5935 to by the left has all the qualifiers of the type pointed to by the right;
5936 <li> the left operand has atomic, qualified, or unqualified pointer type, and (considering
5937 the type the left operand would have after lvalue conversion) one operand is a pointer
5938 to an object type, and the other is a pointer to a qualified or unqualified version of
5939 void, and the type pointed to by the left has all the qualifiers of the type pointed to
5940 by the right;
5941 <li> the left operand is an atomic, qualified, or unqualified pointer, and the right is a null
5942 pointer constant; or
5943 <li> the left operand has type atomic, qualified, or unqualified _Bool, and the right is a
5944 pointer.
5945 </ul>
5948 In simple assignment (=), the value of the right operand is converted to the type of the
5949 assignment expression and replaces the value stored in the object designated by the left
5950 operand.
5952 If the value being stored in an object is read from another object that overlaps in any way
5953 the storage of the first object, then the overlap shall be exact and the two objects shall
5954 have qualified or unqualified versions of a compatible type; otherwise, the behavior is
5955 undefined.
5957 EXAMPLE 1 In the program fragment
5962 <!--page 121 -->
5963 <pre>
5964 int f(void);
5965 char c;
5966 /* ... */
5967 if ((c = f()) == -1)
5968 /* ... */
5969 </pre>
5970 the int value returned by the function may be truncated when stored in the char, and then converted back
5971 to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
5972 values as unsigned char (and char is narrower than int), the result of the conversion cannot be
5973 negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
5974 variable c should be declared as int.
5977 EXAMPLE 2 In the fragment:
5978 <pre>
5979 char c;
5980 int i;
5981 long l;
5982 l = (c = i);
5983 </pre>
5984 the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
5985 of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
5986 that is, long int type.
5989 EXAMPLE 3 Consider the fragment:
5990 <pre>
5991 const char **cpp;
5992 char *p;
5993 const char c = 'A';
5994 cpp = &p; // constraint violation
5995 *cpp = &c; // valid
5996 *p = 0; // valid
5997 </pre>
5998 The first assignment is unsafe because it would allow the following valid code to attempt to change the
5999 value of the const object c.
6003 <p><small><a name="note112" href="#note112">112)</a> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
6004 (specified in <a href="#6.3.2.1">6.3.2.1</a>) that changes lvalues to ''the value of the expression'' and thus removes any type
6005 qualifiers that were applied to the type category of the expression (for example, it removes const but
6006 not volatile from the type int volatile * const).
6007 </small>
6013 For the operators += and -= only, either the left operand shall be an atomic, qualified, or
6014 unqualified pointer to a complete object type, and the right shall have integer type; or the
6015 left operand shall have atomic, qualified, or unqualified arithmetic type, and the right
6016 shall have arithmetic type.
6018 For the other operators, the left operand shall have atomic, qualified, or unqualified
6019 arithmetic type, and (considering the type the left operand would have after lvalue
6020 conversion) each operand shall have arithmetic type consistent with those allowed by the
6021 corresponding binary operator.
6024 A compound assignment of the form E1 op = E2 is equivalent to the simple assignment
6025 expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once, and with
6026 respect to an indeterminately-sequenced function call, the operation of a compound
6027 <!--page 122 -->
6028 assignment is a single evaluation. If E1 has an atomic type, compound assignment is a
6029 read-modify-write operation with memory_order_seq_cst memory order
6035 <!--page 123 -->
6038 <p><small><a name="note113" href="#note113">113)</a> Where a pointer to an atomic object can be formed and E1 and E2 have integer type, this is equivalent
6039 to the following code sequence where T1 is the type of E1 and T2 is the type of E2:
6041 <pre>
6042 T1 *addr = &E1;
6043 T2 val = (E2);
6044 T1 old = *addr;
6045 T1 new;
6046 do {
6047 new = old op val;
6048 } while (!atomic_compare_exchange_strong(addr, &old, new));
6049 </pre>
6050 with new being the result of the operation.
6051 If E1 or E2 has floating type, then exceptional conditions or floating-point exceptions encountered
6052 during discarded evaluations of new should also be discarded in order to satisfy the equivalence of E1
6053 op = E2 and E1 = E1 op (E2). For example, if <a href="#F">annex F</a> is in effect, the floating types involved have
6056 <pre>
6058 #pragma STDC FENV_ACCESS ON
6059 /* ... */
6060 fenv_t fenv;
6061 T1 *addr = &E1;
6062 T2 val = E2;
6063 T1 old = *addr;
6064 T1 new;
6065 feholdexcept(&fenv);
6066 for (;;) {
6067 new = old op val;
6068 if (atomic_compare_exchange_strong(addr, &old, new))
6069 break;
6070 feclearexcept(FE_ALL_EXCEPT);
6071 }
6072 feupdateenv(&fenv);
6073 </pre>
6074 If FLT_EVAL_METHOD is not 0, then T2 must be a type with the range and precision to which E2 is
6075 evaluated in order to satisfy the equivalence.
6076 </small>
6082 <pre>
6083 expression:
6084 assignment-expression
6085 expression , assignment-expression
6086 </pre>
6089 The left operand of a comma operator is evaluated as a void expression; there is a
6090 sequence point between its evaluation and that of the right operand. Then the right
6091 operand is evaluated; the result has its type and value.<sup><a href="#note114"><b>114)</b></a></sup>
6093 EXAMPLE As indicated by the syntax, the comma operator (as described in this subclause) cannot
6094 appear in contexts where a comma is used to separate items in a list (such as arguments to functions or lists
6095 of initializers). On the other hand, it can be used within a parenthesized expression or within the second
6096 expression of a conditional operator in such contexts. In the function call
6097 <pre>
6099 </pre>
6100 the function has three arguments, the second of which has the value 5.
6107 <!--page 124 -->
6110 <p><small><a name="note114" href="#note114">114)</a> A comma operator does not yield an lvalue.
6111 </small>
6117 <pre>
6118 constant-expression:
6119 conditional-expression
6120 </pre>
6123 A constant expression can be evaluated during translation rather than runtime, and
6124 accordingly may be used in any place that a constant may be.
6127 Constant expressions shall not contain assignment, increment, decrement, function-call,
6128 or comma operators, except when they are contained within a subexpression that is not
6131 Each constant expression shall evaluate to a constant that is in the range of representable
6132 values for its type.
6135 An expression that evaluates to a constant is required in several contexts. If a floating
6136 expression is evaluated in the translation environment, the arithmetic range and precision
6137 shall be at least as great as if the expression were being evaluated in the execution
6140 An integer constant expression<sup><a href="#note117"><b>117)</b></a></sup> shall have integer type and shall only have operands
6141 that are integer constants, enumeration constants, character constants, sizeof
6142 expressions whose results are integer constants, _Alignof expressions, and floating
6143 constants that are the immediate operands of casts. Cast operators in an integer constant
6144 expression shall only convert arithmetic types to integer types, except as part of an
6145 operand to the sizeof or _Alignof operator.
6147 More latitude is permitted for constant expressions in initializers. Such a constant
6148 expression shall be, or evaluate to, one of the following:
6149 <ul>
6150 <li> an arithmetic constant expression,
6154 <!--page 125 -->
6155 <li> a null pointer constant,
6156 <li> an address constant, or
6157 <li> an address constant for a complete object type plus or minus an integer constant
6158 expression.
6159 </ul>
6161 An arithmetic constant expression shall have arithmetic type and shall only have
6162 operands that are integer constants, floating constants, enumeration constants, character
6163 constants, sizeof expressions whose results are integer constants, and _Alignof
6164 expressions. Cast operators in an arithmetic constant expression shall only convert
6165 arithmetic types to arithmetic types, except as part of an operand to a sizeof or
6166 _Alignof operator.
6168 An address constant is a null pointer, a pointer to an lvalue designating an object of static
6169 storage duration, or a pointer to a function designator; it shall be created explicitly using
6170 the unary & operator or an integer constant cast to pointer type, or implicitly by the use of
6171 an expression of array or function type. The array-subscript [] and member-access .
6172 and -> operators, the address & and indirection * unary operators, and pointer casts may
6173 be used in the creation of an address constant, but the value of an object shall not be
6174 accessed by use of these operators.
6176 An implementation may accept other forms of constant expressions.
6178 The semantic rules for the evaluation of a constant expression are the same as for
6180 <p><b> Forward references</b>: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), initialization (<a href="#6.7.9">6.7.9</a>).
6185 <!--page 126 -->
6188 <p><small><a name="note115" href="#note115">115)</a> The operand of a sizeof or _Alignof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
6189 </small>
6190 <p><small><a name="note116" href="#note116">116)</a> The use of evaluation formats as characterized by FLT_EVAL_METHOD also applies to evaluation in
6191 the translation environment.
6192 </small>
6193 <p><small><a name="note117" href="#note117">117)</a> An integer constant expression is required in a number of contexts such as the size of a bit-field
6194 member of a structure, the value of an enumeration constant, and the size of a non-variable length
6195 array. Further constraints that apply to the integer constant expressions used in conditional-inclusion
6197 </small>
6200 <pre>
6202 </pre>
6203 the expression is a valid integer constant expression with value one.
6204 </small>
6210 <pre>
6211 declaration:
6213 static_assert-declaration
6214 declaration-specifiers:
6220 init-declarator-list:
6221 init-declarator
6222 init-declarator-list , init-declarator
6223 init-declarator:
6224 declarator
6225 declarator = initializer
6226 </pre>
6229 A declaration other than a static_assert declaration shall declare at least a declarator
6230 (other than the parameters of a function or the members of a structure or union), a tag, or
6231 the members of an enumeration.
6233 If an identifier has no linkage, there shall be no more than one declaration of the identifier
6234 (in a declarator or type specifier) with the same scope and in the same name space, except
6235 that:
6236 <ul>
6237 <li> a typedef name may be redefined to denote the same type as it currently does,
6238 provided that type is not a variably modified type;
6240 </ul>
6242 All declarations in the same scope that refer to the same object or function shall specify
6243 compatible types.
6246 A declaration specifies the interpretation and attributes of a set of identifiers. A definition
6247 of an identifier is a declaration for that identifier that:
6248 <ul>
6249 <li> for an object, causes storage to be reserved for that object;
6251 <!--page 127 -->
6252 <li> for an enumeration constant, is the (only) declaration of the identifier;
6253 <li> for a typedef name, is the first (or only) declaration of the identifier.
6254 </ul>
6256 The declaration specifiers consist of a sequence of specifiers that indicate the linkage,
6257 storage duration, and part of the type of the entities that the declarators denote. The init-
6258 declarator-list is a comma-separated sequence of declarators, each of which may have
6259 additional type information, or an initializer, or both. The declarators contain the
6260 identifiers (if any) being declared.
6262 If an identifier for an object is declared with no linkage, the type for the object shall be
6263 complete by the end of its declarator, or by the end of its init-declarator if it has an
6264 initializer; in the case of function parameters (including in prototypes), it is the adjusted
6266 <p><b> Forward references</b>: declarators (<a href="#6.7.6">6.7.6</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
6267 (<a href="#6.7.9">6.7.9</a>), type names (<a href="#6.7.7">6.7.7</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>).
6270 <p><small><a name="note119" href="#note119">119)</a> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
6271 </small>
6277 <pre>
6278 storage-class-specifier:
6279 typedef
6280 extern
6281 static
6282 _Thread_local
6283 auto
6284 register
6285 </pre>
6288 At most, one storage-class specifier may be given in the declaration specifiers in a
6289 declaration, except that _Thread_local may appear with static or extern.<sup><a href="#note120"><b>120)</b></a></sup>
6291 In the declaration of an object with block scope, if the declaration specifiers include
6292 _Thread_local, they shall also include either static or extern. If
6293 _Thread_local appears in any declaration of an object, it shall be present in every
6294 declaration of that object.
6296 _Thread_local shall not appear in the declaration specifiers of a function declaration.
6301 <!--page 128 -->
6304 The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
6305 only; it is discussed in <a href="#6.7.8">6.7.8</a>. The meanings of the various linkages and storage durations
6308 A declaration of an identifier for an object with storage-class specifier register
6309 suggests that access to the object be as fast as possible. The extent to which such
6310 suggestions are effective is implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
6312 The declaration of an identifier for a function that has block scope shall have no explicit
6313 storage-class specifier other than extern.
6315 If an aggregate or union object is declared with a storage-class specifier other than
6316 typedef, the properties resulting from the storage-class specifier, except with respect to
6317 linkage, also apply to the members of the object, and so on recursively for any aggregate
6318 or union member objects.
6324 <!--page 129 -->
6327 <p><small><a name="note120" href="#note120">120)</a> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
6328 </small>
6329 <p><small><a name="note121" href="#note121">121)</a> The implementation may treat any register declaration simply as an auto declaration. However,
6330 whether or not addressable storage is actually used, the address of any part of an object declared with
6331 storage-class specifier register cannot be computed, either explicitly (by use of the unary &
6332 operator as discussed in <a href="#6.5.3.2">6.5.3.2</a>) or implicitly (by converting an array name to a pointer as discussed in
6333 <a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operators that can be applied to an array declared with storage-class specifier
6334 register are sizeof and _Alignof.
6335 </small>
6341 <pre>
6342 type-specifier:
6343 void
6344 char
6345 short
6346 int
6347 long
6348 float
6349 double
6350 signed
6351 unsigned
6352 _Bool
6353 _Complex
6354 atomic-type-specifier
6355 struct-or-union-specifier
6356 enum-specifier
6357 typedef-name
6358 </pre>
6361 At least one type specifier shall be given in the declaration specifiers in each declaration,
6362 and in the specifier-qualifier list in each struct declaration and type name. Each list of
6363 type specifiers shall be one of the following multisets (delimited by commas, when there
6364 is more than one multiset per item); the type specifiers may occur in any order, possibly
6365 intermixed with the other declaration specifiers.
6366 <ul>
6367 <li> void
6368 <li> char
6369 <li> signed char
6370 <li> unsigned char
6371 <li> short, signed short, short int, or signed short int
6372 <li> unsigned short, or unsigned short int
6373 <li> int, signed, or signed int
6374 <li> unsigned, or unsigned int
6375 <li> long, signed long, long int, or signed long int
6376 <li> unsigned long, or unsigned long int
6377 <!--page 130 -->
6378 <li> long long, signed long long, long long int, or
6379 signed long long int
6380 <li> unsigned long long, or unsigned long long int
6381 <li> float
6382 <li> double
6383 <li> long double
6384 <li> _Bool
6385 <li> float _Complex
6386 <li> double _Complex
6387 <li> long double _Complex
6388 <li> atomic type specifier
6389 <li> struct or union specifier
6390 <li> enum specifier
6391 <li> typedef name
6392 </ul>
6394 The type specifier _Complex shall not be used if the implementation does not support
6398 Specifiers for structures, unions, enumerations, and atomic types are discussed in <a href="#6.7.2.1">6.7.2.1</a>
6399 through <a href="#6.7.2.4">6.7.2.4</a>. Declarations of typedef names are discussed in <a href="#6.7.8">6.7.8</a>. The
6402 Each of the comma-separated multisets designates the same type, except that for bit-
6403 fields, it is implementation-defined whether the specifier int designates the same type as
6404 signed int or the same type as unsigned int.
6405 <p><b> Forward references</b>: atomic type specifiers (<a href="#6.7.2.4">6.7.2.4</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>),
6406 structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
6412 <!--page 131 -->
6413 <pre>
6414 struct-or-union-specifier:
6416 struct-or-union identifier
6417 struct-or-union:
6418 struct
6419 union
6420 struct-declaration-list:
6421 struct-declaration
6422 struct-declaration-list struct-declaration
6423 struct-declaration:
6425 static_assert-declaration
6426 specifier-qualifier-list:
6429 struct-declarator-list:
6430 struct-declarator
6431 struct-declarator-list , struct-declarator
6432 struct-declarator:
6433 declarator
6435 </pre>
6438 A struct-declaration that does not declare an anonymous structure or anonymous union
6439 shall contain a struct-declarator-list.
6441 A structure or union shall not contain a member with incomplete or function type (hence,
6442 a structure shall not contain an instance of itself, but may contain a pointer to an instance
6443 of itself), except that the last member of a structure with more than one named member
6444 may have incomplete array type; such a structure (and any union containing, possibly
6445 recursively, a member that is such a structure) shall not be a member of a structure or an
6446 element of an array.
6448 The expression that specifies the width of a bit-field shall be an integer constant
6449 expression with a nonnegative value that does not exceed the width of an object of the
6450 type that would be specified were the colon and expression omitted.<sup><a href="#note122"><b>122)</b></a></sup> If the value is
6451 zero, the declaration shall have no declarator.
6453 A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
6454 int, unsigned int, or some other implementation-defined type. It is
6455 implementation-defined whether atomic types are permitted.
6457 <!--page 132 -->
6460 As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
6461 storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
6462 of members whose storage overlap.
6464 Structure and union specifiers have the same form. The keywords struct and union
6465 indicate that the type being specified is, respectively, a structure type or a union type.
6467 The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
6468 within a translation unit. The struct-declaration-list is a sequence of declarations for the
6469 members of the structure or union. If the struct-declaration-list does not contain any
6470 named members, either directly or via an anonymous structure or anonymous union, the
6471 behavior is undefined. The type is incomplete until immediately after the } that
6472 terminates the list, and complete thereafter.
6474 A member of a structure or union may have any complete object type other than a
6475 variably modified type.<sup><a href="#note123"><b>123)</b></a></sup> In addition, a member may be declared to consist of a
6476 specified number of bits (including a sign bit, if any). Such a member is called a
6479 A bit-field is interpreted as having a signed or unsigned integer type consisting of the
6480 specified number of bits.<sup><a href="#note125"><b>125)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of
6481 type _Bool, the value of the bit-field shall compare equal to the value stored; a _Bool
6482 bit-field has the semantics of a _Bool.
6484 An implementation may allocate any addressable storage unit large enough to hold a bit-
6485 field. If enough space remains, a bit-field that immediately follows another bit-field in a
6486 structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
6487 whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is
6488 implementation-defined. The order of allocation of bit-fields within a unit (high-order to
6489 low-order or low-order to high-order) is implementation-defined. The alignment of the
6490 addressable storage unit is unspecified.
6492 A bit-field declaration with no declarator, but only a colon and a width, indicates an
6493 unnamed bit-field.<sup><a href="#note126"><b>126)</b></a></sup> As a special case, a bit-field structure member with a width of 0
6496 <!--page 133 -->
6497 indicates that no further bit-field is to be packed into the unit in which the previous bit-
6498 field, if any, was placed.
6500 An unnamed member whose type specifier is a structure specifier with no tag is called an
6501 anonymous structure; an unnamed member whose type specifier is a union specifier with
6502 no tag is called an anonymous union. The members of an anonymous structure or union
6503 are considered to be members of the containing structure or union. This applies
6504 recursively if the containing structure or union is also anonymous.
6506 Each non-bit-field member of a structure or union object is aligned in an implementation-
6507 defined manner appropriate to its type.
6509 Within a structure object, the non-bit-field members and the units in which bit-fields
6510 reside have addresses that increase in the order in which they are declared. A pointer to a
6511 structure object, suitably converted, points to its initial member (or if that member is a
6512 bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
6513 padding within a structure object, but not at its beginning.
6515 The size of a union is sufficient to contain the largest of its members. The value of at
6516 most one of the members can be stored in a union object at any time. A pointer to a
6517 union object, suitably converted, points to each of its members (or if a member is a bit-
6518 field, then to the unit in which it resides), and vice versa.
6520 There may be unnamed padding at the end of a structure or union.
6522 As a special case, the last element of a structure with more than one named member may
6523 have an incomplete array type; this is called a flexible array member. In most situations,
6524 the flexible array member is ignored. In particular, the size of the structure is as if the
6525 flexible array member were omitted except that it may have more trailing padding than
6526 the omission would imply. However, when a . (or ->) operator has a left operand that is
6527 (a pointer to) a structure with a flexible array member and the right operand names that
6528 member, it behaves as if that member were replaced with the longest array (with the same
6529 element type) that would not make the structure larger than the object being accessed; the
6530 offset of the array shall remain that of the flexible array member, even if this would differ
6531 from that of the replacement array. If this array would have no elements, it behaves as if
6532 it had one element but the behavior is undefined if any attempt is made to access that
6533 element or to generate a pointer one past it.
6535 EXAMPLE 1 The following illustrates anonymous structures and unions:
6536 <!--page 134 -->
6537 <pre>
6538 struct v {
6539 union { // anonymous union
6540 struct { int i, j; }; // anonymous structure
6541 struct { long k, l; } w;
6542 };
6543 int m;
6544 } v1;
6545 v1.i = 2; // valid
6546 v1.k = 3; // invalid: inner structure is not anonymous
6547 v1.w.k = 5; // valid
6548 </pre>
6551 EXAMPLE 2 After the declaration:
6552 <pre>
6553 struct s { int n; double d[]; };
6554 </pre>
6555 the structure struct s has a flexible array member d. A typical way to use this is:
6556 <pre>
6557 int m = /* some value */;
6558 struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));
6559 </pre>
6560 and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
6561 p had been declared as:
6562 <pre>
6563 struct { int n; double d[m]; } *p;
6564 </pre>
6565 (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
6566 not be the same).
6568 Following the above declaration:
6569 <pre>
6570 struct s t1 = { 0 }; // valid
6572 t1.n = 4; // valid
6574 </pre>
6575 The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
6576 contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
6577 <pre>
6578 sizeof (struct s) >= offsetof(struct s, d) + sizeof (double)
6579 </pre>
6580 in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
6581 code.
6583 After the further declaration:
6584 <pre>
6585 struct ss { int n; };
6586 </pre>
6587 the expressions:
6588 <pre>
6589 sizeof (struct s) >= sizeof (struct ss)
6590 sizeof (struct s) >= offsetof(struct s, d)
6591 </pre>
6592 are always equal to 1.
6594 If sizeof (double) is 8, then after the following code is executed:
6595 <pre>
6596 struct s *s1;
6597 struct s *s2;
6598 s1 = malloc(sizeof (struct s) + 64);
6599 s2 = malloc(sizeof (struct s) + 46);
6600 </pre>
6601 and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
6602 purposes, as if the identifiers had been declared as:
6603 <pre>
6604 struct { int n; double d[8]; } *s1;
6605 struct { int n; double d[5]; } *s2;
6606 </pre>
6608 Following the further successful assignments:
6609 <!--page 135 -->
6610 <pre>
6611 s1 = malloc(sizeof (struct s) + 10);
6612 s2 = malloc(sizeof (struct s) + 6);
6613 </pre>
6614 they then behave as if the declarations were:
6615 <pre>
6616 struct { int n; double d[1]; } *s1, *s2;
6617 </pre>
6618 and:
6619 <pre>
6620 double *dp;
6622 *dp = 42; // valid
6624 *dp = 42; // undefined behavior
6625 </pre>
6627 The assignment:
6628 <pre>
6629 *s1 = *s2;
6630 </pre>
6631 only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
6632 of the structure, they might be copied or simply overwritten with indeterminate values.
6635 EXAMPLE 3 Because members of anonymous structures and unions are considered to be members of the
6636 containing structure or union, struct s in the following example has more than one named member and
6637 thus the use of a flexible array member is valid:
6638 <pre>
6639 struct s {
6640 struct { int i; };
6641 int a[];
6642 };
6643 </pre>
6645 <p><b> Forward references</b>: declarators (<a href="#6.7.6">6.7.6</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>).
6648 <p><small><a name="note122" href="#note122">122)</a> While the number of bits in a _Bool object is at least CHAR_BIT, the width (number of sign and
6649 value bits) of a _Bool may be just 1 bit.
6650 </small>
6651 <p><small><a name="note123" href="#note123">123)</a> A structure or union cannot contain a member with a variably modified type because member names
6653 </small>
6654 <p><small><a name="note124" href="#note124">124)</a> The unary & (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
6655 or arrays of bit-field objects.
6656 </small>
6657 <p><small><a name="note125" href="#note125">125)</a> As specified in <a href="#6.7.2">6.7.2</a> above, if the actual type specifier used is int or a typedef-name defined as int,
6658 then it is implementation-defined whether the bit-field is signed or unsigned.
6659 </small>
6660 <p><small><a name="note126" href="#note126">126)</a> An unnamed bit-field structure member is useful for padding to conform to externally imposed
6661 layouts.
6662 </small>
6668 <pre>
6669 enum-specifier:
6672 enum identifier
6673 enumerator-list:
6674 enumerator
6675 enumerator-list , enumerator
6676 enumerator:
6677 enumeration-constant
6678 enumeration-constant = constant-expression
6679 </pre>
6682 The expression that defines the value of an enumeration constant shall be an integer
6683 constant expression that has a value representable as an int.
6684 <!--page 136 -->
6687 The identifiers in an enumerator list are declared as constants that have type int and
6688 may appear wherever such are permitted.<sup><a href="#note127"><b>127)</b></a></sup> An enumerator with = defines its
6689 enumeration constant as the value of the constant expression. If the first enumerator has
6690 no =, the value of its enumeration constant is 0. Each subsequent enumerator with no =
6691 defines its enumeration constant as the value of the constant expression obtained by
6692 adding 1 to the value of the previous enumeration constant. (The use of enumerators with
6693 = may produce enumeration constants with values that duplicate other values in the same
6694 enumeration.) The enumerators of an enumeration are also known as its members.
6696 Each enumerated type shall be compatible with char, a signed integer type, or an
6697 unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note128"><b>128)</b></a></sup> but shall be
6698 capable of representing the values of all the members of the enumeration. The
6699 enumerated type is incomplete until immediately after the } that terminates the list of
6700 enumerator declarations, and complete thereafter.
6702 EXAMPLE The following fragment:
6703 <pre>
6704 enum hue { chartreuse, burgundy, claret=20, winedark };
6705 enum hue col, *cp;
6706 col = claret;
6707 cp = &col;
6708 if (*cp != burgundy)
6709 /* ... */
6710 </pre>
6711 makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
6712 pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
6717 <p><small><a name="note127" href="#note127">127)</a> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
6718 each other and from other identifiers declared in ordinary declarators.
6719 </small>
6720 <p><small><a name="note128" href="#note128">128)</a> An implementation may delay the choice of which integer type until all enumeration constants have
6721 been seen.
6722 </small>
6728 A specific type shall have its content defined at most once.
6730 Where two declarations that use the same tag declare the same type, they shall both use
6731 the same choice of struct, union, or enum.
6733 A type specifier of the form
6734 <pre>
6735 enum identifier
6736 </pre>
6737 without an enumerator list shall only appear after the type it specifies is complete.
6740 <!--page 137 -->
6743 All declarations of structure, union, or enumerated types that have the same scope and
6744 use the same tag declare the same type. Irrespective of whether there is a tag or what
6745 other declarations of the type are in the same translation unit, the type is incomplete<sup><a href="#note129"><b>129)</b></a></sup>
6746 until immediately after the closing brace of the list defining the content, and complete
6747 thereafter.
6749 Two declarations of structure, union, or enumerated types which are in different scopes or
6750 use different tags declare distinct types. Each declaration of a structure, union, or
6751 enumerated type which does not include a tag declares a distinct type.
6753 A type specifier of the form
6754 <pre>
6756 </pre>
6757 or
6758 <pre>
6760 </pre>
6761 or
6762 <pre>
6764 </pre>
6765 declares a structure, union, or enumerated type. The list defines the structure content,
6766 union content, or enumeration content. If an identifier is provided,<sup><a href="#note130"><b>130)</b></a></sup> the type specifier
6767 also declares the identifier to be the tag of that type.
6769 A declaration of the form
6770 <pre>
6771 struct-or-union identifier ;
6772 </pre>
6773 specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note131"><b>131)</b></a></sup>
6775 If a type specifier of the form
6776 <pre>
6777 struct-or-union identifier
6778 </pre>
6779 occurs other than as part of one of the above forms, and no other declaration of the
6780 identifier as a tag is visible, then it declares an incomplete structure or union type, and
6785 <!--page 138 -->
6787 If a type specifier of the form
6788 <pre>
6789 struct-or-union identifier
6790 </pre>
6791 or
6792 <pre>
6793 enum identifier
6794 </pre>
6795 occurs other than as part of one of the above forms, and a declaration of the identifier as a
6796 tag is visible, then it specifies the same type as that other declaration, and does not
6797 redeclare the tag.
6799 EXAMPLE 1 This mechanism allows declaration of a self-referential structure.
6800 <pre>
6801 struct tnode {
6802 int count;
6803 struct tnode *left, *right;
6804 };
6805 </pre>
6806 specifies a structure that contains an integer and two pointers to objects of the same type. Once this
6807 declaration has been given, the declaration
6808 <pre>
6809 struct tnode s, *sp;
6810 </pre>
6811 declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
6812 these declarations, the expression sp->left refers to the left struct tnode pointer of the object to
6813 which sp points; the expression s.right->count designates the count member of the right struct
6814 tnode pointed to from s.
6816 The following alternative formulation uses the typedef mechanism:
6817 <pre>
6818 typedef struct tnode TNODE;
6819 struct tnode {
6820 int count;
6821 TNODE *left, *right;
6822 };
6823 TNODE s, *sp;
6824 </pre>
6827 EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
6828 structures, the declarations
6829 <pre>
6830 struct s1 { struct s2 *s2p; /* ... */ }; // D1
6831 struct s2 { struct s1 *s1p; /* ... */ }; // D2
6832 </pre>
6833 specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
6834 declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
6835 D2. To eliminate this context sensitivity, the declaration
6836 <pre>
6837 struct s2;
6838 </pre>
6839 may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
6840 completes the specification of the new type.
6842 <p><b> Forward references</b>: declarators (<a href="#6.7.6">6.7.6</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
6843 <!--page 139 -->
6846 <p><small><a name="note129" href="#note129">129)</a> An incomplete type may only by used when the size of an object of that type is not needed. It is not
6847 needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
6848 when a pointer to or a function returning a structure or union is being declared. (See incomplete types
6849 in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
6850 </small>
6851 <p><small><a name="note130" href="#note130">130)</a> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
6852 of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
6853 can make use of that typedef name to declare objects having the specified structure, union, or
6854 enumerated type.
6855 </small>
6856 <p><small><a name="note131" href="#note131">131)</a> A similar construction with enum does not exist.
6857 </small>
6863 <pre>
6864 atomic-type-specifier:
6865 _Atomic ( type-name )
6866 </pre>
6869 Atomic type specifiers shall not be used if the implementation does not support atomic
6872 The type name in an atomic type specifier shall not refer to an array type, a function type,
6873 an atomic type, or a qualified type.
6876 The properties associated with atomic types are meaningful only for expressions that are
6877 lvalues. If the _Atomic keyword is immediately followed by a left parenthesis, it is
6878 interpreted as a type specifier (with a type name), not as a type qualifier.
6884 <pre>
6885 type-qualifier:
6886 const
6887 restrict
6888 volatile
6889 _Atomic
6890 </pre>
6893 Types other than pointer types whose referenced type is an object type shall not be
6894 restrict-qualified.
6896 The type modified by the _Atomic qualifier shall not be an array type or a function
6897 type.
6900 The properties associated with qualified types are meaningful only for expressions that
6903 If the same qualifier appears more than once in the same specifier-qualifier-list, either
6904 directly or via one or more typedefs, the behavior is the same as if it appeared only
6905 once. If other qualifiers appear along with the _Atomic qualifier in a specifier-qualifier-
6907 <!--page 140 -->
6908 list, the resulting type is the so-qualified atomic type.
6910 If an attempt is made to modify an object defined with a const-qualified type through use
6911 of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
6912 made to refer to an object defined with a volatile-qualified type through use of an lvalue
6913 with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note133"><b>133)</b></a></sup>
6915 An object that has volatile-qualified type may be modified in ways unknown to the
6916 implementation or have other unknown side effects. Therefore any expression referring
6917 to such an object shall be evaluated strictly according to the rules of the abstract machine,
6918 as described in <a href="#5.1.2.3">5.1.2.3</a>. Furthermore, at every sequence point the value last stored in the
6919 object shall agree with that prescribed by the abstract machine, except as modified by the
6920 unknown factors mentioned previously.<sup><a href="#note134"><b>134)</b></a></sup> What constitutes an access to an object that
6921 has volatile-qualified type is implementation-defined.
6923 An object that is accessed through a restrict-qualified pointer has a special association
6924 with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
6925 that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note135"><b>135)</b></a></sup> The intended
6926 use of the restrict qualifier (like the register storage class) is to promote
6927 optimization, and deleting all instances of the qualifier from all preprocessing translation
6928 units composing a conforming program does not change its meaning (i.e., observable
6929 behavior).
6931 If the specification of an array type includes any type qualifiers, the element type is so-
6932 qualified, not the array type. If the specification of a function type includes any type
6935 For two qualified types to be compatible, both shall have the identically qualified version
6936 of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
6937 does not affect the specified type.
6939 EXAMPLE 1 An object declared
6940 <pre>
6941 extern const volatile int real_time_clock;
6942 </pre>
6946 <!--page 141 -->
6947 may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
6950 EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
6951 modify an aggregate type:
6952 <pre>
6953 const struct s { int mem; } cs = { 1 };
6954 struct s ncs; // the object ncs is modifiable
6957 int *pi;
6958 const int *pci;
6959 ncs = cs; // valid
6960 cs = ncs; // violates modifiable lvalue constraint for =
6961 pi = &ncs.mem; // valid
6962 pi = &cs.mem; // violates type constraints for =
6963 pci = &cs.mem; // valid
6965 </pre>
6968 EXAMPLE 3 The declaration
6969 <pre>
6970 _Atomic volatile int *p;
6971 </pre>
6972 specifies that p has the type ''pointer to volatile atomic int'', a pointer to a volatile-qualified atomic type.
6976 <p><small><a name="note132" href="#note132">132)</a> The implementation may place a const object that is not volatile in a read-only region of
6977 storage. Moreover, the implementation need not allocate storage for such an object if its address is
6978 never used.
6979 </small>
6980 <p><small><a name="note133" href="#note133">133)</a> This applies to those objects that behave as if they were defined with qualified types, even if they are
6981 never actually defined as objects in the program (such as an object at a memory-mapped input/output
6982 address).
6983 </small>
6984 <p><small><a name="note134" href="#note134">134)</a> A volatile declaration may be used to describe an object corresponding to a memory-mapped
6985 input/output port or an object accessed by an asynchronously interrupting function. Actions on
6986 objects so declared shall not be ''optimized out'' by an implementation or reordered except as
6987 permitted by the rules for evaluating expressions.
6988 </small>
6989 <p><small><a name="note135" href="#note135">135)</a> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
6990 association between the allocated object and the pointer.
6991 </small>
6992 <p><small><a name="note136" href="#note136">136)</a> Both of these can occur through the use of typedefs.
6993 </small>
6998 Let D be a declaration of an ordinary identifier that provides a means of designating an
6999 object P as a restrict-qualified pointer to type T.
7001 If D appears inside a block and does not have storage class extern, let B denote the
7002 block. If D appears in the list of parameter declarations of a function definition, let B
7003 denote the associated block. Otherwise, let B denote the block of main (or the block of
7004 whatever function is called at program startup in a freestanding environment).
7006 In what follows, a pointer expression E is said to be based on object P if (at some
7007 sequence point in the execution of B prior to the evaluation of E) modifying P to point to
7008 a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note137"><b>137)</b></a></sup>
7009 Note that ''based'' is defined only for expressions with pointer types.
7011 During each execution of B, let L be any lvalue that has &L based on P. If L is used to
7012 access the value of the object X that it designates, and X is also modified (by any means),
7013 then the following requirements apply: T shall not be const-qualified. Every other lvalue
7014 used to access the value of X shall also have its address based on P. Every access that
7015 modifies X shall be considered also to modify P, for the purposes of this subclause. If P
7016 is assigned the value of a pointer expression E that is based on another restricted pointer
7019 <!--page 142 -->
7020 object P2, associated with block B2, then either the execution of B2 shall begin before
7021 the execution of B, or the execution of B2 shall end prior to the assignment. If these
7022 requirements are not met, then the behavior is undefined.
7024 Here an execution of B means that portion of the execution of the program that would
7025 correspond to the lifetime of an object with scalar type and automatic storage duration
7026 associated with B.
7028 A translator is free to ignore any or all aliasing implications of uses of restrict.
7030 EXAMPLE 1 The file scope declarations
7031 <pre>
7032 int * restrict a;
7033 int * restrict b;
7034 extern int c[];
7035 </pre>
7036 assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
7037 program, then it is never accessed using either of the other two.
7040 EXAMPLE 2 The function parameter declarations in the following example
7041 <pre>
7042 void f(int n, int * restrict p, int * restrict q)
7043 {
7045 *p++ = *q++;
7046 }
7047 </pre>
7048 assert that, during each execution of the function, if an object is accessed through one of the pointer
7049 parameters, then it is not also accessed through the other.
7051 The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
7052 analysis of function f without examining any of the calls of f in the program. The cost is that the
7053 programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
7054 second call of f in g has undefined behavior because each of d[1] through d[49] is accessed through
7055 both p and q.
7056 <pre>
7057 void g(void)
7058 {
7059 extern int d[100];
7062 }
7063 </pre>
7066 EXAMPLE 3 The function parameter declarations
7067 <pre>
7068 void h(int n, int * restrict p, int * restrict q, int * restrict r)
7069 {
7070 int i;
7072 p[i] = q[i] + r[i];
7073 }
7074 </pre>
7075 illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
7076 are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
7077 modified within function h.
7078 <!--page 143 -->
7080 EXAMPLE 4 The rule limiting assignments between restricted pointers does not distinguish between a
7081 function call and an equivalent nested block. With one exception, only ''outer-to-inner'' assignments
7082 between restricted pointers declared in nested blocks have defined behavior.
7083 <pre>
7084 {
7085 int * restrict p1;
7086 int * restrict q1;
7087 p1 = q1; // undefined behavior
7088 {
7089 int * restrict p2 = p1; // valid
7090 int * restrict q2 = q1; // valid
7091 p1 = q2; // undefined behavior
7092 p2 = q2; // undefined behavior
7093 }
7094 }
7095 </pre>
7097 The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
7098 precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
7099 example, this permits new_vector to return a vector.
7100 <pre>
7101 typedef struct { int n; float * restrict v; } vector;
7102 vector new_vector(int n)
7103 {
7104 vector t;
7105 t.n = n;
7106 t.v = malloc(n * sizeof (float));
7107 return t;
7108 }
7109 </pre>
7113 <p><small><a name="note137" href="#note137">137)</a> In other words, E depends on the value of P itself rather than on the value of an object referenced
7114 indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
7115 expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
7116 expressions *p and p[1] are not.
7117 </small>
7123 <pre>
7124 function-specifier:
7125 inline
7126 _Noreturn
7127 </pre>
7130 Function specifiers shall be used only in the declaration of an identifier for a function.
7132 An inline definition of a function with external linkage shall not contain a definition of a
7133 modifiable object with static or thread storage duration, and shall not contain a reference
7134 to an identifier with internal linkage.
7136 In a hosted environment, no function specifier(s) shall appear in a declaration of main.
7139 A function specifier may appear more than once; the behavior is the same as if it
7140 appeared only once.
7142 A function declared with an inline function specifier is an inline function. Making a
7143 function an inline function suggests that calls to the function be as fast as possible.<sup><a href="#note138"><b>138)</b></a></sup>
7144 <!--page 144 -->
7145 The extent to which such suggestions are effective is implementation-defined.<sup><a href="#note139"><b>139)</b></a></sup>
7147 Any function with internal linkage can be an inline function. For a function with external
7148 linkage, the following restrictions apply: If a function is declared with an inline
7149 function specifier, then it shall also be defined in the same translation unit. If all of the
7150 file scope declarations for a function in a translation unit include the inline function
7151 specifier without extern, then the definition in that translation unit is an inline
7152 definition. An inline definition does not provide an external definition for the function,
7153 and does not forbid an external definition in another translation unit. An inline definition
7154 provides an alternative to an external definition, which a translator may use to implement
7155 any call to the function in the same translation unit. It is unspecified whether a call to the
7156 function uses the inline definition or the external definition.<sup><a href="#note140"><b>140)</b></a></sup>
7158 A function declared with a _Noreturn function specifier shall not return to its caller.
7161 The implementation should produce a diagnostic message for a function declared with a
7162 _Noreturn function specifier that appears to be capable of returning to its caller.
7164 EXAMPLE 1 The declaration of an inline function with external linkage can result in either an external
7165 definition, or a definition available for use only within the translation unit. A file scope declaration with
7166 extern creates an external definition. The following example shows an entire translation unit.
7167 <pre>
7168 inline double fahr(double t)
7169 {
7171 }
7172 inline double cels(double t)
7173 {
7175 }
7176 extern double fahr(double); // creates an external definition
7177 </pre>
7182 <!--page 145 -->
7183 <pre>
7184 double convert(int is_fahr, double temp)
7185 {
7186 /* A translator may perform inline substitutions */
7187 return is_fahr ? cels(temp) : fahr(temp);
7188 }
7189 </pre>
7191 Note that the definition of fahr is an external definition because fahr is also declared with extern, but
7192 the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
7193 external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
7194 definition are distinct and either may be used for the call.
7197 EXAMPLE 2
7198 <pre>
7199 _Noreturn void f () {
7200 abort(); // ok
7201 }
7204 }
7205 </pre>
7210 <p><small><a name="note138" href="#note138">138)</a> By using, for example, an alternative to the usual function call mechanism, such as ''inline
7211 substitution''. Inline substitution is not textual substitution, nor does it create a new function.
7212 Therefore, for example, the expansion of a macro used within the body of the function uses the
7213 definition it had at the point the function body appears, and not where the function is called; and
7214 identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
7215 single address, regardless of the number of inline definitions that occur in addition to the external
7216 definition.
7217 </small>
7218 <p><small><a name="note139" href="#note139">139)</a> For example, an implementation might never perform inline substitution, or might only perform inline
7219 substitutions to calls in the scope of an inline declaration.
7220 </small>
7221 <p><small><a name="note140" href="#note140">140)</a> Since an inline definition is distinct from the corresponding external definition and from any other
7222 corresponding inline definitions in other translation units, all corresponding objects with static storage
7223 duration are also distinct in each of the definitions.
7224 </small>
7230 <pre>
7231 alignment-specifier:
7232 _Alignas ( type-name )
7233 _Alignas ( constant-expression )
7234 </pre>
7237 An alignment attribute shall not be specified in a declaration of a typedef, or a bit-field, or
7238 a function, or a parameter, or an object declared with the register storage-class
7239 specifier.
7241 The constant expression shall be an integer constant expression. It shall evaluate to a
7242 valid fundamental alignment, or to a valid extended alignment supported by the
7243 implementation in the context in which it appears, or to zero.
7245 The combined effect of all alignment attributes in a declaration shall not specify an
7246 alignment that is less strict than the alignment that would otherwise be required for the
7247 type of the object or member being declared.
7250 The first form is equivalent to _Alignas (_Alignof (type-name)).
7252 The alignment requirement of the declared object or member is taken to be the specified
7253 alignment. An alignment specification of zero has no effect.<sup><a href="#note141"><b>141)</b></a></sup> When multiple
7254 alignment specifiers occur in a declaration, the effective alignment requirement is the
7255 strictest specified alignment.
7256 <!--page 146 -->
7258 If the definition of an object has an alignment specifier, any other declaration of that
7259 object shall either specify equivalent alignment or have no alignment specifier. If the
7260 definition of an object does not have an alignment specifier, any other declaration of that
7261 object shall also have no alignment specifier. If declarations of an object in different
7262 translation units have different alignment specifiers, the behavior is undefined.
7265 <p><small><a name="note141" href="#note141">141)</a> An alignment specification of zero also does not affect other alignment specifications in the same
7266 declaration.
7267 </small>
7273 <pre>
7274 declarator:
7276 direct-declarator:
7277 identifier
7278 ( declarator )
7281 direct-declarator [ type-qualifier-list static assignment-expression ]
7283 direct-declarator ( parameter-type-list )
7285 pointer:
7288 type-qualifier-list:
7289 type-qualifier
7290 type-qualifier-list type-qualifier
7291 parameter-type-list:
7292 parameter-list
7293 parameter-list , ...
7294 parameter-list:
7295 parameter-declaration
7296 parameter-list , parameter-declaration
7297 parameter-declaration:
7298 declaration-specifiers declarator
7300 </pre>
7304 <!--page 147 -->
7305 <pre>
7306 identifier-list:
7307 identifier
7308 identifier-list , identifier
7309 </pre>
7312 Each declarator declares one identifier, and asserts that when an operand of the same
7313 form as the declarator appears in an expression, it designates a function or object with the
7314 scope, storage duration, and type indicated by the declaration specifiers.
7316 A full declarator is a declarator that is not part of another declarator. The end of a full
7317 declarator is a sequence point. If, in the nested sequence of declarators in a full
7318 declarator, there is a declarator specifying a variable length array type, the type specified
7319 by the full declarator is said to be variably modified. Furthermore, any type derived by
7320 declarator type derivation from a variably modified type is itself variably modified.
7322 In the following subclauses, consider a declaration
7323 <pre>
7324 T D1
7325 </pre>
7326 where T contains the declaration specifiers that specify a type T (such as int) and D1 is
7327 a declarator that contains an identifier ident. The type specified for the identifier ident in
7328 the various forms of declarator is described inductively using this notation.
7330 If, in the declaration ''T D1'', D1 has the form
7331 <pre>
7332 identifier
7333 </pre>
7334 then the type specified for ident is T .
7336 If, in the declaration ''T D1'', D1 has the form
7337 <pre>
7338 ( D )
7339 </pre>
7340 then ident has the type specified by the declaration ''T D''. Thus, a declarator in
7341 parentheses is identical to the unparenthesized declarator, but the binding of complicated
7342 declarators may be altered by parentheses.
7345 As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
7346 function declarators that modify an arithmetic, structure, union, or void type, either
7347 directly or via one or more typedefs.
7348 <p><b> Forward references</b>: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
7349 <!--page 148 -->
7355 If, in the declaration ''T D1'', D1 has the form
7356 <pre>
7358 </pre>
7359 and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
7360 T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
7361 pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
7363 For two pointer types to be compatible, both shall be identically qualified and both shall
7364 be pointers to compatible types.
7366 EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
7367 to a constant value'' and a ''constant pointer to a variable value''.
7368 <pre>
7369 const int *ptr_to_constant;
7370 int *const constant_ptr;
7371 </pre>
7372 The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
7373 but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
7374 int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
7375 same location.
7377 The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
7378 type ''pointer to int''.
7379 <pre>
7380 typedef int *int_ptr;
7381 const int_ptr constant_ptr;
7382 </pre>
7383 declares constant_ptr as an object that has type ''const-qualified pointer to int''.
7390 In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
7391 an expression or *. If they delimit an expression (which specifies the size of an array), the
7392 expression shall have an integer type. If the expression is a constant expression, it shall
7393 have a value greater than zero. The element type shall not be an incomplete or function
7394 type. The optional type qualifiers and the keyword static shall appear only in a
7395 declaration of a function parameter with an array type, and then only in the outermost
7396 array type derivation.
7398 If an identifier is declared as having a variably modified type, it shall be an ordinary
7399 identifier (as defined in <a href="#6.2.3">6.2.3</a>), have no linkage, and have either block scope or function
7400 prototype scope. If an identifier is declared to be an object with static or thread storage
7401 duration, it shall not have a variable length array type.
7402 <!--page 149 -->
7405 If, in the declaration ''T D1'', D1 has one of the forms:
7406 <pre>
7409 D[ type-qualifier-list static assignment-expression ]
7411 </pre>
7412 and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
7413 T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note142"><b>142)</b></a></sup>
7414 (See <a href="#6.7.6.3">6.7.6.3</a> for the meaning of the optional type qualifiers and the keyword static.)
7416 If the size is not present, the array type is an incomplete type. If the size is * instead of
7417 being an expression, the array type is a variable length array type of unspecified size,
7418 which can only be used in declarations or type names with function prototype scope;<sup><a href="#note143"><b>143)</b></a></sup>
7419 such arrays are nonetheless complete types. If the size is an integer constant expression
7420 and the element type has a known constant size, the array type is not a variable length
7421 array type; otherwise, the array type is a variable length array type. (Variable length
7422 arrays are a conditional feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.)
7424 If the size is an expression that is not an integer constant expression: if it occurs in a
7425 declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
7426 each time it is evaluated it shall have a value greater than zero. The size of each instance
7427 of a variable length array type does not change during its lifetime. Where a size
7428 expression is part of the operand of a sizeof operator and changing the value of the
7429 size expression would not affect the result of the operator, it is unspecified whether or not
7430 the size expression is evaluated.
7432 For two array types to be compatible, both shall have compatible element types, and if
7433 both size specifiers are present, and are integer constant expressions, then both size
7434 specifiers shall have the same constant value. If the two array types are used in a context
7435 which requires them to be compatible, it is undefined behavior if the two size specifiers
7436 evaluate to unequal values.
7438 EXAMPLE 1
7439 <pre>
7441 </pre>
7442 declares an array of float numbers and an array of pointers to float numbers.
7445 EXAMPLE 2 Note the distinction between the declarations
7450 <!--page 150 -->
7451 <pre>
7452 extern int *x;
7453 extern int y[];
7454 </pre>
7455 The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
7456 (an incomplete type), the storage for which is defined elsewhere.
7459 EXAMPLE 3 The following declarations demonstrate the compatibility rules for variably modified types.
7460 <pre>
7461 extern int n;
7462 extern int m;
7463 void fcompat(void)
7464 {
7465 int a[n][6][m];
7467 int c[n][n][6][m];
7468 int (*r)[n][n][n+1];
7470 r = c; // compatible, but defined behavior only if
7472 }
7473 </pre>
7476 EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
7477 function prototype scope. Array objects declared with the _Thread_local, static, or extern
7478 storage-class specifier cannot have a variable length array (VLA) type. However, an object declared with
7479 the static storage-class specifier can have a VM type (that is, a pointer to a VLA type). Finally, all
7480 identifiers declared with a VM type have to be ordinary identifiers and cannot, therefore, be members of
7481 structures or unions.
7482 <pre>
7483 extern int n;
7484 int A[n]; // invalid: file scope VLA
7485 extern int (*p2)[n]; // invalid: file scope VM
7486 int B[100]; // valid: file scope but not VM
7487 void fvla(int m, int C[m][m]); // valid: VLA with prototype scope
7488 void fvla(int m, int C[m][m]) // valid: adjusted to auto pointer to VLA
7489 {
7490 typedef int VLA[m][m]; // valid: block scope typedef VLA
7491 struct tag {
7492 int (*y)[n]; // invalid: y not ordinary identifier
7493 int z[n]; // invalid: z not ordinary identifier
7494 };
7495 int D[m]; // valid: auto VLA
7496 static int E[m]; // invalid: static block scope VLA
7497 extern int F[m]; // invalid: F has linkage and is VLA
7498 int (*s)[m]; // valid: auto pointer to VLA
7499 extern int (*r)[m]; // invalid: r has linkage and points to VLA
7500 static int (*q)[m] = &B; // valid: q is a static block pointer to VLA
7501 }
7502 </pre>
7504 <p><b> Forward references</b>: function declarators (<a href="#6.7.6.3">6.7.6.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
7506 <!--page 151 -->
7509 <p><small><a name="note142" href="#note142">142)</a> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
7510 </small>
7511 <p><small><a name="note143" href="#note143">143)</a> Thus, * can be used only in function declarations that are not definitions (see <a href="#6.7.6.3">6.7.6.3</a>).
7512 </small>
7515 <h5><a name="6.7.6.3" href="#6.7.6.3">6.7.6.3 Function declarators (including prototypes)</a></h5>
7518 A function declarator shall not specify a return type that is a function type or an array
7519 type.
7521 The only storage-class specifier that shall occur in a parameter declaration is register.
7523 An identifier list in a function declarator that is not part of a definition of that function
7524 shall be empty.
7526 After adjustment, the parameters in a parameter type list in a function declarator that is
7527 part of a definition of that function shall not have incomplete type.
7530 If, in the declaration ''T D1'', D1 has the form
7531 <pre>
7532 D( parameter-type-list )
7533 </pre>
7534 or
7535 <pre>
7537 </pre>
7538 and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
7539 T '', then the type specified for ident is ''derived-declarator-type-list function returning
7540 T ''.
7542 A parameter type list specifies the types of, and may declare identifiers for, the
7543 parameters of the function.
7545 A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
7546 type'', where the type qualifiers (if any) are those specified within the [ and ] of the
7547 array type derivation. If the keyword static also appears within the [ and ] of the
7548 array type derivation, then for each call to the function, the value of the corresponding
7549 actual argument shall provide access to the first element of an array with at least as many
7550 elements as specified by the size expression.
7552 A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
7555 If the list terminates with an ellipsis (, ...), no information about the number or types
7558 The special case of an unnamed parameter of type void as the only item in the list
7559 specifies that the function has no parameters.
7563 <!--page 152 -->
7565 If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
7566 parameter name, it shall be taken as a typedef name.
7568 If the function declarator is not part of a definition of that function, parameters may have
7569 incomplete type and may use the [*] notation in their sequences of declarator specifiers
7570 to specify variable length array types.
7572 The storage-class specifier in the declaration specifiers for a parameter declaration, if
7573 present, is ignored unless the declared parameter is one of the members of the parameter
7574 type list for a function definition.
7576 An identifier list declares only the identifiers of the parameters of the function. An empty
7577 list in a function declarator that is part of a definition of that function specifies that the
7578 function has no parameters. The empty list in a function declarator that is not part of a
7579 definition of that function specifies that no information about the number or types of the
7582 For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note146"><b>146)</b></a></sup>
7583 Moreover, the parameter type lists, if both are present, shall agree in the number of
7584 parameters and in use of the ellipsis terminator; corresponding parameters shall have
7585 compatible types. If one type has a parameter type list and the other type is specified by a
7586 function declarator that is not part of a function definition and that contains an empty
7587 identifier list, the parameter list shall not have an ellipsis terminator and the type of each
7588 parameter shall be compatible with the type that results from the application of the
7589 default argument promotions. If one type has a parameter type list and the other type is
7590 specified by a function definition that contains a (possibly empty) identifier list, both shall
7591 agree in the number of parameters, and the type of each prototype parameter shall be
7592 compatible with the type that results from the application of the default argument
7593 promotions to the type of the corresponding identifier. (In the determination of type
7594 compatibility and of a composite type, each parameter declared with function or array
7595 type is taken as having the adjusted type and each parameter declared with qualified type
7596 is taken as having the unqualified version of its declared type.)
7598 EXAMPLE 1 The declaration
7599 <pre>
7600 int f(void), *fip(), (*pfi)();
7601 </pre>
7602 declares a function f with no parameters returning an int, a function fip with no parameter specification
7603 returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
7604 int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
7605 declaration suggests, and the same construction in an expression requires, the calling of a function fip,
7606 and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
7607 extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
7610 <!--page 153 -->
7611 designator, which is then used to call the function; it returns an int.
7613 If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
7614 declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
7615 internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
7616 the identifier of the pointer pfi has block scope and no linkage.
7619 EXAMPLE 2 The declaration
7620 <pre>
7621 int (*apfi[3])(int *x, int *y);
7622 </pre>
7623 declares an array apfi of three pointers to functions returning int. Each of these functions has two
7624 parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
7625 go out of scope at the end of the declaration of apfi.
7628 EXAMPLE 3 The declaration
7629 <pre>
7630 int (*fpfi(int (*)(long), int))(int, ...);
7631 </pre>
7632 declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
7633 parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
7634 The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
7635 additional arguments of any type.
7638 EXAMPLE 4 The following prototype has a variably modified parameter.
7639 <pre>
7640 void addscalar(int n, int m,
7641 double a[n][n*m+300], double x);
7642 int main()
7643 {
7646 return 0;
7647 }
7648 void addscalar(int n, int m,
7649 double a[n][n*m+300], double x)
7650 {
7653 // a is a pointer to a VLA with n*m+300 elements
7654 a[i][j] += x;
7655 }
7656 </pre>
7659 EXAMPLE 5 The following are all compatible function prototype declarators.
7660 <pre>
7661 double maximum(int n, int m, double a[n][m]);
7662 double maximum(int n, int m, double a[*][*]);
7663 double maximum(int n, int m, double a[ ][*]);
7664 double maximum(int n, int m, double a[ ][m]);
7665 </pre>
7666 as are:
7667 <!--page 154 -->
7668 <pre>
7669 void f(double (* restrict a)[5]);
7670 void f(double a[restrict][5]);
7673 </pre>
7674 (Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
7675 non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
7677 <p><b> Forward references</b>: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
7680 <p><small><a name="note144" href="#note144">144)</a> The macros defined in the <a href="#7.16"><stdarg.h></a> header (<a href="#7.16">7.16</a>) may be used to access arguments that
7681 correspond to the ellipsis.
7682 </small>
7683 <p><small><a name="note145" href="#note145">145)</a> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
7684 </small>
7685 <p><small><a name="note146" href="#note146">146)</a> If both function types are ''old style'', parameter types are not compared.
7686 </small>
7692 <pre>
7693 type-name:
7695 abstract-declarator:
7696 pointer
7698 direct-abstract-declarator:
7699 ( abstract-declarator )
7703 assignment-expression ]
7705 assignment-expression ]
7708 </pre>
7711 In several contexts, it is necessary to specify a type. This is accomplished using a type
7712 name, which is syntactically a declaration for a function or an object of that type that
7715 EXAMPLE The constructions
7716 <pre>
7717 (a) int
7718 (b) int *
7719 (c) int *[3]
7720 (d) int (*)[3]
7721 (e) int (*)[*]
7722 (f) int *()
7723 (g) int (*)(void)
7724 (h) int (*const [])(unsigned int, ...)
7725 </pre>
7726 name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
7727 array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
7728 with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
7731 <!--page 155 -->
7732 returning an int, and (h) array of an unspecified number of constant pointers to functions, each with one
7733 parameter that has type unsigned int and an unspecified number of other parameters, returning an
7734 int.
7738 <p><small><a name="note147" href="#note147">147)</a> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
7739 parameter specification'', rather than redundant parentheses around the omitted identifier.
7740 </small>
7746 <pre>
7747 typedef-name:
7748 identifier
7749 </pre>
7752 If a typedef name specifies a variably modified type then it shall have block scope.
7755 In a declaration whose storage-class specifier is typedef, each declarator defines an
7756 identifier to be a typedef name that denotes the type specified for the identifier in the way
7757 described in <a href="#6.7.6">6.7.6</a>. Any array size expressions associated with variable length array
7758 declarators are evaluated each time the declaration of the typedef name is reached in the
7759 order of execution. A typedef declaration does not introduce a new type, only a
7760 synonym for the type so specified. That is, in the following declarations:
7761 <pre>
7762 typedef T type_ident;
7763 type_ident D;
7764 </pre>
7765 type_ident is defined as a typedef name with the type specified by the declaration
7766 specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
7767 type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
7768 typedef name shares the same name space as other identifiers declared in ordinary
7769 declarators.
7771 EXAMPLE 1 After
7772 <pre>
7773 typedef int MILES, KLICKSP();
7774 typedef struct { double hi, lo; } range;
7775 </pre>
7776 the constructions
7777 <pre>
7778 MILES distance;
7779 extern KLICKSP *metricp;
7780 range x;
7781 range z, *zp;
7782 </pre>
7783 are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
7784 parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
7785 such a structure. The object distance has a type compatible with any other int object.
7788 EXAMPLE 2 After the declarations
7789 <pre>
7790 typedef struct s1 { int x; } t1, *tp1;
7791 typedef struct s2 { int x; } t2, *tp2;
7792 </pre>
7793 type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
7794 <!--page 156 -->
7795 s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
7798 EXAMPLE 3 The following obscure constructions
7799 <pre>
7800 typedef signed int t;
7801 typedef int plain;
7802 struct tag {
7803 unsigned t:4;
7804 const t:5;
7805 plain r:5;
7806 };
7807 </pre>
7808 declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
7809 with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
7810 qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
7811 [-16, +15], and one named r that contains values in one of the ranges [0, 31], [-15, +15], or [-16, +15].
7812 (The choice of range is implementation-defined.) The first two bit-field declarations differ in that
7813 unsigned is a type specifier (which forces t to be the name of a structure member), while const is a
7814 type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed
7815 in an inner scope by
7816 <pre>
7817 t f(t (t));
7818 long t;
7819 </pre>
7820 then a function f is declared with type ''function returning signed int with one unnamed parameter
7821 with type pointer to function returning signed int with one unnamed parameter with type signed
7822 int'', and an identifier t with type long int.
7825 EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
7826 following declarations of the signal function specify exactly the same type, the first without making use
7827 of any typedef names.
7828 <pre>
7829 typedef void fv(int), (*pfv)(int);
7830 void (*signal(int, void (*)(int)))(int);
7831 fv *signal(int, fv *);
7832 pfv signal(int, pfv);
7833 </pre>
7836 EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
7837 time the typedef name is defined, not each time it is used:
7838 <!--page 157 -->
7839 <pre>
7840 void copyt(int n)
7841 {
7842 typedef int B[n]; // B is n ints, n evaluated now
7843 n += 1;
7844 B a; // a is n ints, n without += 1
7845 int b[n]; // a and b are different sizes
7847 a[i-1] = b[i];
7848 }
7849 </pre>
7855 <pre>
7856 initializer:
7857 assignment-expression
7858 { initializer-list }
7859 { initializer-list , }
7860 initializer-list:
7863 designation:
7864 designator-list =
7865 designator-list:
7866 designator
7867 designator-list designator
7868 designator:
7869 [ constant-expression ]
7870 . identifier
7871 </pre>
7874 No initializer shall attempt to provide a value for an object not contained within the entity
7875 being initialized.
7877 The type of the entity to be initialized shall be an array of unknown size or a complete
7878 object type that is not a variable length array type.
7880 All the expressions in an initializer for an object that has static or thread storage duration
7881 shall be constant expressions or string literals.
7883 If the declaration of an identifier has block scope, and the identifier has external or
7884 internal linkage, the declaration shall have no initializer for the identifier.
7886 If a designator has the form
7887 <pre>
7888 [ constant-expression ]
7889 </pre>
7890 then the current object (defined below) shall have array type and the expression shall be
7891 an integer constant expression. If the array is of unknown size, any nonnegative value is
7892 valid.
7894 If a designator has the form
7895 <pre>
7896 . identifier
7897 </pre>
7898 then the current object (defined below) shall have structure or union type and the
7899 identifier shall be the name of a member of that type.
7900 <!--page 158 -->
7903 An initializer specifies the initial value stored in an object.
7905 Except where explicitly stated otherwise, for the purposes of this subclause unnamed
7906 members of objects of structure and union type do not participate in initialization.
7907 Unnamed members of structure objects have indeterminate value even after initialization.
7909 If an object that has automatic storage duration is not initialized explicitly, its value is
7910 indeterminate. If an object that has static or thread storage duration is not initialized
7911 explicitly, then:
7912 <ul>
7913 <li> if it has pointer type, it is initialized to a null pointer;
7914 <li> if it has arithmetic type, it is initialized to (positive or unsigned) zero;
7915 <li> if it is an aggregate, every member is initialized (recursively) according to these rules,
7916 and any padding is initialized to zero bits;
7917 <li> if it is a union, the first named member is initialized (recursively) according to these
7918 rules, and any padding is initialized to zero bits;
7919 </ul>
7921 The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
7922 initial value of the object is that of the expression (after conversion); the same type
7923 constraints and conversions as for simple assignment apply, taking the type of the scalar
7924 to be the unqualified version of its declared type.
7926 The rest of this subclause deals with initializers for objects that have aggregate or union
7927 type.
7929 The initializer for a structure or union object that has automatic storage duration shall be
7930 either an initializer list as described below, or a single expression that has compatible
7931 structure or union type. In the latter case, the initial value of the object, including
7932 unnamed members, is that of the expression.
7934 An array of character type may be initialized by a character string literal or UTF-8 string
7935 literal, optionally enclosed in braces. Successive bytes of the string literal (including the
7936 terminating null character if there is room or if the array is of unknown size) initialize the
7937 elements of the array.
7939 An array with element type compatible with a qualified or unqualified version of
7940 wchar_t, char16_t, or char32_t may be initialized by a wide string literal with
7941 the corresponding encoding prefix (L, u, or U, respectively), optionally enclosed in
7942 braces. Successive wide characters of the wide string literal (including the terminating
7943 null wide character if there is room or if the array is of unknown size) initialize the
7944 elements of the array.
7946 Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
7947 enclosed list of initializers for the elements or named members.
7948 <!--page 159 -->
7950 Each brace-enclosed initializer list has an associated current object. When no
7951 designations are present, subobjects of the current object are initialized in order according
7952 to the type of the current object: array elements in increasing subscript order, structure
7953 members in declaration order, and the first named member of a union.<sup><a href="#note148"><b>148)</b></a></sup> In contrast, a
7954 designation causes the following initializer to begin initialization of the subobject
7955 described by the designator. Initialization then continues forward in order, beginning
7956 with the next subobject after that described by the designator.<sup><a href="#note149"><b>149)</b></a></sup>
7958 Each designator list begins its description with the current object associated with the
7959 closest surrounding brace pair. Each item in the designator list (in order) specifies a
7960 particular member of its current object and changes the current object for the next
7961 designator (if any) to be that member.<sup><a href="#note150"><b>150)</b></a></sup> The current object that results at the end of the
7962 designator list is the subobject to be initialized by the following initializer.
7964 The initialization shall occur in initializer list order, each initializer provided for a
7965 particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note151"><b>151)</b></a></sup>
7966 all subobjects that are not initialized explicitly shall be initialized implicitly the same as
7967 objects that have static storage duration.
7969 If the aggregate or union contains elements or members that are aggregates or unions,
7970 these rules apply recursively to the subaggregates or contained unions. If the initializer of
7971 a subaggregate or contained union begins with a left brace, the initializers enclosed by
7972 that brace and its matching right brace initialize the elements or members of the
7973 subaggregate or the contained union. Otherwise, only enough initializers from the list are
7974 taken to account for the elements or members of the subaggregate or the first member of
7975 the contained union; any remaining initializers are left to initialize the next element or
7976 member of the aggregate of which the current subaggregate or contained union is a part.
7978 If there are fewer initializers in a brace-enclosed list than there are elements or members
7979 of an aggregate, or fewer characters in a string literal used to initialize an array of known
7980 size than there are elements in the array, the remainder of the aggregate shall be
7981 initialized implicitly the same as objects that have static storage duration.
7985 <!--page 160 -->
7987 If an array of unknown size is initialized, its size is determined by the largest indexed
7988 element with an explicit initializer. The array type is completed at the end of its
7989 initializer list.
7991 The evaluations of the initialization list expressions are indeterminately sequenced with
7992 respect to one another and thus the order in which any side effects occur is
7995 EXAMPLE 1 Provided that <a href="#7.3"><complex.h></a> has been #included, the declarations
7996 <pre>
7999 </pre>
8003 EXAMPLE 2 The declaration
8004 <pre>
8006 </pre>
8007 defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
8008 and there are three initializers.
8011 EXAMPLE 3 The declaration
8012 <pre>
8017 };
8018 </pre>
8019 is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
8021 y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
8022 been achieved by
8023 <pre>
8026 };
8027 </pre>
8028 The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
8032 EXAMPLE 4 The declaration
8033 <pre>
8036 };
8037 </pre>
8038 initializes the first column of z as specified and initializes the rest with zeros.
8041 EXAMPLE 5 The declaration
8042 <pre>
8044 </pre>
8045 is a definition with an inconsistently bracketed initialization. It defines an array with two element
8049 <!--page 161 -->
8053 EXAMPLE 6 The declaration
8054 <pre>
8056 { 1 },
8059 };
8060 </pre>
8061 contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
8063 q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
8064 q[0][0] does not begin with a left brace, so up to six items from the current list may be used. There is
8065 only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers
8066 for q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their
8067 respective two-dimensional subaggregates. If there had been more than six items in any of the lists, a
8068 diagnostic message would have been issued. The same initialization result could have been achieved by:
8069 <pre>
8074 };
8075 </pre>
8076 or by:
8077 <pre>
8079 {
8080 { 1 },
8081 },
8082 {
8084 },
8085 {
8087 { 6 },
8088 }
8089 };
8090 </pre>
8091 in a fully bracketed form.
8093 Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
8094 cause confusion.
8097 EXAMPLE 7 One form of initialization that completes array types involves typedef names. Given the
8098 declaration
8099 <pre>
8100 typedef int A[]; // OK - declared with block scope
8101 </pre>
8102 the declaration
8103 <pre>
8105 </pre>
8106 is identical to
8107 <pre>
8109 </pre>
8110 due to the rules for incomplete types.
8111 <!--page 162 -->
8113 EXAMPLE 8 The declaration
8114 <pre>
8116 </pre>
8117 defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
8118 This declaration is identical to
8119 <pre>
8120 char s[] = { 'a', 'b', 'c', '\0' },
8121 t[] = { 'a', 'b', 'c' };
8122 </pre>
8123 The contents of the arrays are modifiable. On the other hand, the declaration
8124 <pre>
8125 char *p = "abc";
8126 </pre>
8127 defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
8128 with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
8129 modify the contents of the array, the behavior is undefined.
8132 EXAMPLE 9 Arrays can be initialized to correspond to the elements of an enumeration by using
8133 designators:
8134 <pre>
8135 enum { member_one, member_two };
8136 const char *nm[] = {
8137 [member_two] = "member two",
8138 [member_one] = "member one",
8139 };
8140 </pre>
8143 EXAMPLE 10 Structure members can be initialized to nonzero values without depending on their order:
8144 <pre>
8146 </pre>
8149 EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
8150 might be misunderstood:
8151 <pre>
8152 struct { int a[3], b; } w[] =
8154 </pre>
8157 EXAMPLE 12 Space can be ''allocated'' from both ends of an array by using a single designator:
8158 <pre>
8159 int a[MAX] = {
8161 };
8162 </pre>
8164 In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
8165 than ten, some of the values provided by the first five initializers will be overridden by the second five.
8168 EXAMPLE 13 Any member of a union can be initialized:
8169 <pre>
8170 union { /* ... */ } u = { .any_member = 42 };
8171 </pre>
8173 <p><b> Forward references</b>: common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>).
8174 <!--page 163 -->
8177 <p><small><a name="note148" href="#note148">148)</a> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
8178 subobjects are initialized as usual, but the subaggregate or contained union does not become the
8179 current object: current objects are associated only with brace-enclosed initializer lists.
8180 </small>
8181 <p><small><a name="note149" href="#note149">149)</a> After a union member is initialized, the next object is not the next member of the union; instead, it is
8182 the next subobject of an object containing the union.
8183 </small>
8184 <p><small><a name="note150" href="#note150">150)</a> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
8185 the surrounding brace pair. Note, too, that each separate designator list is independent.
8186 </small>
8187 <p><small><a name="note151" href="#note151">151)</a> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
8188 not be evaluated at all.
8189 </small>
8190 <p><small><a name="note152" href="#note152">152)</a> In particular, the evaluation order need not be the same as the order of subobject initialization.
8191 </small>
8197 <pre>
8198 static_assert-declaration:
8199 _Static_assert ( constant-expression , string-literal ) ;
8200 </pre>
8203 The constant expression shall compare unequal to 0.
8206 The constant expression shall be an integer constant expression. If the value of the
8207 constant expression compares unequal to 0, the declaration has no effect. Otherwise, the
8208 constraint is violated and the implementation shall produce a diagnostic message that
8209 includes the text of the string literal, except that characters not in the basic source
8210 character set are not required to appear in the message.
8212 <!--page 164 -->
8218 <pre>
8219 statement:
8220 labeled-statement
8221 compound-statement
8222 expression-statement
8223 selection-statement
8224 iteration-statement
8225 jump-statement
8226 </pre>
8229 A statement specifies an action to be performed. Except as indicated, statements are
8230 executed in sequence.
8232 A block allows a set of declarations and statements to be grouped into one syntactic unit.
8233 The initializers of objects that have automatic storage duration, and the variable length
8234 array declarators of ordinary identifiers with block scope, are evaluated and the values are
8235 stored in the objects (including storing an indeterminate value in objects without an
8236 initializer) each time the declaration is reached in the order of execution, as if it were a
8237 statement, and within each declaration in the order that declarators appear.
8239 A full expression is an expression that is not part of another expression or of a declarator.
8240 Each of the following is a full expression: an initializer that is not part of a compound
8241 literal; the expression in an expression statement; the controlling expression of a selection
8242 statement (if or switch); the controlling expression of a while or do statement; each
8243 of the (optional) expressions of a for statement; the (optional) expression in a return
8244 statement. There is a sequence point between the evaluation of a full expression and the
8245 evaluation of the next full expression to be evaluated.
8246 <p><b> Forward references</b>: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
8247 (<a href="#6.8.4">6.8.4</a>), iteration statements (<a href="#6.8.5">6.8.5</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>).
8253 <pre>
8254 labeled-statement:
8255 identifier : statement
8256 case constant-expression : statement
8257 default : statement
8258 </pre>
8261 A case or default label shall appear only in a switch statement. Further
8262 constraints on such labels are discussed under the switch statement.
8263 <!--page 165 -->
8265 Label names shall be unique within a function.
8268 Any statement may be preceded by a prefix that declares an identifier as a label name.
8269 Labels in themselves do not alter the flow of control, which continues unimpeded across
8270 them.
8271 <p><b> Forward references</b>: the goto statement (<a href="#6.8.6.1">6.8.6.1</a>), the switch statement (<a href="#6.8.4.2">6.8.4.2</a>).
8277 <pre>
8278 compound-statement:
8280 block-item-list:
8281 block-item
8282 block-item-list block-item
8283 block-item:
8284 declaration
8285 statement
8286 </pre>
8289 A compound statement is a block.
8295 <pre>
8296 expression-statement:
8298 </pre>
8301 The expression in an expression statement is evaluated as a void expression for its side
8304 A null statement (consisting of just a semicolon) performs no operations.
8306 EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
8307 discarding of its value may be made explicit by converting the expression to a void expression by means of
8308 a cast:
8309 <pre>
8310 int p(int);
8311 /* ... */
8312 (void)p(0);
8313 </pre>
8317 <!--page 166 -->
8319 EXAMPLE 2 In the program fragment
8320 <pre>
8321 char *s;
8322 /* ... */
8323 while (*s++ != '\0')
8324 ;
8325 </pre>
8326 a null statement is used to supply an empty loop body to the iteration statement.
8329 EXAMPLE 3 A null statement may also be used to carry a label just before the closing } of a compound
8330 statement.
8331 <pre>
8332 while (loop1) {
8333 /* ... */
8334 while (loop2) {
8335 /* ... */
8336 if (want_out)
8337 goto end_loop1;
8338 /* ... */
8339 }
8340 /* ... */
8341 end_loop1: ;
8342 }
8343 </pre>
8348 <p><small><a name="note153" href="#note153">153)</a> Such as assignments, and function calls which have side effects.
8349 </small>
8355 <pre>
8356 selection-statement:
8357 if ( expression ) statement
8358 if ( expression ) statement else statement
8359 switch ( expression ) statement
8360 </pre>
8363 A selection statement selects among a set of statements depending on the value of a
8364 controlling expression.
8366 A selection statement is a block whose scope is a strict subset of the scope of its
8367 enclosing block. Each associated substatement is also a block whose scope is a strict
8368 subset of the scope of the selection statement.
8374 The controlling expression of an if statement shall have scalar type.
8377 In both forms, the first substatement is executed if the expression compares unequal to 0.
8378 In the else form, the second substatement is executed if the expression compares equal
8379 <!--page 167 -->
8380 to 0. If the first substatement is reached via a label, the second substatement is not
8381 executed.
8383 An else is associated with the lexically nearest preceding if that is allowed by the
8384 syntax.
8390 The controlling expression of a switch statement shall have integer type.
8392 If a switch statement has an associated case or default label within the scope of an
8393 identifier with a variably modified type, the entire switch statement shall be within the
8396 The expression of each case label shall be an integer constant expression and no two of
8397 the case constant expressions in the same switch statement shall have the same value
8398 after conversion. There may be at most one default label in a switch statement.
8399 (Any enclosed switch statement may have a default label or case constant
8400 expressions with values that duplicate case constant expressions in the enclosing
8401 switch statement.)
8404 A switch statement causes control to jump to, into, or past the statement that is the
8405 switch body, depending on the value of a controlling expression, and on the presence of a
8406 default label and the values of any case labels on or in the switch body. A case or
8407 default label is accessible only within the closest enclosing switch statement.
8409 The integer promotions are performed on the controlling expression. The constant
8410 expression in each case label is converted to the promoted type of the controlling
8411 expression. If a converted value matches that of the promoted controlling expression,
8412 control jumps to the statement following the matched case label. Otherwise, if there is
8413 a default label, control jumps to the labeled statement. If no converted case constant
8414 expression matches and there is no default label, no part of the switch body is
8415 executed.
8418 As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
8419 switch statement.
8424 <!--page 168 -->
8426 EXAMPLE In the artificial program fragment
8427 <pre>
8428 switch (expr)
8429 {
8430 int i = 4;
8431 f(i);
8432 case 0:
8433 i = 17;
8434 /* falls through into default code */
8435 default:
8436 printf("%d\n", i);
8437 }
8438 </pre>
8439 the object whose identifier is i exists with automatic storage duration (within the block) but is never
8440 initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
8441 access an indeterminate value. Similarly, the call to the function f cannot be reached.
8445 <p><small><a name="note154" href="#note154">154)</a> That is, the declaration either precedes the switch statement, or it follows the last case or
8446 default label associated with the switch that is in the block containing the declaration.
8447 </small>
8453 <pre>
8454 iteration-statement:
8455 while ( expression ) statement
8456 do statement while ( expression ) ;
8457 for ( expression<sub>opt</sub> ; expression<sub>opt</sub> ; expression<sub>opt</sub> ) statement
8459 </pre>
8462 The controlling expression of an iteration statement shall have scalar type.
8464 The declaration part of a for statement shall only declare identifiers for objects having
8465 storage class auto or register.
8468 An iteration statement causes a statement called the loop body to be executed repeatedly
8469 until the controlling expression compares equal to 0. The repetition occurs regardless of
8470 whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note155"><b>155)</b></a></sup>
8472 An iteration statement is a block whose scope is a strict subset of the scope of its
8473 enclosing block. The loop body is also a block whose scope is a strict subset of the scope
8474 of the iteration statement.
8476 An iteration statement whose controlling expression is not a constant expression,<sup><a href="#note156"><b>156)</b></a></sup> that
8477 performs no input/output operations, does not access volatile objects, and performs no
8478 synchronization or atomic operations in its body, controlling expression, or (in the case of
8480 <!--page 169 -->
8481 a for statement) its expression-3, may be assumed by the implementation to
8485 <p><small><a name="note155" href="#note155">155)</a> Code jumped over is not executed. In particular, the controlling expression of a for or while
8486 statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
8487 </small>
8488 <p><small><a name="note156" href="#note156">156)</a> An omitted controlling expression is replaced by a nonzero constant, which is a constant expression.
8489 </small>
8490 <p><small><a name="note157" href="#note157">157)</a> This is intended to allow compiler transformations such as removal of empty loops even when
8491 termination cannot be proven.
8492 </small>
8497 The evaluation of the controlling expression takes place before each execution of the loop
8498 body.
8503 The evaluation of the controlling expression takes place after each execution of the loop
8504 body.
8509 The statement
8510 <pre>
8512 </pre>
8513 behaves as follows: The expression expression-2 is the controlling expression that is
8514 evaluated before each execution of the loop body. The expression expression-3 is
8515 evaluated as a void expression after each execution of the loop body. If clause-1 is a
8516 declaration, the scope of any identifiers it declares is the remainder of the declaration and
8517 the entire loop, including the other two expressions; it is reached in the order of execution
8518 before the first evaluation of the controlling expression. If clause-1 is an expression, it is
8519 evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note158"><b>158)</b></a></sup>
8522 nonzero constant.
8525 <p><small><a name="note158" href="#note158">158)</a> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
8526 the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
8527 such that execution of the loop continues until the expression compares equal to 0; and expression-3
8528 specifies an operation (such as incrementing) that is performed after each iteration.
8529 </small>
8535 <pre>
8536 jump-statement:
8537 goto identifier ;
8538 continue ;
8539 break ;
8541 </pre>
8546 <!--page 170 -->
8549 A jump statement causes an unconditional jump to another place.
8555 The identifier in a goto statement shall name a label located somewhere in the enclosing
8556 function. A goto statement shall not jump from outside the scope of an identifier having
8557 a variably modified type to inside the scope of that identifier.
8560 A goto statement causes an unconditional jump to the statement prefixed by the named
8561 label in the enclosing function.
8563 EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
8564 following outline presents one possible approach to a problem based on these three assumptions:
8565 <ol>
8566 <li> The general initialization code accesses objects only visible to the current function.
8567 <li> The general initialization code is too large to warrant duplication.
8568 <li> The code to determine the next operation is at the head of the loop. (To allow it to be reached by
8569 continue statements, for example.)
8570 <!--page 171 -->
8571 <pre>
8572 /* ... */
8573 goto first_time;
8574 for (;;) {
8575 // determine next operation
8576 /* ... */
8577 if (need to reinitialize) {
8578 // reinitialize-only code
8579 /* ... */
8580 first_time:
8581 // general initialization code
8582 /* ... */
8583 continue;
8584 }
8585 // handle other operations
8586 /* ... */
8587 }
8588 </pre>
8589 </ol>
8591 EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
8592 modified types. A jump within the scope, however, is permitted.
8593 <pre>
8594 goto lab3; // invalid: going INTO scope of VLA.
8595 {
8596 double a[n];
8597 a[j] = 4.4;
8598 lab3:
8599 a[j] = 3.3;
8600 goto lab4; // valid: going WITHIN scope of VLA.
8601 a[j] = 5.5;
8602 lab4:
8603 a[j] = 6.6;
8604 }
8605 goto lab4; // invalid: going INTO scope of VLA.
8606 </pre>
8613 A continue statement shall appear only in or as a loop body.
8616 A continue statement causes a jump to the loop-continuation portion of the smallest
8617 enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
8618 of the statements
8619 <pre>
8620 while (/* ... */) { do { for (/* ... */) {
8621 /* ... */ /* ... */ /* ... */
8622 continue; continue; continue;
8623 /* ... */ /* ... */ /* ... */
8624 contin: ; contin: ; contin: ;
8625 } } while (/* ... */); }
8626 </pre>
8627 unless the continue statement shown is in an enclosed iteration statement (in which
8628 case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note159"><b>159)</b></a></sup>
8631 <p><small><a name="note159" href="#note159">159)</a> Following the contin: label is a null statement.
8632 </small>
8638 A break statement shall appear only in or as a switch body or loop body.
8641 A break statement terminates execution of the smallest enclosing switch or iteration
8642 statement.
8646 <!--page 172 -->
8652 A return statement with an expression shall not appear in a function whose return type
8653 is void. A return statement without an expression shall only appear in a function
8654 whose return type is void.
8657 A return statement terminates execution of the current function and returns control to
8658 its caller. A function may have any number of return statements.
8660 If a return statement with an expression is executed, the value of the expression is
8661 returned to the caller as the value of the function call expression. If the expression has a
8662 type different from the return type of the function in which it appears, the value is
8663 converted as if by assignment to an object having the return type of the function.<sup><a href="#note160"><b>160)</b></a></sup>
8665 EXAMPLE In:
8666 <pre>
8667 struct s { double i; } f(void);
8668 union {
8669 struct {
8670 int f1;
8671 struct s f2;
8672 } u1;
8673 struct {
8674 struct s f3;
8675 int f4;
8676 } u2;
8677 } g;
8678 struct s f(void)
8679 {
8680 return g.u1.f2;
8681 }
8682 /* ... */
8683 g.u2.f3 = f();
8684 </pre>
8685 there is no undefined behavior, although there would be if the assignment were done directly (without using
8686 a function call to fetch the value).
8691 <!--page 173 -->
8694 <p><small><a name="note160" href="#note160">160)</a> The return statement is not an assignment. The overlap restriction of subclause <a href="#6.5.16.1">6.5.16.1</a> does not
8695 apply to the case of function return. The representation of floating-point values may have wider range
8696 or precision than implied by the type; a cast may be used to remove this extra range and precision.
8697 </small>
8703 <pre>
8704 translation-unit:
8705 external-declaration
8706 translation-unit external-declaration
8707 external-declaration:
8708 function-definition
8709 declaration
8710 </pre>
8713 The storage-class specifiers auto and register shall not appear in the declaration
8714 specifiers in an external declaration.
8716 There shall be no more than one external definition for each identifier declared with
8717 internal linkage in a translation unit. Moreover, if an identifier declared with internal
8718 linkage is used in an expression (other than as a part of the operand of a sizeof or
8719 _Alignof operator whose result is an integer constant), there shall be exactly one
8720 external definition for the identifier in the translation unit.
8723 As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
8724 which consists of a sequence of external declarations. These are described as ''external''
8725 because they appear outside any function (and hence have file scope). As discussed in
8726 <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
8727 by the identifier is a definition.
8729 An external definition is an external declaration that is also a definition of a function
8730 (other than an inline definition) or an object. If an identifier declared with external
8731 linkage is used in an expression (other than as part of the operand of a sizeof or
8732 _Alignof operator whose result is an integer constant), somewhere in the entire
8733 program there shall be exactly one external definition for the identifier; otherwise, there
8739 <!--page 174 -->
8742 <p><small><a name="note161" href="#note161">161)</a> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
8743 external definition for it.
8744 </small>
8750 <pre>
8751 function-definition:
8753 declaration-list:
8754 declaration
8755 declaration-list declaration
8756 </pre>
8759 The identifier declared in a function definition (which is the name of the function) shall
8760 have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note162"><b>162)</b></a></sup>
8762 The return type of a function shall be void or a complete object type other than array
8763 type.
8765 The storage-class specifier, if any, in the declaration specifiers shall be either extern or
8766 static.
8768 If the declarator includes a parameter type list, the declaration of each parameter shall
8769 include an identifier, except for the special case of a parameter list consisting of a single
8770 parameter of type void, in which case there shall not be an identifier. No declaration list
8771 shall follow.
8773 If the declarator includes an identifier list, each declaration in the declaration list shall
8774 have at least one declarator, those declarators shall declare only identifiers from the
8775 identifier list, and every identifier in the identifier list shall be declared. An identifier
8776 declared as a typedef name shall not be redeclared as a parameter. The declarations in the
8777 declaration list shall contain no storage-class specifier other than register and no
8778 initializations.
8782 <!--page 175 -->
8785 The declarator in a function definition specifies the name of the function being defined
8786 and the identifiers of its parameters. If the declarator includes a parameter type list, the
8787 list also specifies the types of all the parameters; such a declarator also serves as a
8788 function prototype for later calls to the same function in the same translation unit. If the
8789 declarator includes an identifier list,<sup><a href="#note163"><b>163)</b></a></sup> the types of the parameters shall be declared in a
8790 following declaration list. In either case, the type of each parameter is adjusted as
8791 described in <a href="#6.7.6.3">6.7.6.3</a> for a parameter type list; the resulting type shall be a complete object
8792 type.
8794 If a function that accepts a variable number of arguments is defined without a parameter
8795 type list that ends with the ellipsis notation, the behavior is undefined.
8797 Each parameter has automatic storage duration; its identifier is an lvalue.<sup><a href="#note164"><b>164)</b></a></sup> The layout
8798 of the storage for parameters is unspecified.
8800 On entry to the function, the size expressions of each variably modified parameter are
8801 evaluated and the value of each argument expression is converted to the type of the
8802 corresponding parameter as if by assignment. (Array expressions and function
8803 designators as arguments were converted to pointers before the call.)
8805 After all parameters have been assigned, the compound statement that constitutes the
8806 body of the function definition is executed.
8808 If the } that terminates a function is reached, and the value of the function call is used by
8809 the caller, the behavior is undefined.
8811 EXAMPLE 1 In the following:
8812 <pre>
8813 extern int max(int a, int b)
8814 {
8815 return a > b ? a : b;
8816 }
8817 </pre>
8818 extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
8819 function declarator; and
8820 <pre>
8821 { return a > b ? a : b; }
8822 </pre>
8823 is the function body. The following similar definition uses the identifier-list form for the parameter
8824 declarations:
8829 <!--page 176 -->
8830 <pre>
8831 extern int max(a, b)
8832 int a, b;
8833 {
8834 return a > b ? a : b;
8835 }
8836 </pre>
8837 Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
8838 that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
8839 to the function, whereas the second form does not.
8842 EXAMPLE 2 To pass one function to another, one might say
8843 <pre>
8844 int f(void);
8845 /* ... */
8846 g(f);
8847 </pre>
8848 Then the definition of g might read
8849 <pre>
8850 void g(int (*funcp)(void))
8851 {
8852 /* ... */
8853 (*funcp)(); /* or funcp(); ... */
8854 }
8855 </pre>
8856 or, equivalently,
8857 <pre>
8858 void g(int func(void))
8859 {
8860 /* ... */
8861 func(); /* or (*func)(); ... */
8862 }
8863 </pre>
8867 <p><small><a name="note162" href="#note162">162)</a> The intent is that the type category in a function definition cannot be inherited from a typedef:
8869 <pre>
8870 typedef int F(void); // type F is ''function with no parameters
8871 // returning int''
8872 F f, g; // f and g both have type compatible with F
8873 F f { /* ... */ } // WRONG: syntax/constraint error
8874 F g() { /* ... */ } // WRONG: declares that g returns a function
8875 int f(void) { /* ... */ } // RIGHT: f has type compatible with F
8876 int g() { /* ... */ } // RIGHT: g has type compatible with F
8877 F *e(void) { /* ... */ } // e returns a pointer to a function
8878 F *((e))(void) { /* ... */ } // same: parentheses irrelevant
8879 int (*fp)(void); // fp points to a function that has type F
8880 F *Fp; // Fp points to a function that has type F
8881 </pre>
8882 </small>
8883 <p><small><a name="note163" href="#note163">163)</a> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
8884 </small>
8885 <p><small><a name="note164" href="#note164">164)</a> A parameter identifier cannot be redeclared in the function body except in an enclosed block.
8886 </small>
8892 If the declaration of an identifier for an object has file scope and an initializer, the
8893 declaration is an external definition for the identifier.
8895 A declaration of an identifier for an object that has file scope without an initializer, and
8896 without a storage-class specifier or with the storage-class specifier static, constitutes a
8897 tentative definition. If a translation unit contains one or more tentative definitions for an
8898 identifier, and the translation unit contains no external definition for that identifier, then
8899 the behavior is exactly as if the translation unit contains a file scope declaration of that
8900 identifier, with the composite type as of the end of the translation unit, with an initializer
8901 equal to 0.
8903 If the declaration of an identifier for an object is a tentative definition and has internal
8904 linkage, the declared type shall not be an incomplete type.
8905 <!--page 177 -->
8907 EXAMPLE 1
8908 <pre>
8909 int i1 = 1; // definition, external linkage
8910 static int i2 = 2; // definition, internal linkage
8911 extern int i3 = 3; // definition, external linkage
8912 int i4; // tentative definition, external linkage
8913 static int i5; // tentative definition, internal linkage
8914 int i1; // valid tentative definition, refers to previous
8916 int i3; // valid tentative definition, refers to previous
8917 int i4; // valid tentative definition, refers to previous
8919 extern int i1; // refers to previous, whose linkage is external
8920 extern int i2; // refers to previous, whose linkage is internal
8921 extern int i3; // refers to previous, whose linkage is external
8922 extern int i4; // refers to previous, whose linkage is external
8923 extern int i5; // refers to previous, whose linkage is internal
8924 </pre>
8927 EXAMPLE 2 If at the end of the translation unit containing
8928 <pre>
8929 int i[];
8930 </pre>
8931 the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
8932 zero on program startup.
8933 <!--page 178 -->
8939 <!--page 179 -->
8940 <pre>
8941 preprocessing-file:
8943 group:
8944 group-part
8945 group group-part
8946 group-part:
8947 if-section
8948 control-line
8949 text-line
8950 # non-directive
8951 if-section:
8953 if-group:
8957 elif-groups:
8958 elif-group
8959 elif-groups elif-group
8960 elif-group:
8962 else-group:
8964 endif-line:
8965 # endif new-line
8966 control-line:
8967 # include pp-tokens new-line
8968 # define identifier replacement-list new-line
8970 replacement-list new-line
8971 # define identifier lparen ... ) replacement-list new-line
8972 # define identifier lparen identifier-list , ... )
8973 replacement-list new-line
8974 # undef identifier new-line
8975 # line pp-tokens new-line
8978 # new-line
8979 text-line:
8981 non-directive:
8982 pp-tokens new-line
8983 lparen:
8984 a ( character not immediately preceded by white-space
8985 replacement-list:
8987 pp-tokens:
8988 preprocessing-token
8989 pp-tokens preprocessing-token
8990 new-line:
8991 the new-line character
8992 </pre>
8995 A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
8996 following constraints: The first token in the sequence is a # preprocessing token that (at
8997 the start of translation phase 4) is either the first character in the source file (optionally
8998 after white space containing no new-line characters) or that follows white space
8999 containing at least one new-line character. The last token in the sequence is the first new-
9000 line character that follows the first token in the sequence.<sup><a href="#note165"><b>165)</b></a></sup> A new-line character ends
9001 the preprocessing directive even if it occurs within what would otherwise be an
9003 <!--page 180 -->
9004 invocation of a function-like macro.
9006 A text line shall not begin with a # preprocessing token. A non-directive shall not begin
9007 with any of the directive names appearing in the syntax.
9009 When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
9010 sequence of preprocessing tokens to occur between the directive name and the following
9011 new-line character.
9014 The only white-space characters that shall appear between preprocessing tokens within a
9015 preprocessing directive (from just after the introducing # preprocessing token through
9016 just before the terminating new-line character) are space and horizontal-tab (including
9017 spaces that have replaced comments or possibly other white-space characters in
9018 translation phase 3).
9021 The implementation can process and skip sections of source files conditionally, include
9022 other source files, and replace macros. These capabilities are called preprocessing,
9023 because conceptually they occur before translation of the resulting translation unit.
9025 The preprocessing tokens within a preprocessing directive are not subject to macro
9026 expansion unless otherwise stated.
9028 EXAMPLE In:
9029 <pre>
9030 #define EMPTY
9032 </pre>
9033 the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
9034 begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
9035 replaced.
9039 <p><small><a name="note165" href="#note165">165)</a> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
9040 significance, as all white space is equivalent except in certain situations during preprocessing (see the
9041 # character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
9042 </small>
9048 The expression that controls conditional inclusion shall be an integer constant expression
9049 except that: identifiers (including those lexically identical to keywords) are interpreted as
9050 described below;<sup><a href="#note166"><b>166)</b></a></sup> and it may contain unary operator expressions of the form
9051 <pre>
9052 defined identifier
9053 </pre>
9054 or
9055 <pre>
9056 defined ( identifier )
9057 </pre>
9058 which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
9061 <!--page 181 -->
9062 predefined or if it has been the subject of a #define preprocessing directive without an
9063 intervening #undef directive with the same subject identifier), 0 if it is not.
9065 Each preprocessing token that remains (in the list of preprocessing tokens that will
9066 become the controlling expression) after all macro replacements have occurred shall be in
9070 Preprocessing directives of the forms
9071 <pre>
9074 </pre>
9075 check whether the controlling constant expression evaluates to nonzero.
9077 Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
9078 the controlling constant expression are replaced (except for those macro names modified
9079 by the defined unary operator), just as in normal text. If the token defined is
9080 generated as a result of this replacement process or use of the defined unary operator
9081 does not match one of the two specified forms prior to macro replacement, the behavior is
9082 undefined. After all replacements due to macro expansion and the defined unary
9083 operator have been performed, all remaining identifiers (including those lexically
9084 identical to keywords) are replaced with the pp-number 0, and then each preprocessing
9085 token is converted into a token. The resulting tokens compose the controlling constant
9086 expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
9087 token conversion and evaluation, all signed integer types and all unsigned integer types
9088 act as if they have the same representation as, respectively, the types intmax_t and
9089 uintmax_t defined in the header <a href="#7.20"><stdint.h></a>.<sup><a href="#note167"><b>167)</b></a></sup> This includes interpreting
9090 character constants, which may involve converting escape sequences into execution
9091 character set members. Whether the numeric value for these character constants matches
9092 the value obtained when an identical character constant occurs in an expression (other
9093 than within a #if or #elif directive) is implementation-defined.<sup><a href="#note168"><b>168)</b></a></sup> Also, whether a
9094 single-character character constant may have a negative value is implementation-defined.
9099 <!--page 182 -->
9101 Preprocessing directives of the forms
9102 <pre>
9105 </pre>
9106 check whether the identifier is or is not currently defined as a macro name. Their
9107 conditions are equivalent to #if defined identifier and #if !defined identifier
9108 respectively.
9110 Each directive's condition is checked in order. If it evaluates to false (zero), the group
9111 that it controls is skipped: directives are processed only through the name that determines
9112 the directive in order to keep track of the level of nested conditionals; the rest of the
9113 directives' preprocessing tokens are ignored, as are the other preprocessing tokens in the
9114 group. Only the first group whose control condition evaluates to true (nonzero) is
9115 processed. If none of the conditions evaluates to true, and there is a #else directive, the
9116 group controlled by the #else is processed; lacking a #else directive, all the groups
9118 <p><b> Forward references</b>: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
9122 <p><small><a name="note166" href="#note166">166)</a> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
9123 either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
9124 </small>
9125 <p><small><a name="note167" href="#note167">167)</a> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
9126 0x8000 is signed and positive within a #if expression even though it would be unsigned in
9127 translation phase 7.
9128 </small>
9129 <p><small><a name="note168" href="#note168">168)</a> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
9130 evaluate to the same value in these two contexts.
9132 <pre>
9133 #if 'z' - 'a' == 25
9134 if ('z' - 'a' == 25)
9135 </pre>
9136 </small>
9137 <p><small><a name="note169" href="#note169">169)</a> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
9138 before the terminating new-line character. However, comments may appear anywhere in a source file,
9139 including within a preprocessing directive.
9140 </small>
9146 A #include directive shall identify a header or source file that can be processed by the
9147 implementation.
9150 A preprocessing directive of the form
9151 <pre>
9153 </pre>
9154 searches a sequence of implementation-defined places for a header identified uniquely by
9155 the specified sequence between the < and > delimiters, and causes the replacement of that
9156 directive by the entire contents of the header. How the places are specified or the header
9157 identified is implementation-defined.
9159 A preprocessing directive of the form
9160 <pre>
9161 # include "q-char-sequence" new-line
9162 </pre>
9163 causes the replacement of that directive by the entire contents of the source file identified
9164 by the specified sequence between the " delimiters. The named source file is searched
9167 <!--page 183 -->
9168 for in an implementation-defined manner. If this search is not supported, or if the search
9169 fails, the directive is reprocessed as if it read
9170 <pre>
9171 # include <h-char-sequence> new-line
9172 </pre>
9173 with the identical contained sequence (including > characters, if any) from the original
9174 directive.
9176 A preprocessing directive of the form
9177 <pre>
9178 # include pp-tokens new-line
9179 </pre>
9180 (that does not match one of the two previous forms) is permitted. The preprocessing
9181 tokens after include in the directive are processed just as in normal text. (Each
9182 identifier currently defined as a macro name is replaced by its replacement list of
9183 preprocessing tokens.) The directive resulting after all replacements shall match one of
9184 the two previous forms.<sup><a href="#note170"><b>170)</b></a></sup> The method by which a sequence of preprocessing tokens
9185 between a < and a > preprocessing token pair or a pair of " characters is combined into a
9186 single header name preprocessing token is implementation-defined.
9188 The implementation shall provide unique mappings for sequences consisting of one or
9189 more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
9190 first character shall not be a digit. The implementation may ignore distinctions of
9191 alphabetical case and restrict the mapping to eight significant characters before the
9192 period.
9194 A #include preprocessing directive may appear in a source file that has been read
9195 because of a #include directive in another file, up to an implementation-defined
9198 EXAMPLE 1 The most common uses of #include preprocessing directives are as in the following:
9199 <pre>
9201 #include "myprog.h"
9202 </pre>
9207 <!--page 184 -->
9209 EXAMPLE 2 This illustrates macro-replaced #include directives:
9210 <pre>
9211 #if VERSION == 1
9212 #define INCFILE "vers1.h"
9213 #elif VERSION == 2
9214 #define INCFILE "vers2.h" // and so on
9215 #else
9216 #define INCFILE "versN.h"
9217 #endif
9218 #include INCFILE
9219 </pre>
9224 <p><small><a name="note170" href="#note170">170)</a> Note that adjacent string literals are not concatenated into a single string literal (see the translation
9225 phases in <a href="#5.1.1.2">5.1.1.2</a>); thus, an expansion that results in two string literals is an invalid directive.
9226 </small>
9232 Two replacement lists are identical if and only if the preprocessing tokens in both have
9233 the same number, ordering, spelling, and white-space separation, where all white-space
9234 separations are considered identical.
9236 An identifier currently defined as an object-like macro shall not be redefined by another
9237 #define preprocessing directive unless the second definition is an object-like macro
9238 definition and the two replacement lists are identical. Likewise, an identifier currently
9239 defined as a function-like macro shall not be redefined by another #define
9240 preprocessing directive unless the second definition is a function-like macro definition
9241 that has the same number and spelling of parameters, and the two replacement lists are
9242 identical.
9244 There shall be white-space between the identifier and the replacement list in the definition
9245 of an object-like macro.
9247 If the identifier-list in the macro definition does not end with an ellipsis, the number of
9248 arguments (including those arguments consisting of no preprocessing tokens) in an
9249 invocation of a function-like macro shall equal the number of parameters in the macro
9250 definition. Otherwise, there shall be more arguments in the invocation than there are
9251 parameters in the macro definition (excluding the ...). There shall exist a )
9252 preprocessing token that terminates the invocation.
9254 The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
9255 macro that uses the ellipsis notation in the parameters.
9257 A parameter identifier in a function-like macro shall be uniquely declared within its
9258 scope.
9261 The identifier immediately following the define is called the macro name. There is one
9262 name space for macro names. Any white-space characters preceding or following the
9263 replacement list of preprocessing tokens are not considered part of the replacement list
9264 <!--page 185 -->
9265 for either form of macro.
9267 If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
9268 a preprocessing directive could begin, the identifier is not subject to macro replacement.
9270 A preprocessing directive of the form
9271 <pre>
9272 # define identifier replacement-list new-line
9273 </pre>
9274 defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note171"><b>171)</b></a></sup>
9275 to be replaced by the replacement list of preprocessing tokens that constitute the
9276 remainder of the directive. The replacement list is then rescanned for more macro names
9277 as specified below.
9279 A preprocessing directive of the form
9280 <pre>
9282 # define identifier lparen ... ) replacement-list new-line
9283 # define identifier lparen identifier-list , ... ) replacement-list new-line
9284 </pre>
9285 defines a function-like macro with parameters, whose use is similar syntactically to a
9286 function call. The parameters are specified by the optional list of identifiers, whose scope
9287 extends from their declaration in the identifier list until the new-line character that
9288 terminates the #define preprocessing directive. Each subsequent instance of the
9289 function-like macro name followed by a ( as the next preprocessing token introduces the
9290 sequence of preprocessing tokens that is replaced by the replacement list in the definition
9291 (an invocation of the macro). The replaced sequence of preprocessing tokens is
9292 terminated by the matching ) preprocessing token, skipping intervening matched pairs of
9293 left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
9294 tokens making up an invocation of a function-like macro, new-line is considered a normal
9295 white-space character.
9297 The sequence of preprocessing tokens bounded by the outside-most matching parentheses
9298 forms the list of arguments for the function-like macro. The individual arguments within
9299 the list are separated by comma preprocessing tokens, but comma preprocessing tokens
9300 between matching inner parentheses do not separate arguments. If there are sequences of
9301 preprocessing tokens within the list of arguments that would otherwise act as
9302 preprocessing directives,<sup><a href="#note172"><b>172)</b></a></sup> the behavior is undefined.
9304 If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
9305 including any separating comma preprocessing tokens, are merged to form a single item:
9308 <!--page 186 -->
9309 the variable arguments. The number of arguments so combined is such that, following
9310 merger, the number of arguments is one more than the number of parameters in the macro
9311 definition (excluding the ...).
9314 <p><small><a name="note171" href="#note171">171)</a> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
9315 not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
9316 are never scanned for macro names or parameters.
9317 </small>
9318 <p><small><a name="note172" href="#note172">172)</a> Despite the name, a non-directive is a preprocessing directive.
9319 </small>
9324 After the arguments for the invocation of a function-like macro have been identified,
9325 argument substitution takes place. A parameter in the replacement list, unless preceded
9326 by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
9327 replaced by the corresponding argument after all macros contained therein have been
9328 expanded. Before being substituted, each argument's preprocessing tokens are
9329 completely macro replaced as if they formed the rest of the preprocessing file; no other
9330 preprocessing tokens are available.
9332 An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
9333 were a parameter, and the variable arguments shall form the preprocessing tokens used to
9334 replace it.
9340 Each # preprocessing token in the replacement list for a function-like macro shall be
9341 followed by a parameter as the next preprocessing token in the replacement list.
9344 If, in the replacement list, a parameter is immediately preceded by a # preprocessing
9345 token, both are replaced by a single character string literal preprocessing token that
9346 contains the spelling of the preprocessing token sequence for the corresponding
9347 argument. Each occurrence of white space between the argument's preprocessing tokens
9348 becomes a single space character in the character string literal. White space before the
9349 first preprocessing token and after the last preprocessing token composing the argument
9350 is deleted. Otherwise, the original spelling of each preprocessing token in the argument
9351 is retained in the character string literal, except for special handling for producing the
9352 spelling of string literals and character constants: a \ character is inserted before each "
9353 and \ character of a character constant or string literal (including the delimiting "
9354 characters), except that it is implementation-defined whether a \ character is inserted
9355 before the \ character beginning a universal character name. If the replacement that
9356 results is not a valid character string literal, the behavior is undefined. The character
9357 string literal corresponding to an empty argument is "". The order of evaluation of # and
9358 ## operators is unspecified.
9359 <!--page 187 -->
9365 A ## preprocessing token shall not occur at the beginning or at the end of a replacement
9366 list for either form of macro definition.
9369 If, in the replacement list of a function-like macro, a parameter is immediately preceded
9370 or followed by a ## preprocessing token, the parameter is replaced by the corresponding
9371 argument's preprocessing token sequence; however, if an argument consists of no
9372 preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
9375 For both object-like and function-like macro invocations, before the replacement list is
9376 reexamined for more macro names to replace, each instance of a ## preprocessing token
9377 in the replacement list (not from an argument) is deleted and the preceding preprocessing
9378 token is concatenated with the following preprocessing token. Placemarker
9379 preprocessing tokens are handled specially: concatenation of two placemarkers results in
9380 a single placemarker preprocessing token, and concatenation of a placemarker with a
9381 non-placemarker preprocessing token results in the non-placemarker preprocessing token.
9382 If the result is not a valid preprocessing token, the behavior is undefined. The resulting
9383 token is available for further macro replacement. The order of evaluation of ## operators
9384 is unspecified.
9386 EXAMPLE In the following fragment:
9387 <pre>
9388 #define hash_hash # ## #
9389 #define mkstr(a) # a
9390 #define in_between(a) mkstr(a)
9391 #define join(c, d) in_between(c hash_hash d)
9392 char p[] = join(x, y); // equivalent to
9393 // char p[] = "x ## y";
9394 </pre>
9395 The expansion produces, at various stages:
9396 <pre>
9397 join(x, y)
9398 in_between(x hash_hash y)
9399 in_between(x ## y)
9400 mkstr(x ## y)
9401 "x ## y"
9402 </pre>
9403 In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
9404 this new token is not the ## operator.
9407 <!--page 188 -->
9410 <p><small><a name="note173" href="#note173">173)</a> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
9411 exist only within translation phase 4.
9412 </small>
9417 After all parameters in the replacement list have been substituted and # and ##
9418 processing has taken place, all placemarker preprocessing tokens are removed. The
9419 resulting preprocessing token sequence is then rescanned, along with all subsequent
9420 preprocessing tokens of the source file, for more macro names to replace.
9422 If the name of the macro being replaced is found during this scan of the replacement list
9423 (not including the rest of the source file's preprocessing tokens), it is not replaced.
9424 Furthermore, if any nested replacements encounter the name of the macro being replaced,
9425 it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
9426 available for further replacement even if they are later (re)examined in contexts in which
9427 that macro name preprocessing token would otherwise have been replaced.
9429 The resulting completely macro-replaced preprocessing token sequence is not processed
9430 as a preprocessing directive even if it resembles one, but all pragma unary operator
9433 EXAMPLE There are cases where it is not clear whether a replacement is nested or not. For example,
9434 given the following macro definitions:
9435 <pre>
9436 #define f(a) a*g
9437 #define g(a) f(a)
9438 </pre>
9439 the invocation
9440 <pre>
9442 </pre>
9443 may expand to either
9444 <pre>
9446 </pre>
9447 or
9448 <pre>
9450 </pre>
9451 Strictly conforming programs are not permitted to depend on such unspecified behavior.
9457 A macro definition lasts (independent of block structure) until a corresponding #undef
9458 directive is encountered or (if none is encountered) until the end of the preprocessing
9459 translation unit. Macro definitions have no significance after translation phase 4.
9461 A preprocessing directive of the form
9462 <pre>
9463 # undef identifier new-line
9464 </pre>
9465 causes the specified identifier no longer to be defined as a macro name. It is ignored if
9466 the specified identifier is not currently defined as a macro name.
9468 EXAMPLE 1 The simplest use of this facility is to define a ''manifest constant'', as in
9469 <!--page 189 -->
9470 <pre>
9471 #define TABSIZE 100
9472 int table[TABSIZE];
9473 </pre>
9476 EXAMPLE 2 The following defines a function-like macro whose value is the maximum of its arguments.
9477 It has the advantages of working for any compatible types of the arguments and of generating in-line code
9478 without the overhead of function calling. It has the disadvantages of evaluating one or the other of its
9479 arguments a second time (including side effects) and generating more code than a function if invoked
9480 several times. It also cannot have its address taken, as it has none.
9481 <pre>
9482 #define max(a, b) ((a) > (b) ? (a) : (b))
9483 </pre>
9484 The parentheses ensure that the arguments and the resulting expression are bound properly.
9487 EXAMPLE 3 To illustrate the rules for redefinition and reexamination, the sequence
9488 <pre>
9489 #define x 3
9490 #define f(a) f(x * (a))
9491 #undef x
9492 #define x 2
9493 #define g f
9494 #define z z[0]
9495 #define h g(~
9496 #define m(a) a(w)
9498 #define t(a) a
9499 #define p() int
9500 #define q(x) x
9501 #define r(x,y) x ## y
9502 #define str(x) # x
9505 (f)^m(m);
9508 </pre>
9509 results in
9510 <pre>
9515 </pre>
9518 EXAMPLE 4 To illustrate the rules for creating character string literals and concatenating tokens, the
9519 sequence
9520 <!--page 190 -->
9521 <pre>
9522 #define str(s) # s
9523 #define xstr(s) str(s)
9525 x ## s, x ## t)
9526 #define INCFILE(n) vers ## n
9527 #define glue(a, b) a ## b
9528 #define xglue(a, b) glue(a, b)
9529 #define HIGHLOW "hello"
9530 #define LOW LOW ", world"
9533 == 0) str(: @\n), s);
9534 #include xstr(INCFILE(2).h)
9535 glue(HIGH, LOW);
9536 xglue(HIGH, LOW)
9537 </pre>
9538 results in
9539 <pre>
9541 fputs(
9543 s);
9544 #include "vers2.h" (after macro replacement, before file access)
9545 "hello";
9547 </pre>
9548 or, after concatenation of the character string literals,
9549 <pre>
9550 printf("x1= %d, x2= %s", x1, x2);
9551 fputs(
9553 s);
9554 #include "vers2.h" (after macro replacement, before file access)
9555 "hello";
9556 "hello, world"
9557 </pre>
9558 Space around the # and ## tokens in the macro definition is optional.
9561 EXAMPLE 5 To illustrate the rules for placemarker preprocessing tokens, the sequence
9562 <pre>
9563 #define t(x,y,z) x ## y ## z
9566 </pre>
9567 results in
9568 <pre>
9571 </pre>
9574 EXAMPLE 6 To demonstrate the redefinition rules, the following sequence is valid.
9575 <pre>
9578 #define FUNC_LIKE(a) ( a )
9579 #define FUNC_LIKE( a )( /* note the white space */ \
9580 a /* other stuff on this line
9581 */ )
9582 </pre>
9583 But the following redefinitions are invalid:
9584 <pre>
9585 #define OBJ_LIKE (0) // different token sequence
9587 #define FUNC_LIKE(b) ( a ) // different parameter usage
9588 #define FUNC_LIKE(b) ( b ) // different parameter spelling
9589 </pre>
9592 EXAMPLE 7 Finally, to show the variable argument list macro facilities:
9593 <!--page 191 -->
9594 <pre>
9595 #define debug(...) fprintf(stderr, __VA_ARGS__)
9596 #define showlist(...) puts(#__VA_ARGS__)
9597 #define report(test, ...) ((test)?puts(#test):\
9598 printf(__VA_ARGS__))
9599 debug("Flag");
9600 debug("X = %d\n", x);
9601 showlist(The first, second, and third items.);
9603 </pre>
9604 results in
9605 <pre>
9606 fprintf(stderr, "Flag" );
9607 fprintf(stderr, "X = %d\n", x );
9608 puts( "The first, second, and third items." );
9610 printf("x is %d but y is %d", x, y));
9611 </pre>
9618 The string literal of a #line directive, if present, shall be a character string literal.
9621 The line number of the current source line is one greater than the number of new-line
9622 characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
9623 file to the current token.
9625 A preprocessing directive of the form
9626 <pre>
9627 # line digit-sequence new-line
9628 </pre>
9629 causes the implementation to behave as if the following sequence of source lines begins
9630 with a source line that has a line number as specified by the digit sequence (interpreted as
9631 a decimal integer). The digit sequence shall not specify zero, nor a number greater than
9632 2147483647.
9634 A preprocessing directive of the form
9635 <pre>
9636 # line digit-sequence "s-char-sequence<sub>opt</sub>" new-line
9637 </pre>
9638 sets the presumed line number similarly and changes the presumed name of the source
9639 file to be the contents of the character string literal.
9641 A preprocessing directive of the form
9642 <pre>
9643 # line pp-tokens new-line
9644 </pre>
9645 (that does not match one of the two previous forms) is permitted. The preprocessing
9646 tokens after line on the directive are processed just as in normal text (each identifier
9647 currently defined as a macro name is replaced by its replacement list of preprocessing
9648 tokens). The directive resulting after all replacements shall match one of the two
9649 previous forms and is then processed as appropriate.
9650 <!--page 192 -->
9656 A preprocessing directive of the form
9657 <pre>
9659 </pre>
9660 causes the implementation to produce a diagnostic message that includes the specified
9661 sequence of preprocessing tokens.
9667 A preprocessing directive of the form
9668 <pre>
9670 </pre>
9671 where the preprocessing token STDC does not immediately follow pragma in the
9672 directive (prior to any macro replacement)<sup><a href="#note174"><b>174)</b></a></sup> causes the implementation to behave in an
9673 implementation-defined manner. The behavior might cause translation to fail or cause the
9674 translator or the resulting program to behave in a non-conforming manner. Any such
9675 pragma that is not recognized by the implementation is ignored.
9677 If the preprocessing token STDC does immediately follow pragma in the directive (prior
9678 to any macro replacement), then no macro replacement is performed on the directive, and
9679 the directive shall have one of the following forms<sup><a href="#note175"><b>175)</b></a></sup> whose meanings are described
9680 elsewhere:
9681 <pre>
9682 #pragma STDC FP_CONTRACT on-off-switch
9683 #pragma STDC FENV_ACCESS on-off-switch
9684 #pragma STDC CX_LIMITED_RANGE on-off-switch
9685 on-off-switch: one of
9686 ON OFF DEFAULT
9687 </pre>
9688 <p><b> Forward references</b>: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
9694 <!--page 193 -->
9697 <p><small><a name="note174" href="#note174">174)</a> An implementation is not required to perform macro replacement in pragmas, but it is permitted
9698 except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
9699 replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
9700 implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
9701 but is not required to.
9702 </small>
9703 <p><small><a name="note175" href="#note175">175)</a> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
9704 </small>
9710 A preprocessing directive of the form
9711 <pre>
9712 # new-line
9713 </pre>
9714 has no effect.
9719 The values of the predefined macros listed in the following subclauses<sup><a href="#note176"><b>176)</b></a></sup> (except for
9720 __FILE__ and __LINE__) remain constant throughout the translation unit.
9722 None of these macro names, nor the identifier defined, shall be the subject of a
9723 #define or a #undef preprocessing directive. Any other predefined macro names
9724 shall begin with a leading underscore followed by an uppercase letter or a second
9725 underscore.
9727 The implementation shall not predefine the macro __cplusplus, nor shall it define it
9728 in any standard header.
9732 <p><small><a name="note176" href="#note176">176)</a> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
9733 </small>
9738 The following macro names shall be defined by the implementation:
9739 <dl>
9741 string literal of the form "Mmm dd yyyy", where the names of the
9742 months are the same as those generated by the asctime function, and the
9743 first character of dd is a space character if the value is less than 10. If the
9744 date of translation is not available, an implementation-defined valid date
9745 shall be supplied.
9746 <dt> __FILE__ <dd>The presumed name of the current source file (a character string literal).<sup><a href="#note177"><b>177)</b></a></sup>
9751 implementation or the integer constant 0 if it is not.
9752 <!--page 194 -->
9753 <dt> __STDC_VERSION__ <dd>The integer constant 201ymmL.<sup><a href="#note178"><b>178)</b></a></sup>
9755 string literal of the form "hh:mm:ss" as in the time generated by the
9756 asctime function. If the time of translation is not available, an
9757 implementation-defined valid time shall be supplied.
9758 </dl>
9762 <p><small><a name="note177" href="#note177">177)</a> The presumed source file name and line number can be changed by the #line directive.
9763 </small>
9764 <p><small><a name="note178" href="#note178">178)</a> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
9766 remain an integer constant of type long int that is increased with each revision of this International
9767 Standard.
9768 </small>
9773 The following macro names are conditionally defined by the implementation:
9774 <dl>
9776 199712L). If this symbol is defined, then every character in the Unicode
9777 required set, when stored in an object of type wchar_t, has the same
9778 value as the short identifier of that character. The Unicode required set
9779 consists of all the characters that are defined by ISO/IEC 10646, along with
9780 all amendments and technical corrigenda, as of the specified year and
9781 month. If some other encoding is used, the macro shall not be defined and
9782 the actual encoding used is implementation-defined.
9784 the encoding for wchar_t, a member of the basic character set need not
9785 have a code value equal to its value when used as the lone character in an
9786 integer character constant.
9788 char16_t are UTF-16 encoded. If some other encoding is used, the
9789 macro shall not be defined and the actual encoding used is implementation-
9790 defined.
9792 char32_t are UTF-32 encoded. If some other encoding is used, the
9793 macro shall not be defined and the actual encoding used is implementation-
9794 defined.
9795 </dl>
9796 <p><b> Forward references</b>: common definitions (<a href="#7.19">7.19</a>), unicode utilities (<a href="#7.28">7.28</a>).
9801 <!--page 195 -->
9806 The following macro names are conditionally defined by the implementation:
9807 <dl>
9814 arithmetic).
9816 for the extensions defined in <a href="#K">annex K</a> (Bounds-checking interfaces).<sup><a href="#note179"><b>179)</b></a></sup>
9818 implementation does not support atomic types (including the _Atomic
9822 header.
9826 implementation does not support variable length arrays or variably
9827 modified types.
9828 </dl>
9830 An implementation that defines __STDC_NO_COMPLEX__ shall not define
9831 __STDC_IEC_559_COMPLEX__.
9836 <!--page 196 -->
9839 <p><small><a name="note179" href="#note179">179)</a> The intention is that this will remain an integer constant of type long int that is increased with
9840 each revision of this International Standard.
9841 </small>
9847 A unary operator expression of the form:
9848 <pre>
9849 _Pragma ( string-literal )
9850 </pre>
9851 is processed as follows: The string literal is destringized by deleting any encoding prefix,
9852 deleting the leading and trailing double-quotes, replacing each escape sequence \" by a
9853 double-quote, and replacing each escape sequence \\ by a single backslash. The
9854 resulting sequence of characters is processed through translation phase 3 to produce
9855 preprocessing tokens that are executed as if they were the pp-tokens in a pragma
9856 directive. The original four preprocessing tokens in the unary operator expression are
9857 removed.
9859 EXAMPLE A directive of the form:
9860 <pre>
9862 </pre>
9863 can also be expressed as:
9864 <pre>
9866 </pre>
9867 The latter form is processed in the same way whether it appears literally as shown, or results from macro
9868 replacement, as in:
9869 <!--page 197 -->
9870 <pre>
9871 #define LISTING(x) PRAGMA(listing on #x)
9872 #define PRAGMA(x) _Pragma(#x)
9873 LISTING ( ..\listing.dir )
9874 </pre>
9882 Future standardization may include additional floating-point types, including those with
9883 greater range, precision, or both than long double.
9888 Declaring an identifier with internal linkage at file scope without the static storage-
9889 class specifier is an obsolescent feature.
9894 Restriction of the significance of an external name to fewer than 255 characters
9895 (considering each universal character name or extended source character as a single
9896 character) is an obsolescent feature that is a concession to existing implementations.
9901 Lowercase letters as escape sequences are reserved for future standardization. Other
9902 characters may be used in extensions.
9907 The placement of a storage-class specifier other than at the beginning of the declaration
9908 specifiers in a declaration is an obsolescent feature.
9913 The use of function declarators with empty parentheses (not prototype-format parameter
9914 type declarators) is an obsolescent feature.
9919 The use of function definitions with separate parameter identifier and declaration lists
9920 (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
9925 Pragmas whose first preprocessing token is STDC are reserved for future standardization.
9930 Macro names beginning with __STDC_ are reserved for future standardization.
9931 <!--page 198 -->
9942 A string is a contiguous sequence of characters terminated by and including the first null
9943 character. The term multibyte string is sometimes used instead to emphasize special
9944 processing given to multibyte characters contained in the string or to avoid confusion
9945 with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
9946 character. The length of a string is the number of bytes preceding the null character and
9947 the value of a string is the sequence of the values of the contained characters, in order.
9949 The decimal-point character is the character used by functions that convert floating-point
9950 numbers to or from character sequences to denote the beginning of the fractional part of
9951 such character sequences.<sup><a href="#note180"><b>180)</b></a></sup> It is represented in the text and examples by a period, but
9952 may be changed by the setlocale function.
9954 A null wide character is a wide character with code value zero.
9956 A wide string is a contiguous sequence of wide characters terminated by and including
9957 the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
9958 addressed) wide character. The length of a wide string is the number of wide characters
9959 preceding the null wide character and the value of a wide string is the sequence of code
9960 values of the contained wide characters, in order.
9962 A shift sequence is a contiguous sequence of bytes within a multibyte string that
9963 (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
9964 corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
9966 <p><b> Forward references</b>: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
9971 <!--page 199 -->
9973 <p><b>Footnotes</b>
9974 <p><small><a name="note180" href="#note180">180)</a> The functions that make use of the decimal-point character are the numeric conversion functions
9975 (<a href="#7.22.1">7.22.1</a>, <a href="#7.29.4.1">7.29.4.1</a>) and the formatted input/output functions (<a href="#7.21.6">7.21.6</a>, <a href="#7.29.2">7.29.2</a>).
9976 </small>
9977 <p><small><a name="note181" href="#note181">181)</a> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
9978 enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
9979 sequence of maximum length. Whether these counts provide for more than one shift sequence is the
9980 implementation's choice.
9981 </small>
9986 Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note182"><b>182)</b></a></sup>
9987 whose contents are made available by the #include preprocessing directive. The
9988 header declares a set of related functions, plus any necessary types and additional macros
9989 needed to facilitate their use. Declarations of types described in this clause shall not
9990 include type qualifiers, unless explicitly stated otherwise.
9993 <pre>
9994 <a href="#7.2"><assert.h></a> <a href="#7.12"><math.h></a> <a href="#7.22"><stdlib.h></a>
9995 <a href="#7.3"><complex.h></a> <a href="#7.13"><setjmp.h></a> <a href="#7.23"><stdnoreturn.h></a>
9996 <a href="#7.4"><ctype.h></a> <a href="#7.14"><signal.h></a> <a href="#7.24"><string.h></a>
9997 <a href="#7.5"><errno.h></a> <a href="#7.15"><stdalign.h></a> <a href="#7.25"><tgmath.h></a>
9998 <a href="#7.6"><fenv.h></a> <a href="#7.16"><stdarg.h></a> <a href="#7.26"><threads.h></a>
9999 <a href="#7.7"><float.h></a> <a href="#7.17"><stdatomic.h></a> <a href="#7.27"><time.h></a>
10000 <a href="#7.8"><inttypes.h></a> <a href="#7.18"><stdbool.h></a> <a href="#7.28"><uchar.h></a>
10001 <a href="#7.9"><iso646.h></a> <a href="#7.19"><stddef.h></a> <a href="#7.29"><wchar.h></a>
10002 <a href="#7.10"><limits.h></a> <a href="#7.20"><stdint.h></a> <a href="#7.30"><wctype.h></a>
10004 </pre>
10006 If a file with the same name as one of the above < and > delimited sequences, not
10007 provided as part of the implementation, is placed in any of the standard places that are
10008 searched for included source files, the behavior is undefined.
10010 Standard headers may be included in any order; each may be included more than once in
10011 a given scope, with no effect different from being included only once, except that the
10012 effect of including <a href="#7.2"><assert.h></a> depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
10013 used, a header shall be included outside of any external declaration or definition, and it
10014 shall first be included before the first reference to any of the functions or objects it
10015 declares, or to any of the types or macros it defines. However, if an identifier is declared
10016 or defined in more than one header, the second and subsequent associated headers may be
10017 included after the initial reference to the identifier. The program shall not have any
10018 macros with names lexically identical to keywords currently defined prior to the inclusion
10019 of the header or when any macro defined in the header is expanded.
10021 Any definition of an object-like macro described in this clause shall expand to code that is
10022 fully protected by parentheses where necessary, so that it groups in an arbitrary
10023 expression as if it were a single identifier.
10026 <!--page 200 -->
10028 Any declaration of a library function shall have external linkage.
10033 <p><b>Footnotes</b>
10034 <p><small><a name="note182" href="#note182">182)</a> A header is not necessarily a source file, nor are the < and > delimited sequences in header names
10035 necessarily valid source file names.
10036 </small>
10037 <p><small><a name="note183" href="#note183">183)</a> The headers <a href="#7.3"><complex.h></a>, <a href="#7.17"><stdatomic.h></a>, and <a href="#7.26"><threads.h></a> are conditional features that
10039 </small>
10044 Each header declares or defines all identifiers listed in its associated subclause, and
10045 optionally declares or defines identifiers listed in its associated future library directions
10046 subclause and identifiers which are always reserved either for any use or for use as file
10047 scope identifiers.
10048 <ul>
10049 <li> All identifiers that begin with an underscore and either an uppercase letter or another
10050 underscore are always reserved for any use.
10051 <li> All identifiers that begin with an underscore are always reserved for use as identifiers
10052 with file scope in both the ordinary and tag name spaces.
10053 <li> Each macro name in any of the following subclauses (including the future library
10054 directions) is reserved for use as specified if any of its associated headers is included;
10056 <li> All identifiers with external linkage in any of the following subclauses (including the
10057 future library directions) and errno are always reserved for use as identifiers with
10059 <li> Each identifier with file scope listed in any of the following subclauses (including the
10060 future library directions) is reserved for use as a macro name and as an identifier with
10061 file scope in the same name space if any of its associated headers is included.
10062 </ul>
10064 No other identifiers are reserved. If the program declares or defines an identifier in a
10065 context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
10066 identifier as a macro name, the behavior is undefined.
10068 If the program removes (with #undef) any macro definition of an identifier in the first
10069 group listed above, the behavior is undefined.
10074 <!--page 201 -->
10076 <p><b>Footnotes</b>
10077 <p><small><a name="note184" href="#note184">184)</a> The list of reserved identifiers with external linkage includes math_errhandling, setjmp,
10078 va_copy, and va_end.
10079 </small>
10084 Each of the following statements applies unless explicitly stated otherwise in the detailed
10085 descriptions that follow: If an argument to a function has an invalid value (such as a value
10086 outside the domain of the function, or a pointer outside the address space of the program,
10087 or a null pointer, or a pointer to non-modifiable storage when the corresponding
10088 parameter is not const-qualified) or a type (after promotion) not expected by a function
10089 with variable number of arguments, the behavior is undefined. If a function argument is
10090 described as being an array, the pointer actually passed to the function shall have a value
10091 such that all address computations and accesses to objects (that would be valid if the
10092 pointer did point to the first element of such an array) are in fact valid. Any function
10093 declared in a header may be additionally implemented as a function-like macro defined in
10094 the header, so if a library function is declared explicitly when its header is included, one
10095 of the techniques shown below can be used to ensure the declaration is not affected by
10096 such a macro. Any macro definition of a function can be suppressed locally by enclosing
10097 the name of the function in parentheses, because the name is then not followed by the left
10098 parenthesis that indicates expansion of a macro function name. For the same syntactic
10099 reason, it is permitted to take the address of a library function even if it is also defined as
10100 a macro.<sup><a href="#note185"><b>185)</b></a></sup> The use of #undef to remove any macro definition will also ensure that an
10101 actual function is referred to. Any invocation of a library function that is implemented as
10102 a macro shall expand to code that evaluates each of its arguments exactly once, fully
10103 protected by parentheses where necessary, so it is generally safe to use arbitrary
10104 expressions as arguments.<sup><a href="#note186"><b>186)</b></a></sup> Likewise, those function-like macros described in the
10105 following subclauses may be invoked in an expression anywhere a function with a
10106 compatible return type could be called.<sup><a href="#note187"><b>187)</b></a></sup> All object-like macros listed as expanding to
10109 <!--page 202 -->
10110 integer constant expressions shall additionally be suitable for use in #if preprocessing
10111 directives.
10113 Provided that a library function can be declared without reference to any type defined in a
10114 header, it is also permissible to declare the function and use it without including its
10115 associated header.
10117 There is a sequence point immediately before a library function returns.
10119 The functions in the standard library are not guaranteed to be reentrant and may modify
10122 Unless explicitly stated otherwise in the detailed descriptions that follow, library
10123 functions shall prevent data races as follows: A library function shall not directly or
10124 indirectly access objects accessible by threads other than the current thread unless the
10125 objects are accessed directly or indirectly via the function's arguments. A library
10126 function shall not directly or indirectly modify objects accessible by threads other than
10127 the current thread unless the objects are accessed directly or indirectly via the function's
10128 non-const arguments.<sup><a href="#note189"><b>189)</b></a></sup> Implementations may share their own internal objects between
10129 threads if the objects are not visible to users and are protected against data races.
10131 Unless otherwise specified, library functions shall perform all operations solely within the
10132 current thread if those operations have effects that are visible to users.<sup><a href="#note190"><b>190)</b></a></sup>
10134 EXAMPLE The function atoi may be used in any of several ways:
10135 <ul>
10136 <li> by use of its associated header (possibly generating a macro expansion)
10137 <pre>
10139 const char *str;
10140 /* ... */
10141 i = atoi(str);
10142 </pre>
10143 <li> by use of its associated header (assuredly generating a true function reference)
10148 <!--page 203 -->
10149 <pre>
10151 #undef atoi
10152 const char *str;
10153 /* ... */
10154 i = atoi(str);
10155 </pre>
10156 or
10157 <pre>
10159 const char *str;
10160 /* ... */
10161 i = (atoi)(str);
10162 </pre>
10163 <li> by explicit declaration
10164 <!--page 204 -->
10165 <pre>
10166 extern int atoi(const char *);
10167 const char *str;
10168 /* ... */
10169 i = atoi(str);
10170 </pre>
10171 </ul>
10173 <p><b>Footnotes</b>
10174 <p><small><a name="note185" href="#note185">185)</a> This means that an implementation shall provide an actual function for each library function, even if it
10175 also provides a macro for that function.
10176 </small>
10177 <p><small><a name="note186" href="#note186">186)</a> Such macros might not contain the sequence points that the corresponding function calls do.
10178 </small>
10179 <p><small><a name="note187" href="#note187">187)</a> Because external identifiers and some macro names beginning with an underscore are reserved,
10180 implementations may provide special semantics for such names. For example, the identifier
10181 _BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
10182 appropriate header could specify
10184 <pre>
10185 #define abs(x) _BUILTIN_abs(x)
10186 </pre>
10187 for a compiler whose code generator will accept it.
10188 In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
10189 function may write
10191 <pre>
10192 #undef abs
10193 </pre>
10194 whether the implementation's header provides a macro implementation of abs or a built-in
10195 implementation. The prototype for the function, which precedes and is hidden by any macro
10196 definition, is thereby revealed also.
10197 </small>
10198 <p><small><a name="note188" href="#note188">188)</a> Thus, a signal handler cannot, in general, call standard library functions.
10199 </small>
10200 <p><small><a name="note189" href="#note189">189)</a> This means, for example, that an implementation is not permitted to use a static object for internal
10201 purposes without synchronization because it could cause a data race even in programs that do not
10202 explicitly share objects between threads. Similarly, an implementation of memcpy is not permitted to
10203 copy bytes beyond the specified length of the destination object and then restore the original values
10204 because it could cause a data race if the program shared those bytes between threads.
10205 </small>
10206 <p><small><a name="note190" href="#note190">190)</a> This allows implementations to parallelize operations if there are no visible side effects.
10207 </small>
10212 The header <a href="#7.2"><assert.h></a> defines the assert and static_assert macros and
10213 refers to another macro,
10214 <pre>
10215 NDEBUG
10216 </pre>
10217 which is not defined by <a href="#7.2"><assert.h></a>. If NDEBUG is defined as a macro name at the
10218 point in the source file where <a href="#7.2"><assert.h></a> is included, the assert macro is defined
10219 simply as
10220 <pre>
10221 #define assert(ignore) ((void)0)
10222 </pre>
10223 The assert macro is redefined according to the current state of NDEBUG each time that
10226 The assert macro shall be implemented as a macro, not as an actual function. If the
10227 macro definition is suppressed in order to access an actual function, the behavior is
10228 undefined.
10230 The macro
10231 <pre>
10232 static_assert
10233 </pre>
10234 expands to _Static_assert.
10241 <p><b>Synopsis</b>
10243 <pre>
10245 void assert(scalar expression);
10246 </pre>
10247 <p><b>Description</b>
10249 The assert macro puts diagnostic tests into programs; it expands to a void expression.
10250 When it is executed, if expression (which shall have a scalar type) is false (that is,
10251 compares equal to 0), the assert macro writes information about the particular call that
10252 failed (including the text of the argument, the name of the source file, the source line
10253 number, and the name of the enclosing function -- the latter are respectively the values of
10254 the preprocessing macros __FILE__ and __LINE__ and of the identifier
10255 __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note191"><b>191)</b></a></sup> It
10256 then calls the abort function.
10260 <!--page 205 -->
10261 <p><b>Returns</b>
10263 The assert macro returns no value.
10265 <!--page 206 -->
10267 <p><b>Footnotes</b>
10268 <p><small><a name="note191" href="#note191">191)</a> The message written might be of the form:
10269 <pre>
10270 Assertion failed: expression, function abc, file xyz, line nnn.
10271 </pre>
10272 </small>
10280 The header <a href="#7.3"><complex.h></a> defines macros and declares functions that support complex
10283 Implementations that define the macro __STDC_NO_COMPLEX__ need not provide
10284 this header nor support any of its facilities.
10286 Each synopsis specifies a family of functions consisting of a principal function with one
10287 or more double complex parameters and a double complex or double return
10288 value; and other functions with the same name but with f and l suffixes which are
10289 corresponding functions with float and long double parameters and return values.
10291 The macro
10292 <pre>
10293 complex
10294 </pre>
10295 expands to _Complex; the macro
10296 <pre>
10297 _Complex_I
10298 </pre>
10299 expands to a constant expression of type const float _Complex, with the value of
10302 The macros
10303 <pre>
10304 imaginary
10305 </pre>
10306 and
10307 <pre>
10308 _Imaginary_I
10309 </pre>
10310 are defined if and only if the implementation supports imaginary types;<sup><a href="#note194"><b>194)</b></a></sup> if defined,
10311 they expand to _Imaginary and a constant expression of type const float
10312 _Imaginary with the value of the imaginary unit.
10314 The macro
10315 <pre>
10316 I
10317 </pre>
10318 expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
10319 defined, I shall expand to _Complex_I.
10321 Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
10322 redefine the macros complex, imaginary, and I.
10324 <!--page 207 -->
10325 <p><b> Forward references</b>: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
10327 <p><b>Footnotes</b>
10328 <p><small><a name="note192" href="#note192">192)</a> See ''future library directions'' (<a href="#7.31.1">7.31.1</a>).
10329 </small>
10330 <p><small><a name="note193" href="#note193">193)</a> The imaginary unit is a number i such that i<sup>2</sup> = -1.
10331 </small>
10332 <p><small><a name="note194" href="#note194">194)</a> A specification for imaginary types is in informative <a href="#G">annex G</a>.
10333 </small>
10338 Values are interpreted as radians, not degrees. An implementation may set errno but is
10339 not required to.
10344 Some of the functions below have branch cuts, across which the function is
10345 discontinuous. For implementations with a signed zero (including all IEC 60559
10346 implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
10347 one side of a cut from another so the function is continuous (except for format
10348 limitations) as the cut is approached from either side. For example, for the square root
10349 function, which has a branch cut along the negative real axis, the top of the cut, with
10350 imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
10351 imaginary part -0, maps to the negative imaginary axis.
10353 Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
10354 sides of branch cuts. These implementations shall map a cut so the function is continuous
10355 as the cut is approached coming around the finite endpoint of the cut in a counter
10356 clockwise direction. (Branch cuts for the functions specified here have just one finite
10357 endpoint.) For example, for the square root function, coming counter clockwise around
10358 the finite endpoint of the cut along the negative real axis approaches the cut from above,
10359 so the cut maps to the positive imaginary axis.
10363 <p><b>Synopsis</b>
10365 <pre>
10367 #pragma STDC CX_LIMITED_RANGE on-off-switch
10368 </pre>
10369 <p><b>Description</b>
10371 The usual mathematical formulas for complex multiply, divide, and absolute value are
10372 problematic because of their treatment of infinities and because of undue overflow and
10373 underflow. The CX_LIMITED_RANGE pragma can be used to inform the
10374 implementation that (where the state is ''on'') the usual mathematical formulas are
10375 acceptable.<sup><a href="#note195"><b>195)</b></a></sup> The pragma can occur either outside external declarations or preceding all
10376 explicit declarations and statements inside a compound statement. When outside external
10377 declarations, the pragma takes effect from its occurrence until another
10378 CX_LIMITED_RANGE pragma is encountered, or until the end of the translation unit.
10379 When inside a compound statement, the pragma takes effect from its occurrence until
10380 another CX_LIMITED_RANGE pragma is encountered (including within a nested
10381 compound statement), or until the end of the compound statement; at the end of a
10382 compound statement the state for the pragma is restored to its condition just before the
10383 <!--page 208 -->
10384 compound statement. If this pragma is used in any other context, the behavior is
10385 undefined. The default state for the pragma is ''off''.
10387 <p><b>Footnotes</b>
10388 <p><small><a name="note195" href="#note195">195)</a> The purpose of the pragma is to allow the implementation to use the formulas:
10390 <pre>
10391 (x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
10392 (x + iy) / (u + iv) = [(xu + yv) + i(yu - xv)]/(u<sup>2</sup> + v<sup>2</sup> )
10393 | x + iy | = (sqrt)(x<sup>2</sup> + y<sup>2</sup>)
10394 -----
10395 </pre>
10396 where the programmer can determine they are safe.
10397 </small>
10404 <p><b>Synopsis</b>
10406 <pre>
10408 double complex cacos(double complex z);
10409 float complex cacosf(float complex z);
10410 long double complex cacosl(long double complex z);
10411 </pre>
10412 <p><b>Description</b>
10414 The cacos functions compute the complex arc cosine of z, with branch cuts outside the
10415 interval [-1, +1] along the real axis.
10416 <p><b>Returns</b>
10418 The cacos functions return the complex arc cosine value, in the range of a strip
10419 mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
10420 real axis.
10424 <p><b>Synopsis</b>
10426 <pre>
10428 double complex casin(double complex z);
10429 float complex casinf(float complex z);
10430 long double complex casinl(long double complex z);
10431 </pre>
10432 <p><b>Description</b>
10434 The casin functions compute the complex arc sine of z, with branch cuts outside the
10435 interval [-1, +1] along the real axis.
10436 <p><b>Returns</b>
10438 The casin functions return the complex arc sine value, in the range of a strip
10439 mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
10441 <!--page 209 -->
10442 along the real axis.
10446 <p><b>Synopsis</b>
10448 <pre>
10450 double complex catan(double complex z);
10451 float complex catanf(float complex z);
10452 long double complex catanl(long double complex z);
10453 </pre>
10454 <p><b>Description</b>
10456 The catan functions compute the complex arc tangent of z, with branch cuts outside the
10457 interval [-i, +i] along the imaginary axis.
10458 <p><b>Returns</b>
10460 The catan functions return the complex arc tangent value, in the range of a strip
10461 mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
10462 along the real axis.
10466 <p><b>Synopsis</b>
10468 <pre>
10470 double complex ccos(double complex z);
10471 float complex ccosf(float complex z);
10472 long double complex ccosl(long double complex z);
10473 </pre>
10474 <p><b>Description</b>
10476 The ccos functions compute the complex cosine of z.
10477 <p><b>Returns</b>
10479 The ccos functions return the complex cosine value.
10483 <p><b>Synopsis</b>
10485 <pre>
10487 double complex csin(double complex z);
10488 float complex csinf(float complex z);
10489 long double complex csinl(long double complex z);
10490 </pre>
10491 <p><b>Description</b>
10493 The csin functions compute the complex sine of z.
10494 <!--page 210 -->
10495 <p><b>Returns</b>
10497 The csin functions return the complex sine value.
10501 <p><b>Synopsis</b>
10503 <pre>
10505 double complex ctan(double complex z);
10506 float complex ctanf(float complex z);
10507 long double complex ctanl(long double complex z);
10508 </pre>
10509 <p><b>Description</b>
10511 The ctan functions compute the complex tangent of z.
10512 <p><b>Returns</b>
10514 The ctan functions return the complex tangent value.
10521 <p><b>Synopsis</b>
10523 <pre>
10525 double complex cacosh(double complex z);
10526 float complex cacoshf(float complex z);
10527 long double complex cacoshl(long double complex z);
10528 </pre>
10529 <p><b>Description</b>
10531 The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
10532 cut at values less than 1 along the real axis.
10533 <p><b>Returns</b>
10535 The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
10536 half-strip of nonnegative values along the real axis and in the interval [-ipi , +ipi ] along the
10537 imaginary axis.
10541 <p><b>Synopsis</b>
10543 <!--page 211 -->
10544 <pre>
10546 double complex casinh(double complex z);
10547 float complex casinhf(float complex z);
10548 long double complex casinhl(long double complex z);
10549 </pre>
10550 <p><b>Description</b>
10552 The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
10553 outside the interval [-i, +i] along the imaginary axis.
10554 <p><b>Returns</b>
10556 The casinh functions return the complex arc hyperbolic sine value, in the range of a
10557 strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
10558 along the imaginary axis.
10562 <p><b>Synopsis</b>
10564 <pre>
10566 double complex catanh(double complex z);
10567 float complex catanhf(float complex z);
10568 long double complex catanhl(long double complex z);
10569 </pre>
10570 <p><b>Description</b>
10572 The catanh functions compute the complex arc hyperbolic tangent of z, with branch
10573 cuts outside the interval [-1, +1] along the real axis.
10574 <p><b>Returns</b>
10576 The catanh functions return the complex arc hyperbolic tangent value, in the range of a
10577 strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
10578 along the imaginary axis.
10582 <p><b>Synopsis</b>
10584 <pre>
10586 double complex ccosh(double complex z);
10587 float complex ccoshf(float complex z);
10588 long double complex ccoshl(long double complex z);
10589 </pre>
10590 <p><b>Description</b>
10592 The ccosh functions compute the complex hyperbolic cosine of z.
10593 <p><b>Returns</b>
10595 The ccosh functions return the complex hyperbolic cosine value.
10596 <!--page 212 -->
10600 <p><b>Synopsis</b>
10602 <pre>
10604 double complex csinh(double complex z);
10605 float complex csinhf(float complex z);
10606 long double complex csinhl(long double complex z);
10607 </pre>
10608 <p><b>Description</b>
10610 The csinh functions compute the complex hyperbolic sine of z.
10611 <p><b>Returns</b>
10613 The csinh functions return the complex hyperbolic sine value.
10617 <p><b>Synopsis</b>
10619 <pre>
10621 double complex ctanh(double complex z);
10622 float complex ctanhf(float complex z);
10623 long double complex ctanhl(long double complex z);
10624 </pre>
10625 <p><b>Description</b>
10627 The ctanh functions compute the complex hyperbolic tangent of z.
10628 <p><b>Returns</b>
10630 The ctanh functions return the complex hyperbolic tangent value.
10637 <p><b>Synopsis</b>
10639 <pre>
10641 double complex cexp(double complex z);
10642 float complex cexpf(float complex z);
10643 long double complex cexpl(long double complex z);
10644 </pre>
10645 <p><b>Description</b>
10647 The cexp functions compute the complex base-e exponential of z.
10648 <p><b>Returns</b>
10650 The cexp functions return the complex base-e exponential value.
10651 <!--page 213 -->
10655 <p><b>Synopsis</b>
10657 <pre>
10659 double complex clog(double complex z);
10660 float complex clogf(float complex z);
10661 long double complex clogl(long double complex z);
10662 </pre>
10663 <p><b>Description</b>
10665 The clog functions compute the complex natural (base-e) logarithm of z, with a branch
10666 cut along the negative real axis.
10667 <p><b>Returns</b>
10669 The clog functions return the complex natural logarithm value, in the range of a strip
10670 mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
10671 imaginary axis.
10678 <p><b>Synopsis</b>
10680 <pre>
10682 double cabs(double complex z);
10683 float cabsf(float complex z);
10684 long double cabsl(long double complex z);
10685 </pre>
10686 <p><b>Description</b>
10688 The cabs functions compute the complex absolute value (also called norm, modulus, or
10689 magnitude) of z.
10690 <p><b>Returns</b>
10692 The cabs functions return the complex absolute value.
10696 <p><b>Synopsis</b>
10698 <!--page 214 -->
10699 <pre>
10701 double complex cpow(double complex x, double complex y);
10702 float complex cpowf(float complex x, float complex y);
10703 long double complex cpowl(long double complex x,
10704 long double complex y);
10705 </pre>
10706 <p><b>Description</b>
10708 The cpow functions compute the complex power function x<sup>y</sup> , with a branch cut for the
10709 first parameter along the negative real axis.
10710 <p><b>Returns</b>
10712 The cpow functions return the complex power function value.
10716 <p><b>Synopsis</b>
10718 <pre>
10720 double complex csqrt(double complex z);
10721 float complex csqrtf(float complex z);
10722 long double complex csqrtl(long double complex z);
10723 </pre>
10724 <p><b>Description</b>
10726 The csqrt functions compute the complex square root of z, with a branch cut along the
10727 negative real axis.
10728 <p><b>Returns</b>
10730 The csqrt functions return the complex square root value, in the range of the right half-
10731 plane (including the imaginary axis).
10738 <p><b>Synopsis</b>
10740 <pre>
10742 double carg(double complex z);
10743 float cargf(float complex z);
10744 long double cargl(long double complex z);
10745 </pre>
10746 <p><b>Description</b>
10748 The carg functions compute the argument (also called phase angle) of z, with a branch
10749 cut along the negative real axis.
10750 <p><b>Returns</b>
10752 The carg functions return the value of the argument in the interval [-pi , +pi ].
10753 <!--page 215 -->
10757 <p><b>Synopsis</b>
10759 <pre>
10761 double cimag(double complex z);
10762 float cimagf(float complex z);
10763 long double cimagl(long double complex z);
10764 </pre>
10765 <p><b>Description</b>
10767 The cimag functions compute the imaginary part of z.<sup><a href="#note196"><b>196)</b></a></sup>
10768 <p><b>Returns</b>
10770 The cimag functions return the imaginary part value (as a real).
10772 <p><b>Footnotes</b>
10773 <p><small><a name="note196" href="#note196">196)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
10774 </small>
10778 <p><b>Synopsis</b>
10780 <pre>
10782 double complex CMPLX(double x, double y);
10783 float complex CMPLXF(float x, float y);
10784 long double complex CMPLXL(long double x, long double y);
10785 </pre>
10786 <p><b>Description</b>
10788 The CMPLX macros expand to an expression of the specified complex type, with the real
10789 part having the (converted) value of x and the imaginary part having the (converted)
10790 value of y. The resulting expression shall be suitable for use as an initializer for an object
10791 with static or thread storage duration, provided both arguments are likewise suitable.
10792 <p><b>Returns</b>
10794 The CMPLX macros return the complex value x + i y.
10796 NOTE These macros act as if the implementation supported imaginary types and the definitions were:
10797 <pre>
10798 #define CMPLX(x, y) ((double complex)((double)(x) + \
10799 _Imaginary_I * (double)(y)))
10800 #define CMPLXF(x, y) ((float complex)((float)(x) + \
10801 _Imaginary_I * (float)(y)))
10802 #define CMPLXL(x, y) ((long double complex)((long double)(x) + \
10803 _Imaginary_I * (long double)(y)))
10804 </pre>
10809 <!--page 216 -->
10813 <p><b>Synopsis</b>
10815 <pre>
10817 double complex conj(double complex z);
10818 float complex conjf(float complex z);
10819 long double complex conjl(long double complex z);
10820 </pre>
10821 <p><b>Description</b>
10823 The conj functions compute the complex conjugate of z, by reversing the sign of its
10824 imaginary part.
10825 <p><b>Returns</b>
10827 The conj functions return the complex conjugate value.
10831 <p><b>Synopsis</b>
10833 <pre>
10835 double complex cproj(double complex z);
10836 float complex cprojf(float complex z);
10837 long double complex cprojl(long double complex z);
10838 </pre>
10839 <p><b>Description</b>
10841 The cproj functions compute a projection of z onto the Riemann sphere: z projects to
10842 z except that all complex infinities (even those with one infinite part and one NaN part)
10843 project to positive infinity on the real axis. If z has an infinite part, then cproj(z) is
10844 equivalent to
10845 <pre>
10846 INFINITY + I * copysign(0.0, cimag(z))
10847 </pre>
10848 <p><b>Returns</b>
10850 The cproj functions return the value of the projection onto the Riemann sphere.
10854 <p><b>Synopsis</b>
10856 <pre>
10858 double creal(double complex z);
10859 float crealf(float complex z);
10860 long double creall(long double complex z);
10861 </pre>
10862 <p><b>Description</b>
10865 <!--page 217 -->
10866 <p><b>Returns</b>
10868 The creal functions return the real part value.
10873 <!--page 218 -->
10875 <p><b>Footnotes</b>
10876 <p><small><a name="note197" href="#note197">197)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
10877 </small>
10882 The header <a href="#7.4"><ctype.h></a> declares several functions useful for classifying and mapping
10883 characters.<sup><a href="#note198"><b>198)</b></a></sup> In all cases the argument is an int, the value of which shall be
10884 representable as an unsigned char or shall equal the value of the macro EOF. If the
10885 argument has any other value, the behavior is undefined.
10887 The behavior of these functions is affected by the current locale. Those functions that
10890 The term printing character refers to a member of a locale-specific set of characters, each
10891 of which occupies one printing position on a display device; the term control character
10892 refers to a member of a locale-specific set of characters that are not printing
10893 characters.<sup><a href="#note199"><b>199)</b></a></sup> All letters and digits are printing characters.
10894 <p><b> Forward references</b>: EOF (<a href="#7.21.1">7.21.1</a>), localization (<a href="#7.11">7.11</a>).
10896 <p><b>Footnotes</b>
10897 <p><small><a name="note198" href="#note198">198)</a> See ''future library directions'' (<a href="#7.31.2">7.31.2</a>).
10898 </small>
10899 <p><small><a name="note199" href="#note199">199)</a> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
10900 whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
10901 values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
10902 </small>
10907 The functions in this subclause return nonzero (true) if and only if the value of the
10908 argument c conforms to that in the description of the function.
10912 <p><b>Synopsis</b>
10914 <pre>
10916 int isalnum(int c);
10917 </pre>
10918 <p><b>Description</b>
10920 The isalnum function tests for any character for which isalpha or isdigit is true.
10924 <p><b>Synopsis</b>
10926 <pre>
10928 int isalpha(int c);
10929 </pre>
10930 <p><b>Description</b>
10932 The isalpha function tests for any character for which isupper or islower is true,
10933 or any character that is one of a locale-specific set of alphabetic characters for which
10937 <!--page 219 -->
10938 none of iscntrl, isdigit, ispunct, or isspace is true.<sup><a href="#note200"><b>200)</b></a></sup> In the "C" locale,
10939 isalpha returns true only for the characters for which isupper or islower is true.
10941 <p><b>Footnotes</b>
10942 <p><small><a name="note200" href="#note200">200)</a> The functions islower and isupper test true or false separately for each of these additional
10943 characters; all four combinations are possible.
10944 </small>
10948 <p><b>Synopsis</b>
10950 <pre>
10952 int isblank(int c);
10953 </pre>
10954 <p><b>Description</b>
10956 The isblank function tests for any character that is a standard blank character or is one
10957 of a locale-specific set of characters for which isspace is true and that is used to
10958 separate words within a line of text. The standard blank characters are the following:
10960 for the standard blank characters.
10964 <p><b>Synopsis</b>
10966 <pre>
10968 int iscntrl(int c);
10969 </pre>
10970 <p><b>Description</b>
10972 The iscntrl function tests for any control character.
10976 <p><b>Synopsis</b>
10978 <pre>
10980 int isdigit(int c);
10981 </pre>
10982 <p><b>Description</b>
10984 The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
10988 <p><b>Synopsis</b>
10990 <pre>
10992 int isgraph(int c);
10993 </pre>
10998 <!--page 220 -->
10999 <p><b>Description</b>
11001 The isgraph function tests for any printing character except space (' ').
11005 <p><b>Synopsis</b>
11007 <pre>
11009 int islower(int c);
11010 </pre>
11011 <p><b>Description</b>
11013 The islower function tests for any character that is a lowercase letter or is one of a
11014 locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
11020 <p><b>Synopsis</b>
11022 <pre>
11024 int isprint(int c);
11025 </pre>
11026 <p><b>Description</b>
11028 The isprint function tests for any printing character including space (' ').
11032 <p><b>Synopsis</b>
11034 <pre>
11036 int ispunct(int c);
11037 </pre>
11038 <p><b>Description</b>
11040 The ispunct function tests for any printing character that is one of a locale-specific set
11042 locale, ispunct returns true for every printing character for which neither isspace
11043 nor isalnum is true.
11047 <p><b>Synopsis</b>
11049 <pre>
11051 int isspace(int c);
11052 </pre>
11053 <p><b>Description</b>
11055 The isspace function tests for any character that is a standard white-space character or
11056 is one of a locale-specific set of characters for which isalnum is false. The standard
11057 <!--page 221 -->
11058 white-space characters are the following: space (' '), form feed ('\f'), new-line
11059 ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). In the
11064 <p><b>Synopsis</b>
11066 <pre>
11068 int isupper(int c);
11069 </pre>
11070 <p><b>Description</b>
11072 The isupper function tests for any character that is an uppercase letter or is one of a
11073 locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
11079 <p><b>Synopsis</b>
11081 <pre>
11083 int isxdigit(int c);
11084 </pre>
11085 <p><b>Description</b>
11087 The isxdigit function tests for any hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
11094 <p><b>Synopsis</b>
11096 <pre>
11098 int tolower(int c);
11099 </pre>
11100 <p><b>Description</b>
11102 The tolower function converts an uppercase letter to a corresponding lowercase letter.
11103 <p><b>Returns</b>
11105 If the argument is a character for which isupper is true and there are one or more
11106 corresponding characters, as specified by the current locale, for which islower is true,
11107 the tolower function returns one of the corresponding characters (always the same one
11108 for any given locale); otherwise, the argument is returned unchanged.
11109 <!--page 222 -->
11113 <p><b>Synopsis</b>
11115 <pre>
11117 int toupper(int c);
11118 </pre>
11119 <p><b>Description</b>
11121 The toupper function converts a lowercase letter to a corresponding uppercase letter.
11122 <p><b>Returns</b>
11124 If the argument is a character for which islower is true and there are one or more
11125 corresponding characters, as specified by the current locale, for which isupper is true,
11126 the toupper function returns one of the corresponding characters (always the same one
11127 for any given locale); otherwise, the argument is returned unchanged.
11128 <!--page 223 -->
11133 The header <a href="#7.5"><errno.h></a> defines several macros, all relating to the reporting of error
11134 conditions.
11136 The macros are
11137 <pre>
11138 EDOM
11139 EILSEQ
11140 ERANGE
11141 </pre>
11142 which expand to integer constant expressions with type int, distinct positive values, and
11143 which are suitable for use in #if preprocessing directives; and
11144 <pre>
11145 errno
11146 </pre>
11147 which expands to a modifiable lvalue<sup><a href="#note201"><b>201)</b></a></sup> that has type int and thread local storage
11148 duration, the value of which is set to a positive error number by several library functions.
11149 If a macro definition is suppressed in order to access an actual object, or a program
11150 defines an identifier with the name errno, the behavior is undefined.
11152 The value of errno in the initial thread is zero at program startup (the initial value of
11153 errno in other threads is an indeterminate value), but is never set to zero by any library
11154 function.<sup><a href="#note202"><b>202)</b></a></sup> The value of errno may be set to nonzero by a library function call
11155 whether or not there is an error, provided the use of errno is not documented in the
11156 description of the function in this International Standard.
11158 Additional macro definitions, beginning with E and a digit or E and an uppercase
11159 letter,<sup><a href="#note203"><b>203)</b></a></sup> may also be specified by the implementation.
11164 <!--page 224 -->
11166 <p><b>Footnotes</b>
11167 <p><small><a name="note201" href="#note201">201)</a> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
11168 resulting from a function call (for example, *errno()).
11169 </small>
11170 <p><small><a name="note202" href="#note202">202)</a> Thus, a program that uses errno for error checking should set it to zero before a library function call,
11171 then inspect it before a subsequent library function call. Of course, a library function can save the
11172 value of errno on entry and then set it to zero, as long as the original value is restored if errno's
11173 value is still zero just before the return.
11174 </small>
11175 <p><small><a name="note203" href="#note203">203)</a> See ''future library directions'' (<a href="#7.31.3">7.31.3</a>).
11176 </small>
11181 The header <a href="#7.6"><fenv.h></a> defines several macros, and declares types and functions that
11182 provide access to the floating-point environment. The floating-point environment refers
11183 collectively to any floating-point status flags and control modes supported by the
11184 implementation.<sup><a href="#note204"><b>204)</b></a></sup> A floating-point status flag is a system variable whose value is set
11185 (but never cleared) when a floating-point exception is raised, which occurs as a side effect
11186 of exceptional floating-point arithmetic to provide auxiliary information.<sup><a href="#note205"><b>205)</b></a></sup> A floating-
11187 point control mode is a system variable whose value may be set by the user to affect the
11188 subsequent behavior of floating-point arithmetic.
11190 The floating-point environment has thread storage duration. The initial state for a
11191 thread's floating-point environment is the current state of the floating-point environment
11192 of the thread that creates it at the time of creation.
11194 Certain programming conventions support the intended model of use for the floating-
11196 <ul>
11197 <li> a function call does not alter its caller's floating-point control modes, clear its caller's
11198 floating-point status flags, nor depend on the state of its caller's floating-point status
11199 flags unless the function is so documented;
11200 <li> a function call is assumed to require default floating-point control modes, unless its
11201 documentation promises otherwise;
11202 <li> a function call is assumed to have the potential for raising floating-point exceptions,
11203 unless its documentation promises otherwise.
11204 </ul>
11206 The type
11207 <pre>
11208 fenv_t
11209 </pre>
11210 represents the entire floating-point environment.
11212 The type
11213 <pre>
11214 fexcept_t
11215 </pre>
11216 represents the floating-point status flags collectively, including any status the
11217 implementation associates with the flags.
11220 <!--page 225 -->
11222 Each of the macros
11223 <pre>
11224 FE_DIVBYZERO
11225 FE_INEXACT
11226 FE_INVALID
11227 FE_OVERFLOW
11228 FE_UNDERFLOW
11229 </pre>
11230 is defined if and only if the implementation supports the floating-point exception by
11231 means of the functions in 7.6.2.<sup><a href="#note207"><b>207)</b></a></sup> Additional implementation-defined floating-point
11232 exceptions, with macro definitions beginning with FE_ and an uppercase letter,<sup><a href="#note208"><b>208)</b></a></sup> may
11233 also be specified by the implementation. The defined macros expand to integer constant
11234 expressions with values such that bitwise ORs of all combinations of the macros result in
11235 distinct values, and furthermore, bitwise ANDs of all combinations of the macros result in
11238 The macro
11239 <pre>
11240 FE_ALL_EXCEPT
11241 </pre>
11242 is simply the bitwise OR of all floating-point exception macros defined by the
11243 implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
11245 Each of the macros
11246 <pre>
11247 FE_DOWNWARD
11248 FE_TONEAREST
11249 FE_TOWARDZERO
11250 FE_UPWARD
11251 </pre>
11252 is defined if and only if the implementation supports getting and setting the represented
11253 rounding direction by means of the fegetround and fesetround functions.
11254 Additional implementation-defined rounding directions, with macro definitions beginning
11255 with FE_ and an uppercase letter,<sup><a href="#note210"><b>210)</b></a></sup> may also be specified by the implementation. The
11256 defined macros expand to integer constant expressions whose values are distinct
11260 <!--page 226 -->
11262 The macro
11263 <pre>
11264 FE_DFL_ENV
11265 </pre>
11266 represents the default floating-point environment -- the one installed at program startup
11267 -- and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
11270 Additional implementation-defined environments, with macro definitions beginning with
11271 FE_ and an uppercase letter,<sup><a href="#note212"><b>212)</b></a></sup> and having type ''pointer to const-qualified fenv_t'',
11272 may also be specified by the implementation.
11274 <p><b>Footnotes</b>
11275 <p><small><a name="note204" href="#note204">204)</a> This header is designed to support the floating-point exception status flags and directed-rounding
11276 control modes required by IEC 60559, and other similar floating-point state information. It is also
11277 designed to facilitate code portability among all systems.
11278 </small>
11279 <p><small><a name="note205" href="#note205">205)</a> A floating-point status flag is not an object and can be set more than once within an expression.
11280 </small>
11281 <p><small><a name="note206" href="#note206">206)</a> With these conventions, a programmer can safely assume default floating-point control modes (or be
11282 unaware of them). The responsibilities associated with accessing the floating-point environment fall
11283 on the programmer or program that does so explicitly.
11284 </small>
11285 <p><small><a name="note207" href="#note207">207)</a> The implementation supports a floating-point exception if there are circumstances where a call to at
11286 least one of the functions in <a href="#7.6.2">7.6.2</a>, using the macro as the appropriate argument, will succeed. It is not
11287 necessary for all the functions to succeed all the time.
11288 </small>
11289 <p><small><a name="note208" href="#note208">208)</a> See ''future library directions'' (<a href="#7.31.4">7.31.4</a>).
11290 </small>
11291 <p><small><a name="note209" href="#note209">209)</a> The macros should be distinct powers of two.
11292 </small>
11293 <p><small><a name="note210" href="#note210">210)</a> See ''future library directions'' (<a href="#7.31.4">7.31.4</a>).
11294 </small>
11295 <p><small><a name="note211" href="#note211">211)</a> Even though the rounding direction macros may expand to constants corresponding to the values of
11296 FLT_ROUNDS, they are not required to do so.
11297 </small>
11298 <p><small><a name="note212" href="#note212">212)</a> See ''future library directions'' (<a href="#7.31.4">7.31.4</a>).
11299 </small>
11303 <p><b>Synopsis</b>
11305 <pre>
11307 #pragma STDC FENV_ACCESS on-off-switch
11308 </pre>
11309 <p><b>Description</b>
11311 The FENV_ACCESS pragma provides a means to inform the implementation when a
11312 program might access the floating-point environment to test floating-point status flags or
11313 run under non-default floating-point control modes.<sup><a href="#note213"><b>213)</b></a></sup> The pragma shall occur either
11314 outside external declarations or preceding all explicit declarations and statements inside a
11315 compound statement. When outside external declarations, the pragma takes effect from
11316 its occurrence until another FENV_ACCESS pragma is encountered, or until the end of
11317 the translation unit. When inside a compound statement, the pragma takes effect from its
11318 occurrence until another FENV_ACCESS pragma is encountered (including within a
11319 nested compound statement), or until the end of the compound statement; at the end of a
11320 compound statement the state for the pragma is restored to its condition just before the
11321 compound statement. If this pragma is used in any other context, the behavior is
11322 undefined. If part of a program tests floating-point status flags, sets floating-point control
11323 modes, or runs under non-default mode settings, but was translated with the state for the
11324 FENV_ACCESS pragma ''off'', the behavior is undefined. The default state (''on'' or
11325 ''off'') for the pragma is implementation-defined. (When execution passes from a part of
11326 the program translated with FENV_ACCESS ''off'' to a part translated with
11327 FENV_ACCESS ''on'', the state of the floating-point status flags is unspecified and the
11328 floating-point control modes have their default settings.)
11332 <!--page 227 -->
11334 EXAMPLE
11335 <pre>
11337 void f(double x)
11338 {
11339 #pragma STDC FENV_ACCESS ON
11340 void g(double);
11341 void h(double);
11342 /* ... */
11343 g(x + 1);
11344 h(x + 1);
11345 /* ... */
11346 }
11347 </pre>
11349 If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
11350 x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
11351 contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note214"><b>214)</b></a></sup>
11354 <p><b>Footnotes</b>
11355 <p><small><a name="note213" href="#note213">213)</a> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
11356 tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
11357 folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
11358 modes are in effect and the flags are not tested.
11359 </small>
11360 <p><small><a name="note214" href="#note214">214)</a> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
11361 hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
11362 ''off'', just one evaluation of x + 1 would suffice.
11363 </small>
11368 The following functions provide access to the floating-point status flags.<sup><a href="#note215"><b>215)</b></a></sup> The int
11369 input argument for the functions represents a subset of floating-point exceptions, and can
11370 be zero or the bitwise OR of one or more floating-point exception macros, for example
11371 FE_OVERFLOW | FE_INEXACT. For other argument values the behavior of these
11372 functions is undefined.
11374 <p><b>Footnotes</b>
11375 <p><small><a name="note215" href="#note215">215)</a> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
11376 abstraction of flags that are either set or clear. An implementation may endow floating-point status
11377 flags with more information -- for example, the address of the code which first raised the floating-
11378 point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
11379 content of flags.
11380 </small>
11384 <p><b>Synopsis</b>
11386 <pre>
11388 int feclearexcept(int excepts);
11389 </pre>
11390 <p><b>Description</b>
11392 The feclearexcept function attempts to clear the supported floating-point exceptions
11393 represented by its argument.
11394 <p><b>Returns</b>
11396 The feclearexcept function returns zero if the excepts argument is zero or if all
11397 the specified exceptions were successfully cleared. Otherwise, it returns a nonzero value.
11400 <!--page 228 -->
11404 <p><b>Synopsis</b>
11406 <pre>
11408 int fegetexceptflag(fexcept_t *flagp,
11409 int excepts);
11410 </pre>
11411 <p><b>Description</b>
11413 The fegetexceptflag function attempts to store an implementation-defined
11414 representation of the states of the floating-point status flags indicated by the argument
11415 excepts in the object pointed to by the argument flagp.
11416 <p><b>Returns</b>
11418 The fegetexceptflag function returns zero if the representation was successfully
11419 stored. Otherwise, it returns a nonzero value.
11423 <p><b>Synopsis</b>
11425 <pre>
11427 int feraiseexcept(int excepts);
11428 </pre>
11429 <p><b>Description</b>
11431 The feraiseexcept function attempts to raise the supported floating-point exceptions
11432 represented by its argument.<sup><a href="#note216"><b>216)</b></a></sup> The order in which these floating-point exceptions are
11433 raised is unspecified, except as stated in <a href="#F.8.6">F.8.6</a>. Whether the feraiseexcept function
11434 additionally raises the ''inexact'' floating-point exception whenever it raises the
11435 ''overflow'' or ''underflow'' floating-point exception is implementation-defined.
11436 <p><b>Returns</b>
11438 The feraiseexcept function returns zero if the excepts argument is zero or if all
11439 the specified exceptions were successfully raised. Otherwise, it returns a nonzero value.
11444 <!--page 229 -->
11446 <p><b>Footnotes</b>
11447 <p><small><a name="note216" href="#note216">216)</a> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
11448 Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
11450 </small>
11454 <p><b>Synopsis</b>
11456 <pre>
11458 int fesetexceptflag(const fexcept_t *flagp,
11459 int excepts);
11460 </pre>
11461 <p><b>Description</b>
11463 The fesetexceptflag function attempts to set the floating-point status flags
11464 indicated by the argument excepts to the states stored in the object pointed to by
11465 flagp. The value of *flagp shall have been set by a previous call to
11466 fegetexceptflag whose second argument represented at least those floating-point
11467 exceptions represented by the argument excepts. This function does not raise floating-
11468 point exceptions, but only sets the state of the flags.
11469 <p><b>Returns</b>
11471 The fesetexceptflag function returns zero if the excepts argument is zero or if
11472 all the specified flags were successfully set to the appropriate state. Otherwise, it returns
11473 a nonzero value.
11477 <p><b>Synopsis</b>
11479 <pre>
11481 int fetestexcept(int excepts);
11482 </pre>
11483 <p><b>Description</b>
11485 The fetestexcept function determines which of a specified subset of the floating-
11486 point exception flags are currently set. The excepts argument specifies the floating-
11488 <p><b>Returns</b>
11490 The fetestexcept function returns the value of the bitwise OR of the floating-point
11491 exception macros corresponding to the currently set floating-point exceptions included in
11492 excepts.
11494 EXAMPLE Call f if ''invalid'' is set, then g if ''overflow'' is set:
11499 <!--page 230 -->
11500 <pre>
11502 /* ... */
11503 {
11504 #pragma STDC FENV_ACCESS ON
11505 int set_excepts;
11506 feclearexcept(FE_INVALID | FE_OVERFLOW);
11507 // maybe raise exceptions
11508 set_excepts = fetestexcept(FE_INVALID | FE_OVERFLOW);
11509 if (set_excepts & FE_INVALID) f();
11510 if (set_excepts & FE_OVERFLOW) g();
11511 /* ... */
11512 }
11513 </pre>
11516 <p><b>Footnotes</b>
11517 <p><small><a name="note217" href="#note217">217)</a> This mechanism allows testing several floating-point exceptions with just one function call.
11518 </small>
11523 The fegetround and fesetround functions provide control of rounding direction
11524 modes.
11528 <p><b>Synopsis</b>
11530 <pre>
11532 int fegetround(void);
11533 </pre>
11534 <p><b>Description</b>
11536 The fegetround function gets the current rounding direction.
11537 <p><b>Returns</b>
11539 The fegetround function returns the value of the rounding direction macro
11540 representing the current rounding direction or a negative value if there is no such
11541 rounding direction macro or the current rounding direction is not determinable.
11545 <p><b>Synopsis</b>
11547 <pre>
11549 int fesetround(int round);
11550 </pre>
11551 <p><b>Description</b>
11553 The fesetround function establishes the rounding direction represented by its
11554 argument round. If the argument is not equal to the value of a rounding direction macro,
11555 the rounding direction is not changed.
11556 <p><b>Returns</b>
11558 The fesetround function returns zero if and only if the requested rounding direction
11559 was established.
11560 <!--page 231 -->
11562 EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
11563 rounding direction fails.
11564 <pre>
11567 void f(int round_dir)
11568 {
11569 #pragma STDC FENV_ACCESS ON
11570 int save_round;
11571 int setround_ok;
11572 save_round = fegetround();
11573 setround_ok = fesetround(round_dir);
11574 assert(setround_ok == 0);
11575 /* ... */
11576 fesetround(save_round);
11577 /* ... */
11578 }
11579 </pre>
11585 The functions in this section manage the floating-point environment -- status flags and
11586 control modes -- as one entity.
11590 <p><b>Synopsis</b>
11592 <pre>
11594 int fegetenv(fenv_t *envp);
11595 </pre>
11596 <p><b>Description</b>
11598 The fegetenv function attempts to store the current floating-point environment in the
11599 object pointed to by envp.
11600 <p><b>Returns</b>
11602 The fegetenv function returns zero if the environment was successfully stored.
11603 Otherwise, it returns a nonzero value.
11607 <p><b>Synopsis</b>
11609 <pre>
11611 int feholdexcept(fenv_t *envp);
11612 </pre>
11613 <p><b>Description</b>
11615 The feholdexcept function saves the current floating-point environment in the object
11616 pointed to by envp, clears the floating-point status flags, and then installs a non-stop
11617 (continue on floating-point exceptions) mode, if available, for all floating-point
11619 <!--page 232 -->
11620 <p><b>Returns</b>
11622 The feholdexcept function returns zero if and only if non-stop floating-point
11623 exception handling was successfully installed.
11625 <p><b>Footnotes</b>
11626 <p><small><a name="note218" href="#note218">218)</a> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
11627 handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
11628 such systems, the feholdexcept function can be used in conjunction with the feupdateenv
11629 function to write routines that hide spurious floating-point exceptions from their callers.
11630 </small>
11634 <p><b>Synopsis</b>
11636 <pre>
11638 int fesetenv(const fenv_t *envp);
11639 </pre>
11640 <p><b>Description</b>
11642 The fesetenv function attempts to establish the floating-point environment represented
11643 by the object pointed to by envp. The argument envp shall point to an object set by a
11644 call to fegetenv or feholdexcept, or equal a floating-point environment macro.
11645 Note that fesetenv merely installs the state of the floating-point status flags
11646 represented through its argument, and does not raise these floating-point exceptions.
11647 <p><b>Returns</b>
11649 The fesetenv function returns zero if the environment was successfully established.
11650 Otherwise, it returns a nonzero value.
11654 <p><b>Synopsis</b>
11656 <pre>
11658 int feupdateenv(const fenv_t *envp);
11659 </pre>
11660 <p><b>Description</b>
11662 The feupdateenv function attempts to save the currently raised floating-point
11663 exceptions in its automatic storage, install the floating-point environment represented by
11664 the object pointed to by envp, and then raise the saved floating-point exceptions. The
11665 argument envp shall point to an object set by a call to feholdexcept or fegetenv,
11666 or equal a floating-point environment macro.
11667 <p><b>Returns</b>
11669 The feupdateenv function returns zero if all the actions were successfully carried out.
11670 Otherwise, it returns a nonzero value.
11675 <!--page 233 -->
11677 EXAMPLE Hide spurious underflow floating-point exceptions:
11678 <!--page 234 -->
11679 <pre>
11681 double f(double x)
11682 {
11683 #pragma STDC FENV_ACCESS ON
11684 double result;
11685 fenv_t save_env;
11686 if (feholdexcept(&save_env))
11687 return /* indication of an environmental problem */;
11688 // compute result
11689 if (/* test spurious underflow */)
11690 if (feclearexcept(FE_UNDERFLOW))
11691 return /* indication of an environmental problem */;
11692 if (feupdateenv(&save_env))
11693 return /* indication of an environmental problem */;
11694 return result;
11695 }
11696 </pre>
11701 The header <a href="#7.7"><float.h></a> defines several macros that expand to various limits and
11702 parameters of the standard floating-point types.
11704 The macros, their meanings, and the constraints (or restrictions) on their values are listed
11706 <!--page 235 -->
11709 <h3><a name="7.8" href="#7.8">7.8 Format conversion of integer types <inttypes.h></a></h3>
11711 The header <a href="#7.8"><inttypes.h></a> includes the header <a href="#7.20"><stdint.h></a> and extends it with
11712 additional facilities provided by hosted implementations.
11714 It declares functions for manipulating greatest-width integers and converting numeric
11715 character strings to greatest-width integers, and it declares the type
11716 <pre>
11717 imaxdiv_t
11718 </pre>
11719 which is a structure type that is the type of the value returned by the imaxdiv function.
11720 For each type declared in <a href="#7.20"><stdint.h></a>, it defines corresponding macros for conversion
11721 specifiers for use with the formatted input/output functions.<sup><a href="#note219"><b>219)</b></a></sup>
11722 <p><b> Forward references</b>: integer types <a href="#7.20"><stdint.h></a> (<a href="#7.20">7.20</a>), formatted input/output
11723 functions (<a href="#7.21.6">7.21.6</a>), formatted wide character input/output functions (<a href="#7.29.2">7.29.2</a>).
11725 <p><b>Footnotes</b>
11726 <p><small><a name="note219" href="#note219">219)</a> See ''future library directions'' (<a href="#7.31.5">7.31.5</a>).
11727 </small>
11732 Each of the following object-like macros expands to a character string literal containing a
11733 conversion specifier, possibly modified by a length modifier, suitable for use within the
11734 format argument of a formatted input/output function when converting the corresponding
11735 integer type. These macro names have the general form of PRI (character string literals
11736 for the fprintf and fwprintf family) or SCN (character string literals for the
11737 fscanf and fwscanf family),<sup><a href="#note220"><b>220)</b></a></sup> followed by the conversion specifier, followed by a
11738 name corresponding to a similar type name in <a href="#7.20.1">7.20.1</a>. In these names, N represents the
11739 width of the type as described in <a href="#7.20.1">7.20.1</a>. For example, PRIdFAST32 can be used in a
11740 format string to print the value of an integer of type int_fast32_t.
11742 The fprintf macros for signed integers are:
11743 <pre>
11744 PRIdN PRIdLEASTN PRIdFASTN PRIdMAX PRIdPTR
11745 PRIiN PRIiLEASTN PRIiFASTN PRIiMAX PRIiPTR
11746 </pre>
11748 The fprintf macros for unsigned integers are:
11749 <pre>
11750 PRIoN PRIoLEASTN PRIoFASTN PRIoMAX PRIoPTR
11751 PRIuN PRIuLEASTN PRIuFASTN PRIuMAX PRIuPTR
11752 PRIxN PRIxLEASTN PRIxFASTN PRIxMAX PRIxPTR
11753 PRIXN PRIXLEASTN PRIXFASTN PRIXMAX PRIXPTR
11754 </pre>
11756 The fscanf macros for signed integers are:
11760 <!--page 236 -->
11761 <pre>
11762 SCNdN SCNdLEASTN SCNdFASTN SCNdMAX SCNdPTR
11763 SCNiN SCNiLEASTN SCNiFASTN SCNiMAX SCNiPTR
11764 </pre>
11766 The fscanf macros for unsigned integers are:
11767 <pre>
11768 SCNoN SCNoLEASTN SCNoFASTN SCNoMAX SCNoPTR
11769 SCNuN SCNuLEASTN SCNuFASTN SCNuMAX SCNuPTR
11770 SCNxN SCNxLEASTN SCNxFASTN SCNxMAX SCNxPTR
11771 </pre>
11773 For each type that the implementation provides in <a href="#7.20"><stdint.h></a>, the corresponding
11774 fprintf macros shall be defined and the corresponding fscanf macros shall be
11775 defined unless the implementation does not have a suitable fscanf length modifier for
11776 the type.
11778 EXAMPLE
11779 <pre>
11782 int main(void)
11783 {
11784 uintmax_t i = UINTMAX_MAX; // this type always exists
11787 return 0;
11788 }
11789 </pre>
11792 <p><b>Footnotes</b>
11793 <p><small><a name="note220" href="#note220">220)</a> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
11794 different format specifiers may be required for fprintf and fscanf, even when the type is the
11795 same.
11796 </small>
11803 <p><b>Synopsis</b>
11805 <pre>
11807 intmax_t imaxabs(intmax_t j);
11808 </pre>
11809 <p><b>Description</b>
11811 The imaxabs function computes the absolute value of an integer j. If the result cannot
11813 <p><b>Returns</b>
11815 The imaxabs function returns the absolute value.
11820 <!--page 237 -->
11822 <p><b>Footnotes</b>
11823 <p><small><a name="note221" href="#note221">221)</a> The absolute value of the most negative number cannot be represented in two's complement.
11824 </small>
11828 <p><b>Synopsis</b>
11830 <pre>
11832 imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
11833 </pre>
11834 <p><b>Description</b>
11836 The imaxdiv function computes numer / denom and numer % denom in a single
11837 operation.
11838 <p><b>Returns</b>
11840 The imaxdiv function returns a structure of type imaxdiv_t comprising both the
11841 quotient and the remainder. The structure shall contain (in either order) the members
11842 quot (the quotient) and rem (the remainder), each of which has type intmax_t. If
11843 either part of the result cannot be represented, the behavior is undefined.
11847 <p><b>Synopsis</b>
11849 <pre>
11851 intmax_t strtoimax(const char * restrict nptr,
11852 char ** restrict endptr, int base);
11853 uintmax_t strtoumax(const char * restrict nptr,
11854 char ** restrict endptr, int base);
11855 </pre>
11856 <p><b>Description</b>
11858 The strtoimax and strtoumax functions are equivalent to the strtol, strtoll,
11859 strtoul, and strtoull functions, except that the initial portion of the string is
11860 converted to intmax_t and uintmax_t representation, respectively.
11861 <p><b>Returns</b>
11863 The strtoimax and strtoumax functions return the converted value, if any. If no
11864 conversion could be performed, zero is returned. If the correct value is outside the range
11865 of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
11866 (according to the return type and sign of the value, if any), and the value of the macro
11867 ERANGE is stored in errno.
11868 <p><b> Forward references</b>: the strtol, strtoll, strtoul, and strtoull functions
11870 <!--page 238 -->
11874 <p><b>Synopsis</b>
11876 <pre>
11879 intmax_t wcstoimax(const wchar_t * restrict nptr,
11880 wchar_t ** restrict endptr, int base);
11881 uintmax_t wcstoumax(const wchar_t * restrict nptr,
11882 wchar_t ** restrict endptr, int base);
11883 </pre>
11884 <p><b>Description</b>
11886 The wcstoimax and wcstoumax functions are equivalent to the wcstol, wcstoll,
11887 wcstoul, and wcstoull functions except that the initial portion of the wide string is
11888 converted to intmax_t and uintmax_t representation, respectively.
11889 <p><b>Returns</b>
11891 The wcstoimax function returns the converted value, if any. If no conversion could be
11892 performed, zero is returned. If the correct value is outside the range of representable
11893 values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
11894 return type and sign of the value, if any), and the value of the macro ERANGE is stored in
11895 errno.
11896 <p><b> Forward references</b>: the wcstol, wcstoll, wcstoul, and wcstoull functions
11898 <!--page 239 -->
11903 The header <a href="#7.9"><iso646.h></a> defines the following eleven macros (on the left) that expand
11904 to the corresponding tokens (on the right):
11905 <!--page 240 -->
11906 <pre>
11907 and &&
11908 and_eq &=
11909 bitand &
11910 bitor |
11911 compl ~
11912 not !
11913 not_eq !=
11914 or ||
11915 or_eq |=
11916 xor ^
11917 xor_eq ^=
11918 </pre>
11923 The header <a href="#7.10"><limits.h></a> defines several macros that expand to various limits and
11924 parameters of the standard integer types.
11926 The macros, their meanings, and the constraints (or restrictions) on their values are listed
11928 <!--page 241 -->
11933 The header <a href="#7.11"><locale.h></a> declares two functions, one type, and defines several macros.
11935 The type is
11936 <pre>
11937 struct lconv
11938 </pre>
11939 which contains members related to the formatting of numeric values. The structure shall
11940 contain at least the following members, in any order. The semantics of the members and
11941 their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
11942 the values specified in the comments.
11943 <!--page 242 -->
11944 <pre>
11954 char frac_digits; // CHAR_MAX
11955 char p_cs_precedes; // CHAR_MAX
11956 char n_cs_precedes; // CHAR_MAX
11957 char p_sep_by_space; // CHAR_MAX
11958 char n_sep_by_space; // CHAR_MAX
11959 char p_sign_posn; // CHAR_MAX
11960 char n_sign_posn; // CHAR_MAX
11962 char int_frac_digits; // CHAR_MAX
11963 char int_p_cs_precedes; // CHAR_MAX
11964 char int_n_cs_precedes; // CHAR_MAX
11965 char int_p_sep_by_space; // CHAR_MAX
11966 char int_n_sep_by_space; // CHAR_MAX
11967 char int_p_sign_posn; // CHAR_MAX
11968 char int_n_sign_posn; // CHAR_MAX
11969 </pre>
11972 <pre>
11973 LC_ALL
11974 LC_COLLATE
11975 LC_CTYPE
11976 LC_MONETARY
11977 LC_NUMERIC
11978 LC_TIME
11979 </pre>
11980 which expand to integer constant expressions with distinct values, suitable for use as the
11981 first argument to the setlocale function.<sup><a href="#note222"><b>222)</b></a></sup> Additional macro definitions, beginning
11982 with the characters LC_ and an uppercase letter,<sup><a href="#note223"><b>223)</b></a></sup> may also be specified by the
11983 implementation.
11985 <p><b>Footnotes</b>
11986 <p><small><a name="note222" href="#note222">222)</a> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
11987 </small>
11988 <p><small><a name="note223" href="#note223">223)</a> See ''future library directions'' (<a href="#7.31.6">7.31.6</a>).
11989 </small>
11996 <p><b>Synopsis</b>
11998 <pre>
12000 char *setlocale(int category, const char *locale);
12001 </pre>
12002 <p><b>Description</b>
12004 The setlocale function selects the appropriate portion of the program's locale as
12005 specified by the category and locale arguments. The setlocale function may be
12006 used to change or query the program's entire current locale or portions thereof. The value
12007 LC_ALL for category names the program's entire locale; the other values for
12008 category name only a portion of the program's locale. LC_COLLATE affects the
12009 behavior of the strcoll and strxfrm functions. LC_CTYPE affects the behavior of
12010 the character handling functions<sup><a href="#note224"><b>224)</b></a></sup> and the multibyte and wide character functions.
12011 LC_MONETARY affects the monetary formatting information returned by the
12012 localeconv function. LC_NUMERIC affects the decimal-point character for the
12013 formatted input/output functions and the string conversion functions, as well as the
12014 nonmonetary formatting information returned by the localeconv function. LC_TIME
12015 affects the behavior of the strftime and wcsftime functions.
12019 implementation-defined strings may be passed as the second argument to setlocale.
12021 <!--page 243 -->
12023 At program startup, the equivalent of
12024 <pre>
12026 </pre>
12027 is executed.
12029 A call to the setlocale function may introduce a data race with other calls to the
12030 setlocale function or with calls to functions that are affected by the current locale.
12031 The implementation shall behave as if no library function calls the setlocale function.
12032 <p><b>Returns</b>
12034 If a pointer to a string is given for locale and the selection can be honored, the
12035 setlocale function returns a pointer to the string associated with the specified
12036 category for the new locale. If the selection cannot be honored, the setlocale
12037 function returns a null pointer and the program's locale is not changed.
12039 A null pointer for locale causes the setlocale function to return a pointer to the
12040 string associated with the category for the program's current locale; the program's
12043 The pointer to string returned by the setlocale function is such that a subsequent call
12044 with that string value and its associated category will restore that part of the program's
12045 locale. The string pointed to shall not be modified by the program, but may be
12046 overwritten by a subsequent call to the setlocale function.
12047 <p><b> Forward references</b>: formatted input/output functions (<a href="#7.21.6">7.21.6</a>), multibyte/wide
12048 character conversion functions (<a href="#7.22.7">7.22.7</a>), multibyte/wide string conversion functions
12049 (<a href="#7.22.8">7.22.8</a>), numeric conversion functions (<a href="#7.22.1">7.22.1</a>), the strcoll function (<a href="#7.24.4.3">7.24.4.3</a>), the
12050 strftime function (<a href="#7.27.3.5">7.27.3.5</a>), the strxfrm function (<a href="#7.24.4.5">7.24.4.5</a>).
12052 <p><b>Footnotes</b>
12053 <p><small><a name="note224" href="#note224">224)</a> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
12054 isxdigit.
12055 </small>
12056 <p><small><a name="note225" href="#note225">225)</a> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
12057 locale when category has the value LC_ALL.
12058 </small>
12065 <p><b>Synopsis</b>
12067 <pre>
12069 struct lconv *localeconv(void);
12070 </pre>
12071 <p><b>Description</b>
12073 The localeconv function sets the components of an object with type struct lconv
12074 with values appropriate for the formatting of numeric quantities (monetary and otherwise)
12075 according to the rules of the current locale.
12079 <!--page 244 -->
12081 The members of the structure with type char * are pointers to strings, any of which
12083 the current locale or is of zero length. Apart from grouping and mon_grouping, the
12084 strings shall start and end in the initial shift state. The members with type char are
12085 nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not
12086 available in the current locale. The members include the following:
12087 <dl>
12088 <dt> char *decimal_point
12089 <dd>
12090 The decimal-point character used to format nonmonetary quantities.
12091 <dt> char *thousands_sep
12092 <dd>
12093 The character used to separate groups of digits before the decimal-point
12094 character in formatted nonmonetary quantities.
12095 <dt> char *grouping
12096 <dd>
12097 A string whose elements indicate the size of each group of digits in
12098 formatted nonmonetary quantities.
12099 <dt> char *mon_decimal_point
12100 <dd>
12101 The decimal-point used to format monetary quantities.
12102 <dt> char *mon_thousands_sep
12103 <dd>
12104 The separator for groups of digits before the decimal-point in formatted
12105 monetary quantities.
12106 <dt> char *mon_grouping
12107 <dd>
12108 A string whose elements indicate the size of each group of digits in
12109 formatted monetary quantities.
12110 <dt> char *positive_sign
12111 <dd>
12112 The string used to indicate a nonnegative-valued formatted monetary
12113 quantity.
12114 <dt> char *negative_sign
12115 <dd>
12116 The string used to indicate a negative-valued formatted monetary quantity.
12117 <dt> char *currency_symbol
12118 <dd>
12119 The local currency symbol applicable to the current locale.
12120 <dt> char frac_digits
12121 <dd>
12122 The number of fractional digits (those after the decimal-point) to be
12123 displayed in a locally formatted monetary quantity.
12124 <dt> char p_cs_precedes
12125 <dd>
12126 Set to 1 or 0 if the currency_symbol respectively precedes or
12127 succeeds the value for a nonnegative locally formatted monetary quantity.
12128 <!--page 245 -->
12129 <dt> char n_cs_precedes
12130 <dd>
12131 Set to 1 or 0 if the currency_symbol respectively precedes or
12132 succeeds the value for a negative locally formatted monetary quantity.
12133 <dt> char p_sep_by_space
12134 <dd>
12135 Set to a value indicating the separation of the currency_symbol, the
12136 sign string, and the value for a nonnegative locally formatted monetary
12137 quantity.
12138 <dt> char n_sep_by_space
12139 <dd>
12140 Set to a value indicating the separation of the currency_symbol, the
12141 sign string, and the value for a negative locally formatted monetary
12142 quantity.
12143 <dt> char p_sign_posn
12144 <dd>
12145 Set to a value indicating the positioning of the positive_sign for a
12146 nonnegative locally formatted monetary quantity.
12147 <dt> char n_sign_posn
12148 <dd>
12149 Set to a value indicating the positioning of the negative_sign for a
12150 negative locally formatted monetary quantity.
12151 <dt> char *int_curr_symbol
12152 <dd>
12153 The international currency symbol applicable to the current locale. The
12154 first three characters contain the alphabetic international currency symbol
12155 in accordance with those specified in ISO 4217. The fourth character
12156 (immediately preceding the null character) is the character used to separate
12157 the international currency symbol from the monetary quantity.
12158 <dt> char int_frac_digits
12159 <dd>
12160 The number of fractional digits (those after the decimal-point) to be
12161 displayed in an internationally formatted monetary quantity.
12162 <dt> char int_p_cs_precedes
12163 <dd>
12164 Set to 1 or 0 if the int_curr_symbol respectively precedes or
12165 succeeds the value for a nonnegative internationally formatted monetary
12166 quantity.
12167 <dt> char int_n_cs_precedes
12168 <dd>
12169 Set to 1 or 0 if the int_curr_symbol respectively precedes or
12170 succeeds the value for a negative internationally formatted monetary
12171 quantity.
12172 <dt> char int_p_sep_by_space
12173 <dd>
12174 Set to a value indicating the separation of the int_curr_symbol, the
12175 sign string, and the value for a nonnegative internationally formatted
12176 monetary quantity.
12177 <!--page 246 -->
12178 <dt> char int_n_sep_by_space
12179 <dd>
12180 Set to a value indicating the separation of the int_curr_symbol, the
12181 sign string, and the value for a negative internationally formatted monetary
12182 quantity.
12183 <dt> char int_p_sign_posn
12184 <dd>
12185 Set to a value indicating the positioning of the positive_sign for a
12186 nonnegative internationally formatted monetary quantity.
12187 <dt> char int_n_sign_posn
12188 <dd>
12189 Set to a value indicating the positioning of the negative_sign for a
12190 negative internationally formatted monetary quantity.
12191 </dl>
12193 The elements of grouping and mon_grouping are interpreted according to the
12194 following:
12195 <dl>
12196 <dt> CHAR_MAX <dd>No further grouping is to be performed.
12197 <dt> 0 <dd>The previous element is to be repeatedly used for the remainder of the
12198 digits.
12199 <dt> other <dd>The integer value is the number of digits that compose the current group.
12200 The next element is examined to determine the size of the next group of
12201 digits before the current group.
12202 </dl>
12204 The values of p_sep_by_space, n_sep_by_space, int_p_sep_by_space,
12205 and int_n_sep_by_space are interpreted according to the following:
12206 <dl>
12207 <dt> 0 <dd>No space separates the currency symbol and value.
12208 <dt> 1 <dd>If the currency symbol and sign string are adjacent, a space separates them from the
12209 value; otherwise, a space separates the currency symbol from the value.
12210 <dt> 2 <dd>If the currency symbol and sign string are adjacent, a space separates them;
12211 otherwise, a space separates the sign string from the value.
12212 </dl>
12213 For int_p_sep_by_space and int_n_sep_by_space, the fourth character of
12214 int_curr_symbol is used instead of a space.
12216 The values of p_sign_posn, n_sign_posn, int_p_sign_posn, and
12217 int_n_sign_posn are interpreted according to the following:
12218 <dl>
12219 <dt> 0 <dd>Parentheses surround the quantity and currency symbol.
12220 <dt> 1 <dd>The sign string precedes the quantity and currency symbol.
12221 <dt> 2 <dd>The sign string succeeds the quantity and currency symbol.
12222 <dt> 3 <dd>The sign string immediately precedes the currency symbol.
12223 <dt> 4 <dd>The sign string immediately succeeds the currency symbol.
12224 </dl>
12225 <!--page 247 -->
12227 The implementation shall behave as if no library function calls the localeconv
12228 function.
12229 <p><b>Returns</b>
12231 The localeconv function returns a pointer to the filled-in object. The structure
12232 pointed to by the return value shall not be modified by the program, but may be
12233 overwritten by a subsequent call to the localeconv function. In addition, calls to the
12234 setlocale function with categories LC_ALL, LC_MONETARY, or LC_NUMERIC may
12235 overwrite the contents of the structure.
12237 EXAMPLE 1 The following table illustrates rules which may well be used by four countries to format
12238 monetary quantities.
12239 <pre>
12240 Local format International format
12242 Country Positive Negative Positive Negative
12244 Country1 1.234,56 mk -1.234,56 mk FIM 1.234,56 FIM -1.234,56
12245 Country2 L.1.234 -L.1.234 ITL 1.234 -ITL 1.234
12246 Country3 fl. 1.234,56 fl. -1.234,56 NLG 1.234,56 NLG -1.234,56
12247 Country4 SFrs.1,234.56 SFrs.1,234.56C CHF 1,234.56 CHF 1,234.56C
12248 </pre>
12250 For these four countries, the respective values for the monetary members of the structure returned by
12251 localeconv could be:
12252 <pre>
12253 Country1 Country2 Country3 Country4
12261 frac_digits 2 0 2 2
12262 p_cs_precedes 0 1 1 1
12263 n_cs_precedes 0 1 1 1
12264 p_sep_by_space 1 0 1 0
12265 n_sep_by_space 1 0 2 0
12266 p_sign_posn 1 1 1 1
12267 n_sign_posn 1 1 4 2
12269 int_frac_digits 2 0 2 2
12270 int_p_cs_precedes 1 1 1 1
12271 int_n_cs_precedes 1 1 1 1
12272 int_p_sep_by_space 1 1 1 1
12273 int_n_sep_by_space 2 1 2 1
12274 int_p_sign_posn 1 1 1 1
12275 int_n_sign_posn 4 1 4 2
12276 </pre>
12277 <!--page 248 -->
12279 EXAMPLE 2 The following table illustrates how the cs_precedes, sep_by_space, and sign_posn members
12280 affect the formatted value.
12281 <pre>
12282 p_sep_by_space
12284 p_cs_precedes p_sign_posn 0 1 2
12286 0 0 (1.25$) (1.25 $) (1.25$)
12287 1 +1.25$ +1.25 $ + 1.25$
12288 2 1.25$+ 1.25 $+ 1.25$ +
12289 3 1.25+$ 1.25 +$ 1.25+ $
12290 4 1.25$+ 1.25 $+ 1.25$ +
12291 <!--page 249 -->
12292 1 0 ($1.25) ($ 1.25) ($1.25)
12293 1 +$1.25 +$ 1.25 + $1.25
12294 2 $1.25+ $ 1.25+ $1.25 +
12295 3 +$1.25 +$ 1.25 + $1.25
12296 4 $+1.25 $+ 1.25 $ +1.25
12297 </pre>
12302 The header <a href="#7.12"><math.h></a> declares two types and many mathematical functions and defines
12303 several macros. Most synopses specify a family of functions consisting of a principal
12304 function with one or more double parameters, a double return value, or both; and
12305 other functions with the same name but with f and l suffixes, which are corresponding
12306 functions with float and long double parameters, return values, or both.<sup><a href="#note226"><b>226)</b></a></sup>
12307 Integer arithmetic functions and conversion functions are discussed later.
12309 The types
12310 <pre>
12311 float_t
12312 double_t
12313 </pre>
12314 are floating types at least as wide as float and double, respectively, and such that
12315 double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
12316 float_t and double_t are float and double, respectively; if
12317 FLT_EVAL_METHOD equals 1, they are both double; if FLT_EVAL_METHOD equals
12318 2, they are both long double; and for other values of FLT_EVAL_METHOD, they are
12321 The macro
12322 <pre>
12323 HUGE_VAL
12324 </pre>
12325 expands to a positive double constant expression, not necessarily representable as a
12326 float. The macros
12327 <pre>
12328 HUGE_VALF
12329 HUGE_VALL
12330 </pre>
12331 are respectively float and long double analogs of HUGE_VAL.<sup><a href="#note228"><b>228)</b></a></sup>
12333 The macro
12334 <pre>
12335 INFINITY
12336 </pre>
12337 expands to a constant expression of type float representing positive or unsigned
12338 infinity, if available; else to a positive constant of type float that overflows at
12342 <!--page 250 -->
12345 The macro
12346 <pre>
12347 NAN
12348 </pre>
12349 is defined if and only if the implementation supports quiet NaNs for the float type. It
12350 expands to a constant expression of type float representing a quiet NaN.
12352 The number classification macros
12353 <pre>
12354 FP_INFINITE
12355 FP_NAN
12356 FP_NORMAL
12357 FP_SUBNORMAL
12358 FP_ZERO
12359 </pre>
12360 represent the mutually exclusive kinds of floating-point values. They expand to integer
12361 constant expressions with distinct values. Additional implementation-defined floating-
12362 point classifications, with macro definitions beginning with FP_ and an uppercase letter,
12363 may also be specified by the implementation.
12365 The macro
12366 <pre>
12367 FP_FAST_FMA
12368 </pre>
12369 is optionally defined. If defined, it indicates that the fma function generally executes
12370 about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note230"><b>230)</b></a></sup> The
12371 macros
12372 <pre>
12373 FP_FAST_FMAF
12374 FP_FAST_FMAL
12375 </pre>
12376 are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
12377 these macros expand to the integer constant 1.
12379 The macros
12380 <pre>
12381 FP_ILOGB0
12382 FP_ILOGBNAN
12383 </pre>
12384 expand to integer constant expressions whose values are returned by ilogb(x) if x is
12385 zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
12386 -INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
12389 <!--page 251 -->
12391 The macros
12392 <pre>
12393 MATH_ERRNO
12394 MATH_ERREXCEPT
12395 </pre>
12396 expand to the integer constants 1 and 2, respectively; the macro
12397 <pre>
12398 math_errhandling
12399 </pre>
12400 expands to an expression that has type int and the value MATH_ERRNO,
12401 MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
12402 constant for the duration of the program. It is unspecified whether
12403 math_errhandling is a macro or an identifier with external linkage. If a macro
12404 definition is suppressed or a program defines an identifier with the name
12405 math_errhandling, the behavior is undefined. If the expression
12406 math_errhandling & MATH_ERREXCEPT can be nonzero, the implementation
12407 shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
12410 <p><b>Footnotes</b>
12411 <p><small><a name="note226" href="#note226">226)</a> Particularly on systems with wide expression evaluation, a <a href="#7.12"><math.h></a> function might pass arguments
12412 and return values in wider format than the synopsis prototype indicates.
12413 </small>
12414 <p><small><a name="note227" href="#note227">227)</a> The types float_t and double_t are intended to be the implementation's most efficient types at
12415 least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
12416 type float_t is the narrowest type used by the implementation to evaluate floating expressions.
12417 </small>
12418 <p><small><a name="note228" href="#note228">228)</a> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
12419 supports infinities.
12420 </small>
12421 <p><small><a name="note229" href="#note229">229)</a> In this case, using INFINITY will violate the constraint in <a href="#6.4.4">6.4.4</a> and thus require a diagnostic.
12422 </small>
12423 <p><small><a name="note230" href="#note230">230)</a> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
12424 directly with a hardware multiply-add instruction. Software implementations are expected to be
12425 substantially slower.
12426 </small>
12431 The behavior of each of the functions in <a href="#7.12"><math.h></a> is specified for all representable
12432 values of its input arguments, except where stated otherwise. Each function shall execute
12433 as if it were a single operation without raising SIGFPE and without generating any of the
12434 floating-point exceptions ''invalid'', ''divide-by-zero'', or ''overflow'' except to reflect
12435 the result of the function.
12437 For all functions, a domain error occurs if an input argument is outside the domain over
12438 which the mathematical function is defined. The description of each function lists any
12439 required domain errors; an implementation may define additional domain errors, provided
12440 that such errors are consistent with the mathematical definition of the function.<sup><a href="#note231"><b>231)</b></a></sup> On a
12441 domain error, the function returns an implementation-defined value; if the integer
12442 expression math_errhandling & MATH_ERRNO is nonzero, the integer expression
12443 errno acquires the value EDOM; if the integer expression math_errhandling &
12444 MATH_ERREXCEPT is nonzero, the ''invalid'' floating-point exception is raised.
12446 Similarly, a pole error (also known as a singularity or infinitary) occurs if the
12447 mathematical function has an exact infinite result as the finite input argument(s) are
12448 approached in the limit (for example, log(0.0)). The description of each function lists
12449 any required pole errors; an implementation may define additional pole errors, provided
12450 that such errors are consistent with the mathematical definition of the function. On a pole
12451 error, the function returns an implementation-defined value; if the integer expression
12454 <!--page 252 -->
12455 math_errhandling & MATH_ERRNO is nonzero, the integer expression errno
12456 acquires the value ERANGE; if the integer expression math_errhandling &
12457 MATH_ERREXCEPT is nonzero, the ''divide-by-zero'' floating-point exception is raised.
12459 Likewise, a range error occurs if the mathematical result of the function cannot be
12460 represented in an object of the specified type, due to extreme magnitude.
12462 A floating result overflows if the magnitude of the mathematical result is finite but so
12463 large that the mathematical result cannot be represented without extraordinary roundoff
12464 error in an object of the specified type. If a floating result overflows and default rounding
12465 is in effect, then the function returns the value of the macro HUGE_VAL, HUGE_VALF, or
12466 HUGE_VALL according to the return type, with the same sign as the correct value of the
12467 function; if the integer expression math_errhandling & MATH_ERRNO is nonzero,
12468 the integer expression errno acquires the value ERANGE; if the integer expression
12469 math_errhandling & MATH_ERREXCEPT is nonzero, the ''overflow'' floating-
12470 point exception is raised.
12472 The result underflows if the magnitude of the mathematical result is so small that the
12473 mathematical result cannot be represented, without extraordinary roundoff error, in an
12474 object of the specified type.<sup><a href="#note232"><b>232)</b></a></sup> If the result underflows, the function returns an
12475 implementation-defined value whose magnitude is no greater than the smallest
12476 normalized positive number in the specified type; if the integer expression
12477 math_errhandling & MATH_ERRNO is nonzero, whether errno acquires the
12478 value ERANGE is implementation-defined; if the integer expression
12479 math_errhandling & MATH_ERREXCEPT is nonzero, whether the ''underflow''
12480 floating-point exception is raised is implementation-defined.
12482 If a domain, pole, or range error occurs and the integer expression
12483 math_errhandling & MATH_ERRNO is zero,<sup><a href="#note233"><b>233)</b></a></sup> then errno shall either be set to
12484 the value corresponding to the error or left unmodified. If no such error occurs, errno
12485 shall be left unmodified regardless of the setting of math_errhandling.
12490 <!--page 253 -->
12492 <p><b>Footnotes</b>
12493 <p><small><a name="note231" href="#note231">231)</a> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
12494 error if the mathematical domain of the function does not include the infinity.
12495 </small>
12496 <p><small><a name="note232" href="#note232">232)</a> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
12497 also ''flush-to-zero'' underflow.
12498 </small>
12499 <p><small><a name="note233" href="#note233">233)</a> Math errors are being indicated by the floating-point exception flags rather than by errno.
12500 </small>
12504 <p><b>Synopsis</b>
12506 <pre>
12508 #pragma STDC FP_CONTRACT on-off-switch
12509 </pre>
12510 <p><b>Description</b>
12512 The FP_CONTRACT pragma can be used to allow (if the state is ''on'') or disallow (if the
12513 state is ''off'') the implementation to contract expressions (<a href="#6.5">6.5</a>). Each pragma can occur
12514 either outside external declarations or preceding all explicit declarations and statements
12515 inside a compound statement. When outside external declarations, the pragma takes
12516 effect from its occurrence until another FP_CONTRACT pragma is encountered, or until
12517 the end of the translation unit. When inside a compound statement, the pragma takes
12518 effect from its occurrence until another FP_CONTRACT pragma is encountered
12519 (including within a nested compound statement), or until the end of the compound
12520 statement; at the end of a compound statement the state for the pragma is restored to its
12521 condition just before the compound statement. If this pragma is used in any other
12522 context, the behavior is undefined. The default state (''on'' or ''off'') for the pragma is
12523 implementation-defined.
12528 In the synopses in this subclause, real-floating indicates that the argument shall be an
12529 expression of real floating type.
12533 <p><b>Synopsis</b>
12535 <pre>
12537 int fpclassify(real-floating x);
12538 </pre>
12539 <p><b>Description</b>
12541 The fpclassify macro classifies its argument value as NaN, infinite, normal,
12542 subnormal, zero, or into another implementation-defined category. First, an argument
12543 represented in a format wider than its semantic type is converted to its semantic type.
12544 Then classification is based on the type of the argument.<sup><a href="#note234"><b>234)</b></a></sup>
12545 <p><b>Returns</b>
12547 The fpclassify macro returns the value of the number classification macro
12548 appropriate to the value of its argument.
12551 <!--page 254 -->
12553 <p><b>Footnotes</b>
12554 <p><small><a name="note234" href="#note234">234)</a> Since an expression can be evaluated with more range and precision than its type has, it is important to
12555 know the type that classification is based on. For example, a normal long double value might
12556 become subnormal when converted to double, and zero when converted to float.
12557 </small>
12561 <p><b>Synopsis</b>
12563 <pre>
12565 int isfinite(real-floating x);
12566 </pre>
12567 <p><b>Description</b>
12569 The isfinite macro determines whether its argument has a finite value (zero,
12570 subnormal, or normal, and not infinite or NaN). First, an argument represented in a
12571 format wider than its semantic type is converted to its semantic type. Then determination
12572 is based on the type of the argument.
12573 <p><b>Returns</b>
12575 The isfinite macro returns a nonzero value if and only if its argument has a finite
12576 value.
12580 <p><b>Synopsis</b>
12582 <pre>
12584 int isinf(real-floating x);
12585 </pre>
12586 <p><b>Description</b>
12588 The isinf macro determines whether its argument value is an infinity (positive or
12589 negative). First, an argument represented in a format wider than its semantic type is
12590 converted to its semantic type. Then determination is based on the type of the argument.
12591 <p><b>Returns</b>
12593 The isinf macro returns a nonzero value if and only if its argument has an infinite
12594 value.
12598 <p><b>Synopsis</b>
12600 <pre>
12602 int isnan(real-floating x);
12603 </pre>
12604 <p><b>Description</b>
12606 The isnan macro determines whether its argument value is a NaN. First, an argument
12607 represented in a format wider than its semantic type is converted to its semantic type.
12608 Then determination is based on the type of the argument.<sup><a href="#note235"><b>235)</b></a></sup>
12611 <!--page 255 -->
12612 <p><b>Returns</b>
12614 The isnan macro returns a nonzero value if and only if its argument has a NaN value.
12616 <p><b>Footnotes</b>
12617 <p><small><a name="note235" href="#note235">235)</a> For the isnan macro, the type for determination does not matter unless the implementation supports
12618 NaNs in the evaluation type but not in the semantic type.
12619 </small>
12623 <p><b>Synopsis</b>
12625 <pre>
12627 int isnormal(real-floating x);
12628 </pre>
12629 <p><b>Description</b>
12631 The isnormal macro determines whether its argument value is normal (neither zero,
12632 subnormal, infinite, nor NaN). First, an argument represented in a format wider than its
12633 semantic type is converted to its semantic type. Then determination is based on the type
12634 of the argument.
12635 <p><b>Returns</b>
12637 The isnormal macro returns a nonzero value if and only if its argument has a normal
12638 value.
12642 <p><b>Synopsis</b>
12644 <pre>
12646 int signbit(real-floating x);
12647 </pre>
12648 <p><b>Description</b>
12650 The signbit macro determines whether the sign of its argument value is negative.<sup><a href="#note236"><b>236)</b></a></sup>
12651 <p><b>Returns</b>
12653 The signbit macro returns a nonzero value if and only if the sign of its argument value
12654 is negative.
12659 <!--page 256 -->
12661 <p><b>Footnotes</b>
12662 <p><small><a name="note236" href="#note236">236)</a> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
12663 unsigned, it is treated as positive.
12664 </small>
12671 <p><b>Synopsis</b>
12673 <pre>
12675 double acos(double x);
12676 float acosf(float x);
12677 long double acosl(long double x);
12678 </pre>
12679 <p><b>Description</b>
12681 The acos functions compute the principal value of the arc cosine of x. A domain error
12682 occurs for arguments not in the interval [-1, +1].
12683 <p><b>Returns</b>
12685 The acos functions return arccos x in the interval [0, pi ] radians.
12689 <p><b>Synopsis</b>
12691 <pre>
12693 double asin(double x);
12694 float asinf(float x);
12695 long double asinl(long double x);
12696 </pre>
12697 <p><b>Description</b>
12699 The asin functions compute the principal value of the arc sine of x. A domain error
12700 occurs for arguments not in the interval [-1, +1].
12701 <p><b>Returns</b>
12703 The asin functions return arcsin x in the interval [-pi /2, +pi /2] radians.
12707 <p><b>Synopsis</b>
12709 <pre>
12711 double atan(double x);
12712 float atanf(float x);
12713 long double atanl(long double x);
12714 </pre>
12715 <p><b>Description</b>
12717 The atan functions compute the principal value of the arc tangent of x.
12718 <!--page 257 -->
12719 <p><b>Returns</b>
12721 The atan functions return arctan x in the interval [-pi /2, +pi /2] radians.
12725 <p><b>Synopsis</b>
12727 <pre>
12729 double atan2(double y, double x);
12730 float atan2f(float y, float x);
12731 long double atan2l(long double y, long double x);
12732 </pre>
12733 <p><b>Description</b>
12735 The atan2 functions compute the value of the arc tangent of y/x, using the signs of both
12736 arguments to determine the quadrant of the return value. A domain error may occur if
12737 both arguments are zero.
12738 <p><b>Returns</b>
12740 The atan2 functions return arctan y/x in the interval [-pi , +pi ] radians.
12744 <p><b>Synopsis</b>
12746 <pre>
12748 double cos(double x);
12749 float cosf(float x);
12750 long double cosl(long double x);
12751 </pre>
12752 <p><b>Description</b>
12754 The cos functions compute the cosine of x (measured in radians).
12755 <p><b>Returns</b>
12757 The cos functions return cos x.
12761 <p><b>Synopsis</b>
12763 <pre>
12765 double sin(double x);
12766 float sinf(float x);
12767 long double sinl(long double x);
12768 </pre>
12769 <p><b>Description</b>
12771 The sin functions compute the sine of x (measured in radians).
12772 <!--page 258 -->
12773 <p><b>Returns</b>
12775 The sin functions return sin x.
12779 <p><b>Synopsis</b>
12781 <pre>
12783 double tan(double x);
12784 float tanf(float x);
12785 long double tanl(long double x);
12786 </pre>
12787 <p><b>Description</b>
12789 The tan functions return the tangent of x (measured in radians).
12790 <p><b>Returns</b>
12792 The tan functions return tan x.
12799 <p><b>Synopsis</b>
12801 <pre>
12803 double acosh(double x);
12804 float acoshf(float x);
12805 long double acoshl(long double x);
12806 </pre>
12807 <p><b>Description</b>
12809 The acosh functions compute the (nonnegative) arc hyperbolic cosine of x. A domain
12810 error occurs for arguments less than 1.
12811 <p><b>Returns</b>
12813 The acosh functions return arcosh x in the interval [0, +(inf)].
12817 <p><b>Synopsis</b>
12819 <pre>
12821 double asinh(double x);
12822 float asinhf(float x);
12823 long double asinhl(long double x);
12824 </pre>
12825 <p><b>Description</b>
12827 The asinh functions compute the arc hyperbolic sine of x.
12828 <!--page 259 -->
12829 <p><b>Returns</b>
12831 The asinh functions return arsinh x.
12835 <p><b>Synopsis</b>
12837 <pre>
12839 double atanh(double x);
12840 float atanhf(float x);
12841 long double atanhl(long double x);
12842 </pre>
12843 <p><b>Description</b>
12845 The atanh functions compute the arc hyperbolic tangent of x. A domain error occurs
12846 for arguments not in the interval [-1, +1]. A pole error may occur if the argument equals
12847 -1 or +1.
12848 <p><b>Returns</b>
12850 The atanh functions return artanh x.
12854 <p><b>Synopsis</b>
12856 <pre>
12858 double cosh(double x);
12859 float coshf(float x);
12860 long double coshl(long double x);
12861 </pre>
12862 <p><b>Description</b>
12864 The cosh functions compute the hyperbolic cosine of x. A range error occurs if the
12865 magnitude of x is too large.
12866 <p><b>Returns</b>
12868 The cosh functions return cosh x.
12872 <p><b>Synopsis</b>
12874 <pre>
12876 double sinh(double x);
12877 float sinhf(float x);
12878 long double sinhl(long double x);
12879 </pre>
12880 <p><b>Description</b>
12882 The sinh functions compute the hyperbolic sine of x. A range error occurs if the
12883 magnitude of x is too large.
12884 <!--page 260 -->
12885 <p><b>Returns</b>
12887 The sinh functions return sinh x.
12891 <p><b>Synopsis</b>
12893 <pre>
12895 double tanh(double x);
12896 float tanhf(float x);
12897 long double tanhl(long double x);
12898 </pre>
12899 <p><b>Description</b>
12901 The tanh functions compute the hyperbolic tangent of x.
12902 <p><b>Returns</b>
12904 The tanh functions return tanh x.
12911 <p><b>Synopsis</b>
12913 <pre>
12915 double exp(double x);
12916 float expf(float x);
12917 long double expl(long double x);
12918 </pre>
12919 <p><b>Description</b>
12921 The exp functions compute the base-e exponential of x. A range error occurs if the
12922 magnitude of x is too large.
12923 <p><b>Returns</b>
12925 The exp functions return e<sup>x</sup>.
12929 <p><b>Synopsis</b>
12931 <pre>
12933 double exp2(double x);
12934 float exp2f(float x);
12935 long double exp2l(long double x);
12936 </pre>
12937 <p><b>Description</b>
12939 The exp2 functions compute the base-2 exponential of x. A range error occurs if the
12940 magnitude of x is too large.
12941 <!--page 261 -->
12942 <p><b>Returns</b>
12944 The exp2 functions return 2<sup>x</sup>.
12948 <p><b>Synopsis</b>
12950 <pre>
12952 double expm1(double x);
12953 float expm1f(float x);
12954 long double expm1l(long double x);
12955 </pre>
12956 <p><b>Description</b>
12958 The expm1 functions compute the base-e exponential of the argument, minus 1. A range
12960 <p><b>Returns</b>
12962 The expm1 functions return e<sup>x</sup> - 1.
12964 <p><b>Footnotes</b>
12965 <p><small><a name="note237" href="#note237">237)</a> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
12966 </small>
12970 <p><b>Synopsis</b>
12972 <pre>
12974 double frexp(double value, int *exp);
12975 float frexpf(float value, int *exp);
12976 long double frexpl(long double value, int *exp);
12977 </pre>
12978 <p><b>Description</b>
12980 The frexp functions break a floating-point number into a normalized fraction and an
12981 integral power of 2. They store the integer in the int object pointed to by exp.
12982 <p><b>Returns</b>
12984 If value is not a floating-point number or if the integral power of 2 is outside the range
12985 of int, the results are unspecified. Otherwise, the frexp functions return the value x,
12986 such that x has a magnitude in the interval [1/2, 1) or zero, and value equals x 2<sup>*exp</sup>.
12987 If value is zero, both parts of the result are zero.
12992 <!--page 262 -->
12996 <p><b>Synopsis</b>
12998 <pre>
13000 int ilogb(double x);
13001 int ilogbf(float x);
13002 int ilogbl(long double x);
13003 </pre>
13004 <p><b>Description</b>
13006 The ilogb functions extract the exponent of x as a signed int value. If x is zero they
13007 compute the value FP_ILOGB0; if x is infinite they compute the value INT_MAX; if x is
13008 a NaN they compute the value FP_ILOGBNAN; otherwise, they are equivalent to calling
13009 the corresponding logb function and casting the returned value to type int. A domain
13010 error or range error may occur if x is zero, infinite, or NaN. If the correct value is outside
13011 the range of the return type, the numeric result is unspecified.
13012 <p><b>Returns</b>
13014 The ilogb functions return the exponent of x as a signed int value.
13019 <p><b>Synopsis</b>
13021 <pre>
13023 double ldexp(double x, int exp);
13024 float ldexpf(float x, int exp);
13025 long double ldexpl(long double x, int exp);
13026 </pre>
13027 <p><b>Description</b>
13029 The ldexp functions multiply a floating-point number by an integral power of 2. A
13030 range error may occur.
13031 <p><b>Returns</b>
13033 The ldexp functions return x 2<sup>exp</sup>.
13037 <p><b>Synopsis</b>
13039 <!--page 263 -->
13040 <pre>
13042 double log(double x);
13043 float logf(float x);
13044 long double logl(long double x);
13045 </pre>
13046 <p><b>Description</b>
13048 The log functions compute the base-e (natural) logarithm of x. A domain error occurs if
13049 the argument is negative. A pole error may occur if the argument is zero.
13050 <p><b>Returns</b>
13052 The log functions return loge x.
13056 <p><b>Synopsis</b>
13058 <pre>
13060 double log10(double x);
13061 float log10f(float x);
13062 long double log10l(long double x);
13063 </pre>
13064 <p><b>Description</b>
13066 The log10 functions compute the base-10 (common) logarithm of x. A domain error
13067 occurs if the argument is negative. A pole error may occur if the argument is zero.
13068 <p><b>Returns</b>
13070 The log10 functions return log10 x.
13074 <p><b>Synopsis</b>
13076 <pre>
13078 double log1p(double x);
13079 float log1pf(float x);
13080 long double log1pl(long double x);
13081 </pre>
13082 <p><b>Description</b>
13084 The log1p functions compute the base-e (natural) logarithm of 1 plus the argument.<sup><a href="#note238"><b>238)</b></a></sup>
13085 A domain error occurs if the argument is less than -1. A pole error may occur if the
13086 argument equals -1.
13087 <p><b>Returns</b>
13089 The log1p functions return loge (1 + x).
13094 <!--page 264 -->
13096 <p><b>Footnotes</b>
13097 <p><small><a name="note238" href="#note238">238)</a> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
13098 </small>
13102 <p><b>Synopsis</b>
13104 <pre>
13106 double log2(double x);
13107 float log2f(float x);
13108 long double log2l(long double x);
13109 </pre>
13110 <p><b>Description</b>
13112 The log2 functions compute the base-2 logarithm of x. A domain error occurs if the
13113 argument is less than zero. A pole error may occur if the argument is zero.
13114 <p><b>Returns</b>
13116 The log2 functions return log2 x.
13120 <p><b>Synopsis</b>
13122 <pre>
13124 double logb(double x);
13125 float logbf(float x);
13126 long double logbl(long double x);
13127 </pre>
13128 <p><b>Description</b>
13130 The logb functions extract the exponent of x, as a signed integer value in floating-point
13131 format. If x is subnormal it is treated as though it were normalized; thus, for positive
13132 finite x,
13133 <pre>
13134 1 <= x FLT_RADIX<sup>-logb(x)</sup> < FLT_RADIX
13135 </pre>
13136 A domain error or pole error may occur if the argument is zero.
13137 <p><b>Returns</b>
13139 The logb functions return the signed exponent of x.
13143 <p><b>Synopsis</b>
13145 <pre>
13147 double modf(double value, double *iptr);
13148 float modff(float value, float *iptr);
13149 long double modfl(long double value, long double *iptr);
13150 </pre>
13151 <p><b>Description</b>
13153 The modf functions break the argument value into integral and fractional parts, each of
13154 which has the same type and sign as the argument. They store the integral part (in
13155 <!--page 265 -->
13156 floating-point format) in the object pointed to by iptr.
13157 <p><b>Returns</b>
13159 The modf functions return the signed fractional part of value.
13163 <p><b>Synopsis</b>
13165 <pre>
13167 double scalbn(double x, int n);
13168 float scalbnf(float x, int n);
13169 long double scalbnl(long double x, int n);
13170 double scalbln(double x, long int n);
13171 float scalblnf(float x, long int n);
13172 long double scalblnl(long double x, long int n);
13173 </pre>
13174 <p><b>Description</b>
13176 The scalbn and scalbln functions compute x FLT_RADIX<sup>n</sup> efficiently, not
13177 normally by computing FLT_RADIX<sup>n</sup> explicitly. A range error may occur.
13178 <p><b>Returns</b>
13180 The scalbn and scalbln functions return x FLT_RADIX<sup>n</sup>.
13187 <p><b>Synopsis</b>
13189 <pre>
13191 double cbrt(double x);
13192 float cbrtf(float x);
13193 long double cbrtl(long double x);
13194 </pre>
13195 <p><b>Description</b>
13197 The cbrt functions compute the real cube root of x.
13198 <p><b>Returns</b>
13200 The cbrt functions return x<sup>1/3</sup>.
13201 <!--page 266 -->
13205 <p><b>Synopsis</b>
13207 <pre>
13209 double fabs(double x);
13210 float fabsf(float x);
13211 long double fabsl(long double x);
13212 </pre>
13213 <p><b>Description</b>
13215 The fabs functions compute the absolute value of a floating-point number x.
13216 <p><b>Returns</b>
13218 The fabs functions return | x |.
13222 <p><b>Synopsis</b>
13224 <pre>
13226 double hypot(double x, double y);
13227 float hypotf(float x, float y);
13228 long double hypotl(long double x, long double y);
13229 </pre>
13230 <p><b>Description</b>
13232 The hypot functions compute the square root of the sum of the squares of x and y,
13233 without undue overflow or underflow. A range error may occur.
13235 <p><b>Returns</b>
13237 The hypot functions return (sqrt)(x<sup>2</sup> + y<sup>2</sup>).
13241 <p><b>Synopsis</b>
13243 <pre>
13245 double pow(double x, double y);
13246 float powf(float x, float y);
13247 long double powl(long double x, long double y);
13248 </pre>
13249 <p><b>Description</b>
13251 The pow functions compute x raised to the power y. A domain error occurs if x is finite
13252 and negative and y is finite and not an integer value. A range error may occur. A domain
13253 error may occur if x is zero and y is zero. A domain error or pole error may occur if x is
13254 zero and y is less than zero.
13255 <!--page 267 -->
13256 <p><b>Returns</b>
13258 The pow functions return x<sup>y</sup>.
13262 <p><b>Synopsis</b>
13264 <pre>
13266 double sqrt(double x);
13267 float sqrtf(float x);
13268 long double sqrtl(long double x);
13269 </pre>
13270 <p><b>Description</b>
13272 The sqrt functions compute the nonnegative square root of x. A domain error occurs if
13273 the argument is less than zero.
13274 <p><b>Returns</b>
13276 The sqrt functions return (sqrt)(x).
13283 <p><b>Synopsis</b>
13285 <pre>
13287 double erf(double x);
13288 float erff(float x);
13289 long double erfl(long double x);
13290 </pre>
13291 <p><b>Description</b>
13293 The erf functions compute the error function of x.
13294 <p><b>Returns</b>
13296 The erf functions return
13297 <pre>
13298 2 x
13299 erf x = --- (integral) e<sup>-t<sup>2</sup></sup> dt .
13300 (sqrt)(pi) 0
13301 </pre>
13305 <p><b>Synopsis</b>
13307 <pre>
13309 double erfc(double x);
13310 float erfcf(float x);
13311 long double erfcl(long double x);
13312 </pre>
13313 <p><b>Description</b>
13315 The erfc functions compute the complementary error function of x. A range error
13316 occurs if x is too large.
13317 <!--page 268 -->
13318 <p><b>Returns</b>
13320 The erfc functions return
13321 <pre>
13322 2 (inf)
13323 erfc x = 1 - erf x = --- (integral) e<sup>-t<sup>2</sup></sup> dt .
13324 (sqrt)(pi) x
13325 </pre>
13329 <p><b>Synopsis</b>
13331 <pre>
13333 double lgamma(double x);
13334 float lgammaf(float x);
13335 long double lgammal(long double x);
13336 </pre>
13337 <p><b>Description</b>
13339 The lgamma functions compute the natural logarithm of the absolute value of gamma of
13340 x. A range error occurs if x is too large. A pole error may occur if x is a negative integer
13341 or zero.
13342 <p><b>Returns</b>
13344 The lgamma functions return loge | (Gamma)(x) |.
13348 <p><b>Synopsis</b>
13350 <pre>
13352 double tgamma(double x);
13353 float tgammaf(float x);
13354 long double tgammal(long double x);
13355 </pre>
13356 <p><b>Description</b>
13358 The tgamma functions compute the gamma function of x. A domain error or pole error
13359 may occur if x is a negative integer or zero. A range error occurs if the magnitude of x is
13360 too large and may occur if the magnitude of x is too small.
13361 <p><b>Returns</b>
13363 The tgamma functions return (Gamma)(x).
13364 <!--page 269 -->
13371 <p><b>Synopsis</b>
13373 <pre>
13375 double ceil(double x);
13376 float ceilf(float x);
13377 long double ceill(long double x);
13378 </pre>
13379 <p><b>Description</b>
13381 The ceil functions compute the smallest integer value not less than x.
13382 <p><b>Returns</b>
13384 The ceil functions return [^x^], expressed as a floating-point number.
13388 <p><b>Synopsis</b>
13390 <pre>
13392 double floor(double x);
13393 float floorf(float x);
13394 long double floorl(long double x);
13395 </pre>
13396 <p><b>Description</b>
13398 The floor functions compute the largest integer value not greater than x.
13399 <p><b>Returns</b>
13401 The floor functions return [_x_], expressed as a floating-point number.
13405 <p><b>Synopsis</b>
13407 <pre>
13409 double nearbyint(double x);
13410 float nearbyintf(float x);
13411 long double nearbyintl(long double x);
13412 </pre>
13413 <p><b>Description</b>
13415 The nearbyint functions round their argument to an integer value in floating-point
13416 format, using the current rounding direction and without raising the ''inexact'' floating-
13417 point exception.
13418 <!--page 270 -->
13419 <p><b>Returns</b>
13421 The nearbyint functions return the rounded integer value.
13425 <p><b>Synopsis</b>
13427 <pre>
13429 double rint(double x);
13430 float rintf(float x);
13431 long double rintl(long double x);
13432 </pre>
13433 <p><b>Description</b>
13435 The rint functions differ from the nearbyint functions (<a href="#7.12.9.3">7.12.9.3</a>) only in that the
13436 rint functions may raise the ''inexact'' floating-point exception if the result differs in
13437 value from the argument.
13438 <p><b>Returns</b>
13440 The rint functions return the rounded integer value.
13444 <p><b>Synopsis</b>
13446 <pre>
13448 long int lrint(double x);
13449 long int lrintf(float x);
13450 long int lrintl(long double x);
13451 long long int llrint(double x);
13452 long long int llrintf(float x);
13453 long long int llrintl(long double x);
13454 </pre>
13455 <p><b>Description</b>
13457 The lrint and llrint functions round their argument to the nearest integer value,
13458 rounding according to the current rounding direction. If the rounded value is outside the
13459 range of the return type, the numeric result is unspecified and a domain error or range
13460 error may occur.
13461 <p><b>Returns</b>
13463 The lrint and llrint functions return the rounded integer value.
13464 <!--page 271 -->
13468 <p><b>Synopsis</b>
13470 <pre>
13472 double round(double x);
13473 float roundf(float x);
13474 long double roundl(long double x);
13475 </pre>
13476 <p><b>Description</b>
13478 The round functions round their argument to the nearest integer value in floating-point
13479 format, rounding halfway cases away from zero, regardless of the current rounding
13480 direction.
13481 <p><b>Returns</b>
13483 The round functions return the rounded integer value.
13487 <p><b>Synopsis</b>
13489 <pre>
13491 long int lround(double x);
13492 long int lroundf(float x);
13493 long int lroundl(long double x);
13494 long long int llround(double x);
13495 long long int llroundf(float x);
13496 long long int llroundl(long double x);
13497 </pre>
13498 <p><b>Description</b>
13500 The lround and llround functions round their argument to the nearest integer value,
13501 rounding halfway cases away from zero, regardless of the current rounding direction. If
13502 the rounded value is outside the range of the return type, the numeric result is unspecified
13503 and a domain error or range error may occur.
13504 <p><b>Returns</b>
13506 The lround and llround functions return the rounded integer value.
13510 <p><b>Synopsis</b>
13512 <!--page 272 -->
13513 <pre>
13515 double trunc(double x);
13516 float truncf(float x);
13517 long double truncl(long double x);
13518 </pre>
13519 <p><b>Description</b>
13521 The trunc functions round their argument to the integer value, in floating format,
13522 nearest to but no larger in magnitude than the argument.
13523 <p><b>Returns</b>
13525 The trunc functions return the truncated integer value.
13532 <p><b>Synopsis</b>
13534 <pre>
13536 double fmod(double x, double y);
13537 float fmodf(float x, float y);
13538 long double fmodl(long double x, long double y);
13539 </pre>
13540 <p><b>Description</b>
13542 The fmod functions compute the floating-point remainder of x/y.
13543 <p><b>Returns</b>
13545 The fmod functions return the value x - ny, for some integer n such that, if y is nonzero,
13546 the result has the same sign as x and magnitude less than the magnitude of y. If y is zero,
13547 whether a domain error occurs or the fmod functions return zero is implementation-
13548 defined.
13552 <p><b>Synopsis</b>
13554 <pre>
13556 double remainder(double x, double y);
13557 float remainderf(float x, float y);
13558 long double remainderl(long double x, long double y);
13559 </pre>
13560 <p><b>Description</b>
13562 The remainder functions compute the remainder x REM y required by IEC 60559.<sup><a href="#note239"><b>239)</b></a></sup>
13567 <!--page 273 -->
13568 <p><b>Returns</b>
13570 The remainder functions return x REM y. If y is zero, whether a domain error occurs
13571 or the functions return zero is implementation defined.
13573 <p><b>Footnotes</b>
13574 <p><small><a name="note239" href="#note239">239)</a> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
13575 mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
13576 | n - x/y | = 1/2, then n is even. If r = 0, its sign shall be that of x.'' This definition is applicable for
13577 all implementations.
13578 </small>
13582 <p><b>Synopsis</b>
13584 <pre>
13586 double remquo(double x, double y, int *quo);
13587 float remquof(float x, float y, int *quo);
13588 long double remquol(long double x, long double y,
13589 int *quo);
13590 </pre>
13591 <p><b>Description</b>
13593 The remquo functions compute the same remainder as the remainder functions. In
13594 the object pointed to by quo they store a value whose sign is the sign of x/y and whose
13595 magnitude is congruent modulo 2<sup>n</sup> to the magnitude of the integral quotient of x/y, where
13596 n is an implementation-defined integer greater than or equal to 3.
13597 <p><b>Returns</b>
13599 The remquo functions return x REM y. If y is zero, the value stored in the object
13600 pointed to by quo is unspecified and whether a domain error occurs or the functions
13601 return zero is implementation defined.
13608 <p><b>Synopsis</b>
13610 <pre>
13612 double copysign(double x, double y);
13613 float copysignf(float x, float y);
13614 long double copysignl(long double x, long double y);
13615 </pre>
13616 <p><b>Description</b>
13618 The copysign functions produce a value with the magnitude of x and the sign of y.
13619 They produce a NaN (with the sign of y) if x is a NaN. On implementations that
13620 represent a signed zero but do not treat negative zero consistently in arithmetic
13621 operations, the copysign functions regard the sign of zero as positive.
13622 <p><b>Returns</b>
13624 The copysign functions return a value with the magnitude of x and the sign of y.
13625 <!--page 274 -->
13629 <p><b>Synopsis</b>
13631 <pre>
13633 double nan(const char *tagp);
13634 float nanf(const char *tagp);
13635 long double nanl(const char *tagp);
13636 </pre>
13637 <p><b>Description</b>
13643 NULL). Calls to nanf and nanl are equivalent to the corresponding calls to strtof
13644 and strtold.
13645 <p><b>Returns</b>
13647 The nan functions return a quiet NaN, if available, with content indicated through tagp.
13648 If the implementation does not support quiet NaNs, the functions return zero.
13649 <p><b> Forward references</b>: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
13653 <p><b>Synopsis</b>
13655 <pre>
13657 double nextafter(double x, double y);
13658 float nextafterf(float x, float y);
13659 long double nextafterl(long double x, long double y);
13660 </pre>
13661 <p><b>Description</b>
13663 The nextafter functions determine the next representable value, in the type of the
13664 function, after x in the direction of y, where x and y are first converted to the type of the
13665 function.<sup><a href="#note240"><b>240)</b></a></sup> The nextafter functions return y if x equals y. A range error may occur
13666 if the magnitude of x is the largest finite value representable in the type and the result is
13667 infinite or not representable in the type.
13668 <p><b>Returns</b>
13670 The nextafter functions return the next representable value in the specified format
13671 after x in the direction of y.
13674 <!--page 275 -->
13676 <p><b>Footnotes</b>
13677 <p><small><a name="note240" href="#note240">240)</a> The argument values are converted to the type of the function, even by a macro implementation of the
13678 function.
13679 </small>
13683 <p><b>Synopsis</b>
13685 <pre>
13687 double nexttoward(double x, long double y);
13688 float nexttowardf(float x, long double y);
13689 long double nexttowardl(long double x, long double y);
13690 </pre>
13691 <p><b>Description</b>
13693 The nexttoward functions are equivalent to the nextafter functions except that the
13694 second parameter has type long double and the functions return y converted to the
13697 <p><b>Footnotes</b>
13698 <p><small><a name="note241" href="#note241">241)</a> The result of the nexttoward functions is determined in the type of the function, without loss of
13699 range or precision in a floating second argument.
13700 </small>
13703 <h4><a name="7.12.12" href="#7.12.12">7.12.12 Maximum, minimum, and positive difference functions</a></h4>
13707 <p><b>Synopsis</b>
13709 <pre>
13711 double fdim(double x, double y);
13712 float fdimf(float x, float y);
13713 long double fdiml(long double x, long double y);
13714 </pre>
13715 <p><b>Description</b>
13717 The fdim functions determine the positive difference between their arguments:
13718 <pre>
13719 {x - y if x > y
13720 {
13721 {+0 if x <= y
13722 </pre>
13723 A range error may occur.
13724 <p><b>Returns</b>
13726 The fdim functions return the positive difference value.
13730 <p><b>Synopsis</b>
13732 <pre>
13734 double fmax(double x, double y);
13735 float fmaxf(float x, float y);
13736 long double fmaxl(long double x, long double y);
13737 </pre>
13741 <!--page 276 -->
13742 <p><b>Description</b>
13744 The fmax functions determine the maximum numeric value of their arguments.<sup><a href="#note242"><b>242)</b></a></sup>
13745 <p><b>Returns</b>
13747 The fmax functions return the maximum numeric value of their arguments.
13749 <p><b>Footnotes</b>
13750 <p><small><a name="note242" href="#note242">242)</a> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
13752 </small>
13756 <p><b>Synopsis</b>
13758 <pre>
13760 double fmin(double x, double y);
13761 float fminf(float x, float y);
13762 long double fminl(long double x, long double y);
13763 </pre>
13764 <p><b>Description</b>
13766 The fmin functions determine the minimum numeric value of their arguments.<sup><a href="#note243"><b>243)</b></a></sup>
13767 <p><b>Returns</b>
13769 The fmin functions return the minimum numeric value of their arguments.
13771 <p><b>Footnotes</b>
13772 <p><small><a name="note243" href="#note243">243)</a> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
13773 </small>
13780 <p><b>Synopsis</b>
13782 <pre>
13784 double fma(double x, double y, double z);
13785 float fmaf(float x, float y, float z);
13786 long double fmal(long double x, long double y,
13787 long double z);
13788 </pre>
13789 <p><b>Description</b>
13791 The fma functions compute (x y) + z, rounded as one ternary operation: they compute
13792 the value (as if) to infinite precision and round once to the result format, according to the
13793 current rounding mode. A range error may occur.
13794 <p><b>Returns</b>
13796 The fma functions return (x y) + z, rounded as one ternary operation.
13801 <!--page 277 -->
13806 The relational and equality operators support the usual mathematical relationships
13807 between numeric values. For any ordered pair of numeric values exactly one of the
13808 relationships -- less, greater, and equal -- is true. Relational operators may raise the
13809 ''invalid'' floating-point exception when argument values are NaNs. For a NaN and a
13810 numeric value, or for two NaNs, just the unordered relationship is true.<sup><a href="#note244"><b>244)</b></a></sup> The following
13811 subclauses provide macros that are quiet (non floating-point exception raising) versions
13812 of the relational operators, and other comparison macros that facilitate writing efficient
13813 code that accounts for NaNs without suffering the ''invalid'' floating-point exception. In
13814 the synopses in this subclause, real-floating indicates that the argument shall be an
13815 expression of real floating type<sup><a href="#note245"><b>245)</b></a></sup> (both arguments need not have the same type).<sup><a href="#note246"><b>246)</b></a></sup>
13817 <p><b>Footnotes</b>
13818 <p><small><a name="note244" href="#note244">244)</a> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
13819 the operands compare unordered, as an error indicator for programs written without consideration of
13820 NaNs; the result in these cases is false.
13821 </small>
13822 <p><small><a name="note245" href="#note245">245)</a> If any argument is of integer type, or any other type that is not a real floating type, the behavior is
13823 undefined.
13824 </small>
13825 <p><small><a name="note246" href="#note246">246)</a> Whether an argument represented in a format wider than its semantic type is converted to the semantic
13826 type is unspecified.
13827 </small>
13831 <p><b>Synopsis</b>
13833 <pre>
13835 int isgreater(real-floating x, real-floating y);
13836 </pre>
13837 <p><b>Description</b>
13839 The isgreater macro determines whether its first argument is greater than its second
13840 argument. The value of isgreater(x, y) is always equal to (x) > (y); however,
13841 unlike (x) > (y), isgreater(x, y) does not raise the ''invalid'' floating-point
13842 exception when x and y are unordered.
13843 <p><b>Returns</b>
13845 The isgreater macro returns the value of (x) > (y).
13849 <p><b>Synopsis</b>
13851 <pre>
13853 int isgreaterequal(real-floating x, real-floating y);
13854 </pre>
13859 <!--page 278 -->
13860 <p><b>Description</b>
13862 The isgreaterequal macro determines whether its first argument is greater than or
13863 equal to its second argument. The value of isgreaterequal(x, y) is always equal
13864 to (x) >= (y); however, unlike (x) >= (y), isgreaterequal(x, y) does
13865 not raise the ''invalid'' floating-point exception when x and y are unordered.
13866 <p><b>Returns</b>
13868 The isgreaterequal macro returns the value of (x) >= (y).
13872 <p><b>Synopsis</b>
13874 <pre>
13876 int isless(real-floating x, real-floating y);
13877 </pre>
13878 <p><b>Description</b>
13880 The isless macro determines whether its first argument is less than its second
13881 argument. The value of isless(x, y) is always equal to (x) < (y); however,
13882 unlike (x) < (y), isless(x, y) does not raise the ''invalid'' floating-point
13883 exception when x and y are unordered.
13884 <p><b>Returns</b>
13886 The isless macro returns the value of (x) < (y).
13890 <p><b>Synopsis</b>
13892 <pre>
13894 int islessequal(real-floating x, real-floating y);
13895 </pre>
13896 <p><b>Description</b>
13898 The islessequal macro determines whether its first argument is less than or equal to
13899 its second argument. The value of islessequal(x, y) is always equal to
13900 (x) <= (y); however, unlike (x) <= (y), islessequal(x, y) does not raise
13901 the ''invalid'' floating-point exception when x and y are unordered.
13902 <p><b>Returns</b>
13904 The islessequal macro returns the value of (x) <= (y).
13905 <!--page 279 -->
13909 <p><b>Synopsis</b>
13911 <pre>
13913 int islessgreater(real-floating x, real-floating y);
13914 </pre>
13915 <p><b>Description</b>
13917 The islessgreater macro determines whether its first argument is less than or
13918 greater than its second argument. The islessgreater(x, y) macro is similar to
13919 (x) < (y) || (x) > (y); however, islessgreater(x, y) does not raise
13920 the ''invalid'' floating-point exception when x and y are unordered (nor does it evaluate x
13921 and y twice).
13922 <p><b>Returns</b>
13924 The islessgreater macro returns the value of (x) < (y) || (x) > (y).
13928 <p><b>Synopsis</b>
13930 <pre>
13932 int isunordered(real-floating x, real-floating y);
13933 </pre>
13934 <p><b>Description</b>
13936 The isunordered macro determines whether its arguments are unordered.
13937 <p><b>Returns</b>
13939 The isunordered macro returns 1 if its arguments are unordered and 0 otherwise.
13940 <!--page 280 -->
13945 The header <a href="#7.13"><setjmp.h></a> defines the macro setjmp, and declares one function and
13946 one type, for bypassing the normal function call and return discipline.<sup><a href="#note247"><b>247)</b></a></sup>
13948 The type declared is
13949 <pre>
13950 jmp_buf
13951 </pre>
13952 which is an array type suitable for holding the information needed to restore a calling
13953 environment. The environment of a call to the setjmp macro consists of information
13954 sufficient for a call to the longjmp function to return execution to the correct block and
13955 invocation of that block, were it called recursively. It does not include the state of the
13956 floating-point status flags, of open files, or of any other component of the abstract
13957 machine.
13959 It is unspecified whether setjmp is a macro or an identifier declared with external
13960 linkage. If a macro definition is suppressed in order to access an actual function, or a
13961 program defines an external identifier with the name setjmp, the behavior is undefined.
13963 <p><b>Footnotes</b>
13964 <p><small><a name="note247" href="#note247">247)</a> These functions are useful for dealing with unusual conditions encountered in a low-level function of
13965 a program.
13966 </small>
13973 <p><b>Synopsis</b>
13975 <pre>
13977 int setjmp(jmp_buf env);
13978 </pre>
13979 <p><b>Description</b>
13981 The setjmp macro saves its calling environment in its jmp_buf argument for later use
13982 by the longjmp function.
13983 <p><b>Returns</b>
13985 If the return is from a direct invocation, the setjmp macro returns the value zero. If the
13986 return is from a call to the longjmp function, the setjmp macro returns a nonzero
13987 value.
13988 <p><b>Environmental limits</b>
13990 An invocation of the setjmp macro shall appear only in one of the following contexts:
13991 <ul>
13992 <li> the entire controlling expression of a selection or iteration statement;
13993 <li> one operand of a relational or equality operator with the other operand an integer
13994 constant expression, with the resulting expression being the entire controlling
13997 <!--page 281 -->
13998 expression of a selection or iteration statement;
13999 <li> the operand of a unary ! operator with the resulting expression being the entire
14000 controlling expression of a selection or iteration statement; or
14001 <li> the entire expression of an expression statement (possibly cast to void).
14002 </ul>
14004 If the invocation appears in any other context, the behavior is undefined.
14011 <p><b>Synopsis</b>
14013 <pre>
14015 _Noreturn void longjmp(jmp_buf env, int val);
14016 </pre>
14017 <p><b>Description</b>
14019 The longjmp function restores the environment saved by the most recent invocation of
14020 the setjmp macro in the same invocation of the program with the corresponding
14021 jmp_buf argument. If there has been no such invocation, or if the invocation was from
14022 another thread of execution, or if the function containing the invocation of the setjmp
14023 macro has terminated execution<sup><a href="#note248"><b>248)</b></a></sup> in the interim, or if the invocation of the setjmp
14024 macro was within the scope of an identifier with variably modified type and execution has
14025 left that scope in the interim, the behavior is undefined.
14027 All accessible objects have values, and all other components of the abstract machine<sup><a href="#note249"><b>249)</b></a></sup>
14028 have state, as of the time the longjmp function was called, except that the values of
14029 objects of automatic storage duration that are local to the function containing the
14030 invocation of the corresponding setjmp macro that do not have volatile-qualified type
14031 and have been changed between the setjmp invocation and longjmp call are
14032 indeterminate.
14033 <p><b>Returns</b>
14035 After longjmp is completed, thread execution continues as if the corresponding
14036 invocation of the setjmp macro had just returned the value specified by val. The
14037 longjmp function cannot cause the setjmp macro to return the value 0; if val is 0,
14038 the setjmp macro returns the value 1.
14040 EXAMPLE The longjmp function that returns control back to the point of the setjmp invocation
14041 might cause memory associated with a variable length array object to be squandered.
14045 <!--page 282 -->
14046 <!--page 283 -->
14047 <pre>
14049 jmp_buf buf;
14050 void g(int n);
14051 void h(int n);
14052 int n = 6;
14053 void f(void)
14054 {
14055 int x[n]; // valid: f is not terminated
14056 setjmp(buf);
14057 g(n);
14058 }
14059 void g(int n)
14060 {
14061 int a[n]; // a may remain allocated
14062 h(n);
14063 }
14064 void h(int n)
14065 {
14066 int b[n]; // b may remain allocated
14067 longjmp(buf, 2); // might cause memory loss
14068 }
14069 </pre>
14071 <p><b>Footnotes</b>
14072 <p><small><a name="note248" href="#note248">248)</a> For example, by executing a return statement or because another longjmp call has caused a
14073 transfer to a setjmp invocation in a function earlier in the set of nested calls.
14074 </small>
14075 <p><small><a name="note249" href="#note249">249)</a> This includes, but is not limited to, the floating-point status flags and the state of open files.
14076 </small>
14081 The header <a href="#7.14"><signal.h></a> declares a type and two functions and defines several macros,
14082 for handling various signals (conditions that may be reported during program execution).
14084 The type defined is
14085 <pre>
14086 sig_atomic_t
14087 </pre>
14088 which is the (possibly volatile-qualified) integer type of an object that can be accessed as
14089 an atomic entity, even in the presence of asynchronous interrupts.
14091 The macros defined are
14092 <pre>
14093 SIG_DFL
14094 SIG_ERR
14095 SIG_IGN
14096 </pre>
14097 which expand to constant expressions with distinct values that have type compatible with
14098 the second argument to, and the return value of, the signal function, and whose values
14099 compare unequal to the address of any declarable function; and the following, which
14100 expand to positive integer constant expressions with type int and distinct values that are
14101 the signal numbers, each corresponding to the specified condition:
14102 <pre>
14103 SIGABRT abnormal termination, such as is initiated by the abort function
14104 SIGFPE an erroneous arithmetic operation, such as zero divide or an operation
14105 resulting in overflow
14106 SIGILL detection of an invalid function image, such as an invalid instruction
14107 SIGINT receipt of an interactive attention signal
14108 SIGSEGV an invalid access to storage
14109 SIGTERM a termination request sent to the program
14110 </pre>
14112 An implementation need not generate any of these signals, except as a result of explicit
14113 calls to the raise function. Additional signals and pointers to undeclarable functions,
14114 with macro definitions beginning, respectively, with the letters SIG and an uppercase
14115 letter or with SIG_ and an uppercase letter,<sup><a href="#note250"><b>250)</b></a></sup> may also be specified by the
14116 implementation. The complete set of signals, their semantics, and their default handling
14117 is implementation-defined; all signal numbers shall be positive.
14122 <!--page 284 -->
14124 <p><b>Footnotes</b>
14125 <p><small><a name="note250" href="#note250">250)</a> See ''future library directions'' (<a href="#7.31.7">7.31.7</a>). The names of the signal numbers reflect the following terms
14126 (respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
14127 and termination.
14128 </small>
14135 <p><b>Synopsis</b>
14137 <pre>
14139 void (*signal(int sig, void (*func)(int)))(int);
14140 </pre>
14141 <p><b>Description</b>
14143 The signal function chooses one of three ways in which receipt of the signal number
14144 sig is to be subsequently handled. If the value of func is SIG_DFL, default handling
14145 for that signal will occur. If the value of func is SIG_IGN, the signal will be ignored.
14146 Otherwise, func shall point to a function to be called when that signal occurs. An
14147 invocation of such a function because of a signal, or (recursively) of any further functions
14148 called by that invocation (other than functions in the standard library),<sup><a href="#note251"><b>251)</b></a></sup> is called a
14149 signal handler.
14151 When a signal occurs and func points to a function, it is implementation-defined
14152 whether the equivalent of signal(sig, SIG_DFL); is executed or the
14153 implementation prevents some implementation-defined set of signals (at least including
14154 sig) from occurring until the current signal handling has completed; in the case of
14155 SIGILL, the implementation may alternatively define that no action is taken. Then the
14156 equivalent of (*func)(sig); is executed. If and when the function returns, if the
14157 value of sig is SIGFPE, SIGILL, SIGSEGV, or any other implementation-defined
14158 value corresponding to a computational exception, the behavior is undefined; otherwise
14159 the program will resume execution at the point it was interrupted.
14161 If the signal occurs as the result of calling the abort or raise function, the signal
14162 handler shall not call the raise function.
14164 If the signal occurs other than as the result of calling the abort or raise function, the
14165 behavior is undefined if the signal handler refers to any object with static or thread
14166 storage duration that is not a lock-free atomic object other than by assigning a value to an
14167 object declared as volatile sig_atomic_t, or the signal handler calls any function
14168 in the standard library other than the abort function, the _Exit function, the
14169 quick_exit function, or the signal function with the first argument equal to the
14170 signal number corresponding to the signal that caused the invocation of the handler.
14171 Furthermore, if such a call to the signal function results in a SIG_ERR return, the
14175 <!--page 285 -->
14177 At program startup, the equivalent of
14178 <pre>
14179 signal(sig, SIG_IGN);
14180 </pre>
14181 may be executed for some signals selected in an implementation-defined manner; the
14182 equivalent of
14183 <pre>
14184 signal(sig, SIG_DFL);
14185 </pre>
14186 is executed for all other signals defined by the implementation.
14188 Use of this function in a multi-threaded program results in undefined behavior. The
14189 implementation shall behave as if no library function calls the signal function.
14190 <p><b>Returns</b>
14192 If the request can be honored, the signal function returns the value of func for the
14193 most recent successful call to signal for the specified signal sig. Otherwise, a value of
14194 SIG_ERR is returned and a positive value is stored in errno.
14195 <p><b> Forward references</b>: the abort function (<a href="#7.22.4.1">7.22.4.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the
14196 _Exit function (<a href="#7.22.4.5">7.22.4.5</a>), the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
14198 <p><b>Footnotes</b>
14199 <p><small><a name="note251" href="#note251">251)</a> This includes functions called indirectly via standard library functions (e.g., a SIGABRT handler
14200 called via the abort function).
14201 </small>
14202 <p><small><a name="note252" href="#note252">252)</a> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
14203 </small>
14210 <p><b>Synopsis</b>
14212 <pre>
14214 int raise(int sig);
14215 </pre>
14216 <p><b>Description</b>
14218 The raise function carries out the actions described in <a href="#7.14.1.1">7.14.1.1</a> for the signal sig. If a
14219 signal handler is called, the raise function shall not return until after the signal handler
14220 does.
14221 <p><b>Returns</b>
14223 The raise function returns zero if successful, nonzero if unsuccessful.
14224 <!--page 286 -->
14231 The macro
14232 <pre>
14233 alignas
14234 </pre>
14235 expands to _Alignas; the macro
14236 <pre>
14237 alignof
14238 </pre>
14239 expands to _Alignof.
14241 The remaining macros are suitable for use in #if preprocessing directives. They are
14242 <pre>
14243 __alignas_is_defined
14244 </pre>
14245 and
14246 <pre>
14247 __alignof_is_defined
14248 </pre>
14249 which both expand to the integer constant 1.
14250 <!--page 287 -->
14255 The header <a href="#7.16"><stdarg.h></a> declares a type and defines four macros, for advancing
14256 through a list of arguments whose number and types are not known to the called function
14257 when it is translated.
14259 A function may be called with a variable number of arguments of varying types. As
14260 described in <a href="#6.9.1">6.9.1</a>, its parameter list contains one or more parameters. The rightmost
14261 parameter plays a special role in the access mechanism, and will be designated parmN in
14262 this description.
14264 The type declared is
14265 <pre>
14266 va_list
14267 </pre>
14268 which is a complete object type suitable for holding information needed by the macros
14269 va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
14270 desired, the called function shall declare an object (generally referred to as ap in this
14271 subclause) having type va_list. The object ap may be passed as an argument to
14272 another function; if that function invokes the va_arg macro with parameter ap, the
14273 value of ap in the calling function is indeterminate and shall be passed to the va_end
14276 <p><b>Footnotes</b>
14277 <p><small><a name="note253" href="#note253">253)</a> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
14278 case the original function may make further use of the original list after the other function returns.
14279 </small>
14284 The va_start and va_arg macros described in this subclause shall be implemented
14285 as macros, not functions. It is unspecified whether va_copy and va_end are macros or
14286 identifiers declared with external linkage. If a macro definition is suppressed in order to
14287 access an actual function, or a program defines an external identifier with the same name,
14288 the behavior is undefined. Each invocation of the va_start and va_copy macros
14289 shall be matched by a corresponding invocation of the va_end macro in the same
14290 function.
14294 <p><b>Synopsis</b>
14296 <pre>
14298 type va_arg(va_list ap, type);
14299 </pre>
14300 <p><b>Description</b>
14302 The va_arg macro expands to an expression that has the specified type and the value of
14303 the next argument in the call. The parameter ap shall have been initialized by the
14304 va_start or va_copy macro (without an intervening invocation of the va_end
14306 <!--page 288 -->
14307 macro for the same ap). Each invocation of the va_arg macro modifies ap so that the
14308 values of successive arguments are returned in turn. The parameter type shall be a type
14309 name specified such that the type of a pointer to an object that has the specified type can
14310 be obtained simply by postfixing a * to type. If there is no actual next argument, or if
14311 type is not compatible with the type of the actual next argument (as promoted according
14312 to the default argument promotions), the behavior is undefined, except for the following
14313 cases:
14314 <ul>
14315 <li> one type is a signed integer type, the other type is the corresponding unsigned integer
14316 type, and the value is representable in both types;
14317 <li> one type is pointer to void and the other is a pointer to a character type.
14318 </ul>
14319 <p><b>Returns</b>
14321 The first invocation of the va_arg macro after that of the va_start macro returns the
14322 value of the argument after that specified by parmN . Successive invocations return the
14323 values of the remaining arguments in succession.
14327 <p><b>Synopsis</b>
14329 <pre>
14331 void va_copy(va_list dest, va_list src);
14332 </pre>
14333 <p><b>Description</b>
14335 The va_copy macro initializes dest as a copy of src, as if the va_start macro had
14336 been applied to dest followed by the same sequence of uses of the va_arg macro as
14337 had previously been used to reach the present state of src. Neither the va_copy nor
14338 va_start macro shall be invoked to reinitialize dest without an intervening
14339 invocation of the va_end macro for the same dest.
14340 <p><b>Returns</b>
14342 The va_copy macro returns no value.
14346 <p><b>Synopsis</b>
14348 <pre>
14350 void va_end(va_list ap);
14351 </pre>
14352 <p><b>Description</b>
14354 The va_end macro facilitates a normal return from the function whose variable
14355 argument list was referred to by the expansion of the va_start macro, or the function
14356 containing the expansion of the va_copy macro, that initialized the va_list ap. The
14357 va_end macro may modify ap so that it is no longer usable (without being reinitialized
14358 <!--page 289 -->
14359 by the va_start or va_copy macro). If there is no corresponding invocation of the
14360 va_start or va_copy macro, or if the va_end macro is not invoked before the
14361 return, the behavior is undefined.
14362 <p><b>Returns</b>
14364 The va_end macro returns no value.
14368 <p><b>Synopsis</b>
14370 <pre>
14372 void va_start(va_list ap, parmN);
14373 </pre>
14374 <p><b>Description</b>
14376 The va_start macro shall be invoked before any access to the unnamed arguments.
14378 The va_start macro initializes ap for subsequent use by the va_arg and va_end
14379 macros. Neither the va_start nor va_copy macro shall be invoked to reinitialize ap
14380 without an intervening invocation of the va_end macro for the same ap.
14382 The parameter parmN is the identifier of the rightmost parameter in the variable
14383 parameter list in the function definition (the one just before the , ...). If the parameter
14384 parmN is declared with the register storage class, with a function or array type, or
14385 with a type that is not compatible with the type that results after application of the default
14386 argument promotions, the behavior is undefined.
14387 <p><b>Returns</b>
14389 The va_start macro returns no value.
14391 EXAMPLE 1 The function f1 gathers into an array a list of arguments that are pointers to strings (but not
14392 more than MAXARGS arguments), then passes the array as a single argument to function f2. The number of
14393 pointers is specified by the first argument to f1.
14394 <!--page 290 -->
14395 <pre>
14397 #define MAXARGS 31
14398 void f1(int n_ptrs, ...)
14399 {
14400 va_list ap;
14401 char *array[MAXARGS];
14402 int ptr_no = 0;
14403 if (n_ptrs > MAXARGS)
14404 n_ptrs = MAXARGS;
14405 va_start(ap, n_ptrs);
14406 while (ptr_no < n_ptrs)
14407 array[ptr_no++] = va_arg(ap, char *);
14408 va_end(ap);
14409 f2(n_ptrs, array);
14410 }
14411 </pre>
14412 Each call to f1 is required to have visible the definition of the function or a declaration such as
14413 <pre>
14414 void f1(int, ...);
14415 </pre>
14418 EXAMPLE 2 The function f3 is similar, but saves the status of the variable argument list after the
14419 indicated number of arguments; after f2 has been called once with the whole list, the trailing part of the list
14420 is gathered again and passed to function f4.
14421 <!--page 291 -->
14422 <pre>
14424 #define MAXARGS 31
14425 void f3(int n_ptrs, int f4_after, ...)
14426 {
14427 va_list ap, ap_save;
14428 char *array[MAXARGS];
14429 int ptr_no = 0;
14430 if (n_ptrs > MAXARGS)
14431 n_ptrs = MAXARGS;
14432 va_start(ap, f4_after);
14433 while (ptr_no < n_ptrs) {
14434 array[ptr_no++] = va_arg(ap, char *);
14435 if (ptr_no == f4_after)
14436 va_copy(ap_save, ap);
14437 }
14438 va_end(ap);
14439 f2(n_ptrs, array);
14440 // Now process the saved copy.
14441 n_ptrs -= f4_after;
14442 ptr_no = 0;
14443 while (ptr_no < n_ptrs)
14444 array[ptr_no++] = va_arg(ap_save, char *);
14445 va_end(ap_save);
14446 f4(n_ptrs, array);
14447 }
14448 </pre>
14456 The header <a href="#7.17"><stdatomic.h></a> defines several macros and declares several types and
14457 functions for performing atomic operations on data shared between threads.<sup><a href="#note254"><b>254)</b></a></sup>
14459 Implementations that define the macro __STDC_NO_ATOMICS__ need not provide
14460 this header nor support any of its facilities.
14462 The macros defined are the atomic lock-free macros
14463 <pre>
14464 ATOMIC_BOOL_LOCK_FREE
14465 ATOMIC_CHAR_LOCK_FREE
14466 ATOMIC_CHAR16_T_LOCK_FREE
14467 ATOMIC_CHAR32_T_LOCK_FREE
14468 ATOMIC_WCHAR_T_LOCK_FREE
14469 ATOMIC_SHORT_LOCK_FREE
14470 ATOMIC_INT_LOCK_FREE
14471 ATOMIC_LONG_LOCK_FREE
14472 ATOMIC_LLONG_LOCK_FREE
14473 ATOMIC_POINTER_LOCK_FREE
14474 </pre>
14475 which indicate the lock-free property of the corresponding atomic types (both signed and
14476 unsigned); and
14477 <pre>
14478 ATOMIC_FLAG_INIT
14479 </pre>
14480 which expands to an initializer for an object of type atomic_flag.
14482 The types include
14483 <pre>
14484 memory_order
14485 </pre>
14486 which is an enumerated type whose enumerators identify memory ordering constraints;
14487 <pre>
14488 atomic_flag
14489 </pre>
14490 which is a structure type representing a lock-free, primitive atomic flag; and several
14491 atomic analogs of integer types.
14493 In the following synopses:
14494 <ul>
14495 <li> An A refers to one of the atomic types.
14496 <li> A C refers to its corresponding non-atomic type.
14497 <li> An M refers to the type of the other argument for arithmetic operations. For atomic
14498 integer types, M is C. For atomic pointer types, M is ptrdiff_t.
14500 <!--page 292 -->
14501 <li> The functions not ending in _explicit have the same semantics as the
14502 corresponding _explicit function with memory_order_seq_cst for the
14503 memory_order argument.
14504 </ul>
14506 NOTE Many operations are volatile-qualified. The ''volatile as device register'' semantics have not
14507 changed in the standard. This qualification means that volatility is preserved when applying these
14508 operations to volatile objects.
14511 <p><b>Footnotes</b>
14512 <p><small><a name="note254" href="#note254">254)</a> See ''future library directions'' (<a href="#7.31.8">7.31.8</a>).
14513 </small>
14520 <p><b>Synopsis</b>
14522 <pre>
14524 #define ATOMIC_VAR_INIT(C value)
14525 </pre>
14526 <p><b>Description</b>
14528 The ATOMIC_VAR_INIT macro expands to a token sequence suitable for initializing an
14529 atomic object of a type that is initialization-compatible with value. An atomic object
14530 with automatic storage duration that is not explicitly initialized using
14531 ATOMIC_VAR_INIT is initially in an indeterminate state; however, the default (zero)
14532 initialization for objects with static or thread-local storage duration is guaranteed to
14533 produce a valid state.
14535 Concurrent access to the variable being initialized, even via an atomic operation,
14536 constitutes a data race.
14538 EXAMPLE
14539 <pre>
14540 atomic_int guide = ATOMIC_VAR_INIT(42);
14541 </pre>
14546 <p><b>Synopsis</b>
14548 <pre>
14550 void atomic_init(volatile A *obj, C value);
14551 </pre>
14552 <p><b>Description</b>
14554 The atomic_init generic function initializes the atomic object pointed to by obj to
14555 the value value, while also initializing any additional state that the implementation
14556 might need to carry for the atomic object.
14558 Although this function initializes an atomic object, it does not avoid data races;
14559 concurrent access to the variable being initialized, even via an atomic operation,
14560 constitutes a data race.
14561 <!--page 293 -->
14562 <p><b>Returns</b>
14564 The atomic_init generic function returns no value.
14566 EXAMPLE
14567 <pre>
14568 atomic_int guide;
14569 atomic_init(&guide, 42);
14570 </pre>
14576 The enumerated type memory_order specifies the detailed regular (non-atomic)
14577 memory synchronization operations as defined in <a href="#5.1.2.4">5.1.2.4</a> and may provide for operation
14578 ordering. Its enumeration constants are as follows:<sup><a href="#note255"><b>255)</b></a></sup>
14579 <pre>
14580 memory_order_relaxed
14581 memory_order_consume
14582 memory_order_acquire
14583 memory_order_release
14584 memory_order_acq_rel
14585 memory_order_seq_cst
14586 </pre>
14588 For memory_order_relaxed, no operation orders memory.
14590 For memory_order_release, memory_order_acq_rel, and
14591 memory_order_seq_cst, a store operation performs a release operation on the
14592 affected memory location.
14594 For memory_order_acquire, memory_order_acq_rel, and
14595 memory_order_seq_cst, a load operation performs an acquire operation on the
14596 affected memory location.
14598 For memory_order_consume, a load operation performs a consume operation on the
14599 affected memory location.
14601 There shall be a single total order S on all memory_order_seq_cst operations,
14602 consistent with the ''happens before'' order and modification orders for all affected
14603 locations, such that each memory_order_seq_cst operation B that loads a value
14604 from an atomic object M observes one of the following values:
14605 <ul>
14606 <li> the result of the last modification A of M that precedes B in S, if it exists, or
14607 <li> if A exists, the result of some modification of M in the visible sequence of side
14608 effects with respect to B that is not memory_order_seq_cst and that does not
14609 happen before A, or
14614 <!--page 294 -->
14615 <li> if A does not exist, the result of some modification of M in the visible sequence of
14616 side effects with respect to B that is not memory_order_seq_cst.
14617 </ul>
14619 NOTE 1 Although it is not explicitly required that S include lock operations, it can always be extended to
14620 an order that does include lock and unlock operations, since the ordering between those is already included
14621 in the ''happens before'' ordering.
14624 NOTE 2 Atomic operations specifying memory_order_relaxed are relaxed only with respect to
14625 memory ordering. Implementations must still guarantee that any given atomic access to a particular atomic
14626 object be indivisible with respect to all other atomic accesses to that object.
14629 For an atomic operation B that reads the value of an atomic object M, if there is a
14630 memory_order_seq_cst fence X sequenced before B, then B observes either the
14631 last memory_order_seq_cst modification of M preceding X in the total order S or
14632 a later modification of M in its modification order.
14634 For atomic operations A and B on an atomic object M, where A modifies M and B takes
14635 its value, if there is a memory_order_seq_cst fence X such that A is sequenced
14636 before X and B follows X in S, then B observes either the effects of A or a later
14637 modification of M in its modification order.
14639 For atomic operations A and B on an atomic object M, where A modifies M and B takes
14640 its value, if there are memory_order_seq_cst fences X and Y such that A is
14641 sequenced before X, Y is sequenced before B, and X precedes Y in S, then B observes
14642 either the effects of A or a later modification of M in its modification order.
14644 Atomic read-modify-write operations shall always read the last value (in the modification
14645 order) stored before the write associated with the read-modify-write operation.
14647 An atomic store shall only store a value that has been computed from constants and
14648 program input values by a finite sequence of program evaluations, such that each
14649 evaluation observes the values of variables as computed by the last prior assignment in
14650 the sequence.<sup><a href="#note256"><b>256)</b></a></sup> The ordering of evaluations in this sequence shall be such that
14651 <ul>
14652 <li> If an evaluation B observes a value computed by A in a different thread, then B does
14653 not happen before A.
14654 <li> If an evaluation A is included in the sequence, then all evaluations that assign to the
14655 same variable and happen before A are also included.
14656 </ul>
14658 NOTE 3 The second requirement disallows ''out-of-thin-air'', or ''speculative'' stores of atomics when
14659 relaxed atomics are used. Since unordered operations are involved, evaluations may appear in this
14660 sequence out of thread order. For example, with x and y initially zero,
14665 <!--page 295 -->
14666 <pre>
14667 // Thread 1:
14668 r1 = atomic_load_explicit(&y, memory_order_relaxed);
14669 atomic_store_explicit(&x, r1, memory_order_relaxed);
14671 // Thread 2:
14672 r2 = atomic_load_explicit(&x, memory_order_relaxed);
14673 atomic_store_explicit(&y, 42, memory_order_relaxed);
14674 </pre>
14675 is allowed to produce r1 == 42 && r2 == 42. The sequence of evaluations justifying this consists of:
14676 <pre>
14677 atomic_store_explicit(&y, 42, memory_order_relaxed);
14678 r1 = atomic_load_explicit(&y, memory_order_relaxed);
14679 atomic_store_explicit(&x, r1, memory_order_relaxed);
14680 r2 = atomic_load_explicit(&x, memory_order_relaxed);
14681 </pre>
14682 On the other hand,
14683 <pre>
14684 // Thread 1:
14685 r1 = atomic_load_explicit(&y, memory_order_relaxed);
14686 atomic_store_explicit(&x, r1, memory_order_relaxed);
14688 // Thread 2:
14689 r2 = atomic_load_explicit(&x, memory_order_relaxed);
14690 atomic_store_explicit(&y, r2, memory_order_relaxed);
14691 </pre>
14692 is not allowed to produce r1 == 42 && r2 = 42, since there is no sequence of evaluations that results
14693 in the computation of 42. In the absence of ''relaxed'' operations and read-modify-write operations with
14694 weaker than memory_order_acq_rel ordering, the second requirement has no impact.
14696 <p><b>Recommended practice</b>
14698 The requirements do not forbid r1 == 42 && r2 == 42 in the following example,
14699 with x and y initially zero:
14700 <pre>
14701 // Thread 1:
14702 r1 = atomic_load_explicit(&x, memory_order_relaxed);
14703 if (r1 == 42)
14704 atomic_store_explicit(&y, r1, memory_order_relaxed);
14706 // Thread 2:
14707 r2 = atomic_load_explicit(&y, memory_order_relaxed);
14708 if (r2 == 42)
14709 atomic_store_explicit(&x, 42, memory_order_relaxed);
14710 </pre>
14711 However, this is not useful behavior, and implementations should not allow it.
14713 Implementations should make atomic stores visible to atomic loads within a reasonable
14714 amount of time.
14715 <!--page 296 -->
14717 <p><b>Footnotes</b>
14718 <p><small><a name="note255" href="#note255">255)</a> See ''future library directions'' (<a href="#7.31.8">7.31.8</a>).
14719 </small>
14720 <p><small><a name="note256" href="#note256">256)</a> Among other implications, atomic variables shall not decay.
14721 </small>
14725 <p><b>Synopsis</b>
14727 <pre>
14729 type kill_dependency(type y);
14730 </pre>
14731 <p><b>Description</b>
14733 The kill_dependency macro terminates a dependency chain; the argument does not
14734 carry a dependency to the return value.
14735 <p><b>Returns</b>
14737 The kill_dependency macro returns the value of y.
14742 This subclause introduces synchronization primitives called fences. Fences can have
14743 acquire semantics, release semantics, or both. A fence with acquire semantics is called
14744 an acquire fence; a fence with release semantics is called a release fence.
14746 A release fence A synchronizes with an acquire fence B if there exist atomic operations
14747 X and Y , both operating on some atomic object M, such that A is sequenced before X, X
14748 modifies M, Y is sequenced before B, and Y reads the value written by X or a value
14749 written by any side effect in the hypothetical release sequence X would head if it were a
14750 release operation.
14752 A release fence A synchronizes with an atomic operation B that performs an acquire
14753 operation on an atomic object M if there exists an atomic operation X such that A is
14754 sequenced before X, X modifies M, and B reads the value written by X or a value written
14755 by any side effect in the hypothetical release sequence X would head if it were a release
14756 operation.
14758 An atomic operation A that is a release operation on an atomic object M synchronizes
14759 with an acquire fence B if there exists some atomic operation X on M such that X is
14760 sequenced before B and reads the value written by A or a value written by any side effect
14761 in the release sequence headed by A.
14765 <p><b>Synopsis</b>
14767 <pre>
14769 void atomic_thread_fence(memory_order order);
14770 </pre>
14771 <p><b>Description</b>
14773 Depending on the value of order, this operation:
14774 <ul>
14775 <li> has no effects, if order == memory_order_relaxed;
14776 <!--page 297 -->
14777 <li> is an acquire fence, if order == memory_order_acquire or order ==
14778 memory_order_consume;
14779 <li> is a release fence, if order == memory_order_release;
14780 <li> is both an acquire fence and a release fence, if order ==
14781 memory_order_acq_rel;
14782 <li> is a sequentially consistent acquire and release fence, if order ==
14783 memory_order_seq_cst.
14784 </ul>
14785 <p><b>Returns</b>
14787 The atomic_thread_fence function returns no value.
14791 <p><b>Synopsis</b>
14793 <pre>
14795 void atomic_signal_fence(memory_order order);
14796 </pre>
14797 <p><b>Description</b>
14799 Equivalent to atomic_thread_fence(order), except that the resulting ordering
14800 constraints are established only between a thread and a signal handler executed in the
14801 same thread.
14803 NOTE 1 The atomic_signal_fence function can be used to specify the order in which actions
14804 performed by the thread become visible to the signal handler.
14807 NOTE 2 Compiler optimizations and reorderings of loads and stores are inhibited in the same way as with
14808 atomic_thread_fence, but the hardware fence instructions that atomic_thread_fence would
14809 have inserted are not emitted.
14811 <p><b>Returns</b>
14813 The atomic_signal_fence function returns no value.
14818 The atomic lock-free macros indicate the lock-free property of integer and address atomic
14819 types. A value of 0 indicates that the type is never lock-free; a value of 1 indicates that
14820 the type is sometimes lock-free; a value of 2 indicates that the type is always lock-free.
14822 NOTE Operations that are lock-free should also be address-free. That is, atomic operations on the same
14823 memory location via two different addresses will communicate atomically. The implementation should not
14824 depend on any per-process state. This restriction enables communication via memory mapped into a
14825 process more than once and memory shared between two processes.
14826 <!--page 298 -->
14829 <h5><a name="7.17.5.1" href="#7.17.5.1">7.17.5.1 The atomic_is_lock_free generic function</a></h5>
14830 <p><b>Synopsis</b>
14832 <pre>
14834 _Bool atomic_is_lock_free(const volatile A *obj);
14835 </pre>
14836 <p><b>Description</b>
14838 The atomic_is_lock_free generic function indicates whether or not the object
14839 pointed to by obj is lock-free.
14840 <p><b>Returns</b>
14842 The atomic_is_lock_free generic function returns nonzero (true) if and only if the
14843 object's operations are lock-free. The result of a lock-free query on one object cannot be
14844 inferred from the result of a lock-free query on another object.
14849 For each line in the following table,<sup><a href="#note257"><b>257)</b></a></sup> the atomic type name is declared as a type that
14850 has the same representation and alignment requirements as the corresponding direct
14856 <!--page 299 -->
14857 <pre>
14858 Atomic type name Direct type
14860 atomic_bool _Atomic _Bool
14861 atomic_char _Atomic char
14862 atomic_schar _Atomic signed char
14863 atomic_uchar _Atomic unsigned char
14864 atomic_short _Atomic short
14865 atomic_ushort _Atomic unsigned short
14866 atomic_int _Atomic int
14867 atomic_uint _Atomic unsigned int
14868 atomic_long _Atomic long
14869 atomic_ulong _Atomic unsigned long
14870 atomic_llong _Atomic long long
14871 atomic_ullong _Atomic unsigned long long
14872 atomic_char16_t _Atomic char16_t
14873 atomic_char32_t _Atomic char32_t
14874 atomic_wchar_t _Atomic wchar_t
14875 atomic_int_least8_t _Atomic int_least8_t
14876 atomic_uint_least8_t _Atomic uint_least8_t
14877 atomic_int_least16_t _Atomic int_least16_t
14878 atomic_uint_least16_t _Atomic uint_least16_t
14879 atomic_int_least32_t _Atomic int_least32_t
14880 atomic_uint_least32_t _Atomic uint_least32_t
14881 atomic_int_least64_t _Atomic int_least64_t
14882 atomic_uint_least64_t _Atomic uint_least64_t
14883 atomic_int_fast8_t _Atomic int_fast8_t
14884 atomic_uint_fast8_t _Atomic uint_fast8_t
14885 atomic_int_fast16_t _Atomic int_fast16_t
14886 atomic_uint_fast16_t _Atomic uint_fast16_t
14887 atomic_int_fast32_t _Atomic int_fast32_t
14888 atomic_uint_fast32_t _Atomic uint_fast32_t
14889 atomic_int_fast64_t _Atomic int_fast64_t
14890 atomic_uint_fast64_t _Atomic uint_fast64_t
14891 atomic_intptr_t _Atomic intptr_t
14892 atomic_uintptr_t _Atomic uintptr_t
14893 atomic_size_t _Atomic size_t
14894 atomic_ptrdiff_t _Atomic ptrdiff_t
14895 atomic_intmax_t _Atomic intmax_t
14896 atomic_uintmax_t _Atomic uintmax_t
14897 </pre>
14900 <!--page 300 -->
14902 NOTE The representation of atomic integer types need not have the same size as their corresponding
14903 regular types. They should have the same size whenever possible, as it eases effort required to port existing
14904 code.
14907 <p><b>Footnotes</b>
14908 <p><small><a name="note257" href="#note257">257)</a> See ''future library directions'' (<a href="#7.31.8">7.31.8</a>).
14909 </small>
14910 <p><small><a name="note258" href="#note258">258)</a> The same representation and alignment requirements are meant to imply interchangeability as
14911 arguments to functions, return values from functions, and members of unions.
14912 </small>
14917 There are only a few kinds of operations on atomic types, though there are many
14918 instances of those kinds. This subclause specifies each general kind.
14922 <p><b>Synopsis</b>
14924 <pre>
14926 void atomic_store(volatile A *object, C desired);
14927 void atomic_store_explicit(volatile A *object,
14928 C desired, memory_order order);
14929 </pre>
14930 <p><b>Description</b>
14932 The order argument shall not be memory_order_acquire,
14933 memory_order_consume, nor memory_order_acq_rel. Atomically replace the
14934 value pointed to by object with the value of desired. Memory is affected according
14935 to the value of order.
14936 <p><b>Returns</b>
14938 The atomic_store generic functions return no value.
14942 <p><b>Synopsis</b>
14944 <pre>
14946 C atomic_load(volatile A *object);
14947 C atomic_load_explicit(volatile A *object,
14948 memory_order order);
14949 </pre>
14950 <p><b>Description</b>
14952 The order argument shall not be memory_order_release nor
14953 memory_order_acq_rel. Memory is affected according to the value of order.
14954 <p><b>Returns</b>
14955 Atomically returns the value pointed to by object.
14956 <!--page 301 -->
14959 <h5><a name="7.17.7.3" href="#7.17.7.3">7.17.7.3 The atomic_exchange generic functions</a></h5>
14960 <p><b>Synopsis</b>
14962 <pre>
14964 C atomic_exchange(volatile A *object, C desired);
14965 C atomic_exchange_explicit(volatile A *object,
14966 C desired, memory_order order);
14967 </pre>
14968 <p><b>Description</b>
14970 Atomically replace the value pointed to by object with desired. Memory is affected
14971 according to the value of order. These operations are read-modify-write operations
14973 <p><b>Returns</b>
14975 Atomically returns the value pointed to by object immediately before the effects.
14978 <h5><a name="7.17.7.4" href="#7.17.7.4">7.17.7.4 The atomic_compare_exchange generic functions</a></h5>
14979 <p><b>Synopsis</b>
14981 <pre>
14983 _Bool atomic_compare_exchange_strong(volatile A *object,
14984 C *expected, C desired);
14985 _Bool atomic_compare_exchange_strong_explicit(
14986 volatile A *object, C *expected, C desired,
14987 memory_order success, memory_order failure);
14988 _Bool atomic_compare_exchange_weak(volatile A *object,
14989 C *expected, C desired);
14990 _Bool atomic_compare_exchange_weak_explicit(
14991 volatile A *object, C *expected, C desired,
14992 memory_order success, memory_order failure);
14993 </pre>
14994 <p><b>Description</b>
14996 The failure argument shall not be memory_order_release nor
14997 memory_order_acq_rel. The failure argument shall be no stronger than the
14998 success argument. Atomically, compares the value pointed to by object for equality
14999 with that in expected, and if true, replaces the value pointed to by object with
15000 desired, and if false, updates the value in expected with the value pointed to by
15001 object. Further, if the comparison is true, memory is affected according to the value of
15002 success, and if the comparison is false, memory is affected according to the value of
15003 failure. These operations are atomic read-modify-write operations (<a href="#5.1.2.4">5.1.2.4</a>).
15005 NOTE 1 For example, the effect of atomic_compare_exchange_strong is
15006 <!--page 302 -->
15007 <pre>
15008 if (memcmp(object, expected, sizeof (*object)) == 0)
15009 memcpy(object, &desired, sizeof (*object));
15010 else
15011 memcpy(expected, object, sizeof (*object));
15012 </pre>
15015 A weak compare-and-exchange operation may fail spuriously. That is, even when the
15016 contents of memory referred to by expected and object are equal, it may return zero
15017 and store back to expected the same memory contents that were originally there.
15019 NOTE 2 This spurious failure enables implementation of compare-and-exchange on a broader class of
15020 machines, e.g. load-locked store-conditional machines.
15023 EXAMPLE A consequence of spurious failure is that nearly all uses of weak compare-and-exchange will
15024 be in a loop.
15025 <pre>
15026 exp = atomic_load(&cur);
15027 do {
15028 des = function(exp);
15029 } while (!atomic_compare_exchange_weak(&cur, &exp, des));
15030 </pre>
15031 When a compare-and-exchange is in a loop, the weak version will yield better performance on some
15032 platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
15033 strong one is preferable.
15035 <p><b>Returns</b>
15037 The result of the comparison.
15040 <h5><a name="7.17.7.5" href="#7.17.7.5">7.17.7.5 The atomic_fetch and modify generic functions</a></h5>
15042 The following operations perform arithmetic and bitwise computations. All of these
15043 operations are applicable to an object of any atomic integer type. None of these
15044 operations is applicable to atomic_bool. The key, operator, and computation
15045 correspondence is:
15046 <table border=1>
15047 <tr><th> key <th>op <th>computation
15048 <tr><td> add <td>+ <td>addition
15049 <tr><td> sub <td>- <td>subtraction
15050 <tr><td> or <td>| <td>bitwise inclusive or
15051 <tr><td> xor <td>^ <td>bitwise exclusive or
15052 <tr><td> and <td>& <td>bitwise and
15053 </table>
15054 <p><b>Synopsis</b>
15056 <pre>
15058 C atomic_fetch_<i>key</i>(volatile A *object, M operand);
15059 C atomic_fetch_<i>key</i>_explicit(volatile A *object,
15060 M operand, memory_order order);
15061 </pre>
15062 <p><b>Description</b>
15064 Atomically replaces the value pointed to by object with the result of the computation
15065 applied to the value pointed to by object and the given operand. Memory is affected
15066 <!--page 303 -->
15067 according to the value of order. These operations are atomic read-modify-write
15068 operations (<a href="#5.1.2.4">5.1.2.4</a>). For signed integer types, arithmetic is defined to use two's
15069 complement representation with silent wrap-around on overflow; there are no undefined
15070 results. For address types, the result may be an undefined address, but the operations
15071 otherwise have no undefined behavior.
15072 <p><b>Returns</b>
15074 Atomically, the value pointed to by object immediately before the effects.
15076 NOTE The operation of the atomic_fetch and modify generic functions are nearly equivalent to the
15077 operation of the corresponding op= compound assignment operators. The only differences are that the
15078 compound assignment operators are not guaranteed to operate atomically, and the value yielded by a
15079 compound assignment operator is the updated value of the object, whereas the value returned by the
15080 atomic_fetch and modify generic functions is the previous value of the atomic object.
15086 The atomic_flag type provides the classic test-and-set functionality. It has two
15087 states, set and clear.
15089 Operations on an object of type atomic_flag shall be lock free.
15091 NOTE Hence the operations should also be address-free. No other type requires lock-free operations, so
15092 the atomic_flag type is the minimum hardware-implemented type needed to conform to this
15093 International standard. The remaining types can be emulated with atomic_flag, though with less than
15094 ideal properties.
15097 The macro ATOMIC_FLAG_INIT may be used to initialize an atomic_flag to the
15098 clear state. An atomic_flag that is not explicitly initialized with
15099 ATOMIC_FLAG_INIT is initially in an indeterminate state.
15101 EXAMPLE
15102 <pre>
15103 atomic_flag guard = ATOMIC_FLAG_INIT;
15104 </pre>
15108 <h5><a name="7.17.8.1" href="#7.17.8.1">7.17.8.1 The atomic_flag_test_and_set functions</a></h5>
15109 <p><b>Synopsis</b>
15111 <pre>
15113 _Bool atomic_flag_test_and_set(
15114 volatile atomic_flag *object);
15115 _Bool atomic_flag_test_and_set_explicit(
15116 volatile atomic_flag *object, memory_order order);
15117 </pre>
15118 <p><b>Description</b>
15120 Atomically sets the value pointed to by object to true. Memory is affected according
15121 to the value of order. These operations are atomic read-modify-write operations
15123 <!--page 304 -->
15124 <p><b>Returns</b>
15126 Atomically, the value of the object immediately before the effects.
15130 <p><b>Synopsis</b>
15132 <pre>
15134 void atomic_flag_clear(volatile atomic_flag *object);
15135 void atomic_flag_clear_explicit(
15136 volatile atomic_flag *object, memory_order order);
15137 </pre>
15138 <p><b>Description</b>
15140 The order argument shall not be memory_order_acquire nor
15141 memory_order_acq_rel. Atomically sets the value pointed to by object to false.
15142 Memory is affected according to the value of order.
15143 <p><b>Returns</b>
15145 The atomic_flag_clear functions return no value.
15146 <!--page 305 -->
15153 The macro
15154 <pre>
15155 bool
15156 </pre>
15157 expands to _Bool.
15159 The remaining three macros are suitable for use in #if preprocessing directives. They
15160 are
15161 <pre>
15162 true
15163 </pre>
15164 which expands to the integer constant 1,
15165 <pre>
15166 false
15167 </pre>
15168 which expands to the integer constant 0, and
15169 <pre>
15170 __bool_true_false_are_defined
15171 </pre>
15172 which expands to the integer constant 1.
15174 Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
15180 <!--page 306 -->
15182 <p><b>Footnotes</b>
15183 <p><small><a name="note259" href="#note259">259)</a> See ''future library directions'' (<a href="#7.31.9">7.31.9</a>).
15184 </small>
15189 The header <a href="#7.19"><stddef.h></a> defines the following macros and declares the following types.
15190 Some are also defined in other headers, as noted in their respective subclauses.
15192 The types are
15193 <pre>
15194 ptrdiff_t
15195 </pre>
15196 which is the signed integer type of the result of subtracting two pointers;
15197 <pre>
15198 size_t
15199 </pre>
15200 which is the unsigned integer type of the result of the sizeof operator;
15201 <pre>
15202 max_align_t
15203 </pre>
15204 which is an object type whose alignment is as great as is supported by the implementation
15205 in all contexts; and
15206 <pre>
15207 wchar_t
15208 </pre>
15209 which is an integer type whose range of values can represent distinct codes for all
15210 members of the largest extended character set specified among the supported locales; the
15211 null character shall have the code value zero. Each member of the basic character set
15212 shall have a code value equal to its value when used as the lone character in an integer
15213 character constant if an implementation does not define
15214 __STDC_MB_MIGHT_NEQ_WC__.
15216 The macros are
15217 <pre>
15218 NULL
15219 </pre>
15220 which expands to an implementation-defined null pointer constant; and
15221 <pre>
15222 offsetof(type, member-designator)
15223 </pre>
15224 which expands to an integer constant expression that has type size_t, the value of
15225 which is the offset in bytes, to the structure member (designated by member-designator),
15226 from the beginning of its structure (designated by type). The type and member designator
15227 shall be such that given
15228 <pre>
15229 static type t;
15230 </pre>
15231 then the expression &(t.member-designator) evaluates to an address constant. (If the
15232 specified member is a bit-field, the behavior is undefined.)
15233 <p><b>Recommended practice</b>
15235 The types used for size_t and ptrdiff_t should not have an integer conversion rank
15236 greater than that of signed long int unless the implementation supports objects
15237 large enough to make this necessary. *
15238 <!--page 307 -->
15243 The header <a href="#7.20"><stdint.h></a> declares sets of integer types having specified widths, and
15244 defines corresponding sets of macros.<sup><a href="#note260"><b>260)</b></a></sup> It also defines macros that specify limits of
15245 integer types corresponding to types defined in other standard headers.
15247 Types are defined in the following categories:
15248 <ul>
15249 <li> integer types having certain exact widths;
15250 <li> integer types having at least certain specified widths;
15251 <li> fastest integer types having at least certain specified widths;
15252 <li> integer types wide enough to hold pointers to objects;
15253 <li> integer types having greatest width.
15254 </ul>
15255 (Some of these types may denote the same type.)
15257 Corresponding macros specify limits of the declared types and construct suitable
15258 constants.
15260 For each type described herein that the implementation provides,<sup><a href="#note261"><b>261)</b></a></sup> <a href="#7.20"><stdint.h></a> shall
15261 declare that typedef name and define the associated macros. Conversely, for each type
15262 described herein that the implementation does not provide, <a href="#7.20"><stdint.h></a> shall not
15263 declare that typedef name nor shall it define the associated macros. An implementation
15264 shall provide those types described as ''required'', but need not provide any of the others
15265 (described as ''optional'').
15267 <p><b>Footnotes</b>
15268 <p><small><a name="note260" href="#note260">260)</a> See ''future library directions'' (<a href="#7.31.10">7.31.10</a>).
15269 </small>
15270 <p><small><a name="note261" href="#note261">261)</a> Some of these types may denote implementation-defined extended integer types.
15271 </small>
15276 When typedef names differing only in the absence or presence of the initial u are defined,
15277 they shall denote corresponding signed and unsigned types as described in <a href="#6.2.5">6.2.5</a>; an
15278 implementation providing one of these corresponding types shall also provide the other.
15280 In the following descriptions, the symbol N represents an unsigned decimal integer with
15281 no leading zeros (e.g., 8 or 24, but not 04 or 048).
15286 <!--page 308 -->
15291 The typedef name int<i>N</i>_t designates a signed integer type with width N , no padding
15292 bits, and a two's complement representation. Thus, int8_t denotes such a signed
15293 integer type with a width of exactly 8 bits.
15295 The typedef name uint<i>N</i>_t designates an unsigned integer type with width N and no
15296 padding bits. Thus, uint24_t denotes such an unsigned integer type with a width of
15297 exactly 24 bits.
15299 These types are optional. However, if an implementation provides integer types with
15300 widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a
15301 two's complement representation, it shall define the corresponding typedef names.
15306 The typedef name int_least<i>N</i>_t designates a signed integer type with a width of at
15307 least N , such that no signed integer type with lesser size has at least the specified width.
15308 Thus, int_least32_t denotes a signed integer type with a width of at least 32 bits.
15310 The typedef name uint_least<i>N</i>_t designates an unsigned integer type with a width
15311 of at least N , such that no unsigned integer type with lesser size has at least the specified
15312 width. Thus, uint_least16_t denotes an unsigned integer type with a width of at
15313 least 16 bits.
15315 The following types are required:
15316 <pre>
15317 int_least8_t uint_least8_t
15318 int_least16_t uint_least16_t
15319 int_least32_t uint_least32_t
15320 int_least64_t uint_least64_t
15321 </pre>
15322 All other types of this form are optional.
15327 Each of the following types designates an integer type that is usually fastest<sup><a href="#note262"><b>262)</b></a></sup> to operate
15328 with among all integer types that have at least the specified width.
15330 The typedef name int_fast<i>N</i>_t designates the fastest signed integer type with a width
15331 of at least N . The typedef name uint_fast<i>N</i>_t designates the fastest unsigned integer
15332 type with a width of at least N .
15337 <!--page 309 -->
15339 The following types are required:
15340 <pre>
15341 int_fast8_t uint_fast8_t
15342 int_fast16_t uint_fast16_t
15343 int_fast32_t uint_fast32_t
15344 int_fast64_t uint_fast64_t
15345 </pre>
15346 All other types of this form are optional.
15348 <p><b>Footnotes</b>
15349 <p><small><a name="note262" href="#note262">262)</a> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
15350 grounds for choosing one type over another, it will simply pick some integer type satisfying the
15351 signedness and width requirements.
15352 </small>
15355 <h5><a name="7.20.1.4" href="#7.20.1.4">7.20.1.4 Integer types capable of holding object pointers</a></h5>
15357 The following type designates a signed integer type with the property that any valid
15358 pointer to void can be converted to this type, then converted back to pointer to void,
15359 and the result will compare equal to the original pointer:
15360 <pre>
15361 intptr_t
15362 </pre>
15363 The following type designates an unsigned integer type with the property that any valid
15364 pointer to void can be converted to this type, then converted back to pointer to void,
15365 and the result will compare equal to the original pointer:
15366 <pre>
15367 uintptr_t
15368 </pre>
15369 These types are optional.
15374 The following type designates a signed integer type capable of representing any value of
15375 any signed integer type:
15376 <pre>
15377 intmax_t
15378 </pre>
15379 The following type designates an unsigned integer type capable of representing any value
15380 of any unsigned integer type:
15381 <pre>
15382 uintmax_t
15383 </pre>
15384 These types are required.
15389 The following object-like macros specify the minimum and maximum limits of the types
15390 declared in <a href="#7.20"><stdint.h></a>. Each macro name corresponds to a similar type name in
15393 Each instance of any defined macro shall be replaced by a constant expression suitable
15394 for use in #if preprocessing directives, and this expression shall have the same type as
15395 would an expression that is an object of the corresponding type converted according to
15396 the integer promotions. Its implementation-defined value shall be equal to or greater in
15397 magnitude (absolute value) than the corresponding value given below, with the same sign,
15398 except where stated to be exactly the given value.
15399 <!--page 310 -->
15404 <ul>
15405 <li> minimum values of exact-width signed integer types
15406 <pre>
15407 INT<i>N</i>_MIN exactly -(2<sup>N-1</sup>)
15408 </pre>
15409 <li> maximum values of exact-width signed integer types
15410 <pre>
15411 INT<i>N</i>_MAX exactly 2<sup>N-1</sup> - 1
15412 </pre>
15413 <li> maximum values of exact-width unsigned integer types
15414 <pre>
15415 UINT<i>N</i>_MAX exactly 2<sup>N</sup> - 1
15416 </pre>
15417 </ul>
15420 <h5><a name="7.20.2.2" href="#7.20.2.2">7.20.2.2 Limits of minimum-width integer types</a></h5>
15422 <ul>
15423 <li> minimum values of minimum-width signed integer types
15424 <pre>
15425 INT_LEAST<i>N</i>_MIN -(2<sup>N-1</sup> - 1)
15426 </pre>
15427 <li> maximum values of minimum-width signed integer types
15428 <pre>
15429 INT_LEAST<i>N</i>_MAX 2<sup>N-1</sup> - 1
15430 </pre>
15431 <li> maximum values of minimum-width unsigned integer types
15432 <pre>
15433 UINT_LEAST<i>N</i>_MAX 2<sup>N</sup> - 1
15434 </pre>
15435 </ul>
15438 <h5><a name="7.20.2.3" href="#7.20.2.3">7.20.2.3 Limits of fastest minimum-width integer types</a></h5>
15440 <ul>
15441 <li> minimum values of fastest minimum-width signed integer types
15442 <pre>
15443 INT_FAST<i>N</i>_MIN -(2<sup>N-1</sup> - 1)
15444 </pre>
15445 <li> maximum values of fastest minimum-width signed integer types
15446 <pre>
15447 INT_FAST<i>N</i>_MAX 2<sup>N-1</sup> - 1
15448 </pre>
15449 <li> maximum values of fastest minimum-width unsigned integer types
15450 <pre>
15451 UINT_FAST<i>N</i>_MAX 2<sup>N</sup> - 1
15452 </pre>
15453 </ul>
15456 <h5><a name="7.20.2.4" href="#7.20.2.4">7.20.2.4 Limits of integer types capable of holding object pointers</a></h5>
15458 <ul>
15459 <li> minimum value of pointer-holding signed integer type
15460 <pre>
15461 INTPTR_MIN -(2<sup>15</sup> - 1)
15462 </pre>
15463 <li> maximum value of pointer-holding signed integer type
15464 <pre>
15465 INTPTR_MAX 2<sup>15</sup> - 1
15466 </pre>
15467 <li> maximum value of pointer-holding unsigned integer type
15468 <pre>
15469 UINTPTR_MAX 2<sup>16</sup> - 1
15470 </pre>
15471 </ul>
15472 <!--page 311 -->
15475 <h5><a name="7.20.2.5" href="#7.20.2.5">7.20.2.5 Limits of greatest-width integer types</a></h5>
15477 <ul>
15478 <li> minimum value of greatest-width signed integer type
15479 <pre>
15480 INTMAX_MIN -(2<sup>63</sup> - 1)
15481 </pre>
15482 <li> maximum value of greatest-width signed integer type
15483 <pre>
15484 INTMAX_MAX 2<sup>63</sup> - 1
15485 </pre>
15486 <li> maximum value of greatest-width unsigned integer type
15487 <pre>
15488 UINTMAX_MAX 2<sup>64</sup> - 1
15489 </pre>
15490 </ul>
15495 The following object-like macros specify the minimum and maximum limits of integer
15496 types corresponding to types defined in other standard headers.
15498 Each instance of these macros shall be replaced by a constant expression suitable for use
15499 in #if preprocessing directives, and this expression shall have the same type as would an
15500 expression that is an object of the corresponding type converted according to the integer
15501 promotions. Its implementation-defined value shall be equal to or greater in magnitude
15502 (absolute value) than the corresponding value given below, with the same sign. An
15503 implementation shall define only the macros corresponding to those typedef names it
15505 <ul>
15506 <li> limits of ptrdiff_t
15507 <pre>
15508 PTRDIFF_MIN -65535
15509 PTRDIFF_MAX +65535
15510 </pre>
15511 <li> limits of sig_atomic_t
15512 <pre>
15513 SIG_ATOMIC_MIN see below
15514 SIG_ATOMIC_MAX see below
15515 </pre>
15516 <li> limit of size_t
15517 <pre>
15518 SIZE_MAX 65535
15519 </pre>
15520 <li> limits of wchar_t
15521 <pre>
15522 WCHAR_MIN see below
15523 WCHAR_MAX see below
15524 </pre>
15525 <li> limits of wint_t
15526 <!--page 312 -->
15527 <pre>
15528 WINT_MIN see below
15529 WINT_MAX see below
15530 </pre>
15531 </ul>
15533 If sig_atomic_t (see <a href="#7.14">7.14</a>) is defined as a signed integer type, the value of
15534 SIG_ATOMIC_MIN shall be no greater than -127 and the value of SIG_ATOMIC_MAX
15535 shall be no less than 127; otherwise, sig_atomic_t is defined as an unsigned integer
15536 type, and the value of SIG_ATOMIC_MIN shall be 0 and the value of
15537 SIG_ATOMIC_MAX shall be no less than 255.
15539 If wchar_t (see <a href="#7.19">7.19</a>) is defined as a signed integer type, the value of WCHAR_MIN
15540 shall be no greater than -127 and the value of WCHAR_MAX shall be no less than 127;
15541 otherwise, wchar_t is defined as an unsigned integer type, and the value of
15542 WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.<sup><a href="#note264"><b>264)</b></a></sup>
15544 If wint_t (see <a href="#7.29">7.29</a>) is defined as a signed integer type, the value of WINT_MIN shall
15545 be no greater than -32767 and the value of WINT_MAX shall be no less than 32767;
15546 otherwise, wint_t is defined as an unsigned integer type, and the value of WINT_MIN
15547 shall be 0 and the value of WINT_MAX shall be no less than 65535.
15549 <p><b>Footnotes</b>
15550 <p><small><a name="note263" href="#note263">263)</a> A freestanding implementation need not provide all of these types.
15551 </small>
15552 <p><small><a name="note264" href="#note264">264)</a> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
15553 character set.
15554 </small>
15559 The following function-like macros expand to integer constants suitable for initializing
15560 objects that have integer types corresponding to types defined in <a href="#7.20"><stdint.h></a>. Each
15561 macro name corresponds to a similar type name in <a href="#7.20.1.2">7.20.1.2</a> or <a href="#7.20.1.5">7.20.1.5</a>.
15563 The argument in any instance of these macros shall be an unsuffixed integer constant (as
15564 defined in <a href="#6.4.4.1">6.4.4.1</a>) with a value that does not exceed the limits for the corresponding type.
15566 Each invocation of one of these macros shall expand to an integer constant expression
15567 suitable for use in #if preprocessing directives. The type of the expression shall have
15568 the same type as would an expression of the corresponding type converted according to
15569 the integer promotions. The value of the expression shall be that of the argument.
15572 <h5><a name="7.20.4.1" href="#7.20.4.1">7.20.4.1 Macros for minimum-width integer constants</a></h5>
15574 The macro INT<i>N</i>_C(value) shall expand to an integer constant expression
15575 corresponding to the type int_least<i>N</i>_t. The macro UINT<i>N</i>_C(value) shall expand
15576 to an integer constant expression corresponding to the type uint_least<i>N</i>_t. For
15577 example, if uint_least64_t is a name for the type unsigned long long int,
15578 then UINT64_C(0x123) might expand to the integer constant 0x123ULL.
15583 <!--page 313 -->
15586 <h5><a name="7.20.4.2" href="#7.20.4.2">7.20.4.2 Macros for greatest-width integer constants</a></h5>
15588 The following macro expands to an integer constant expression having the value specified
15589 by its argument and the type intmax_t:
15590 <pre>
15591 INTMAX_C(value)
15592 </pre>
15593 The following macro expands to an integer constant expression having the value specified
15594 by its argument and the type uintmax_t:
15595 <!--page 314 -->
15596 <pre>
15597 UINTMAX_C(value)
15598 </pre>
15606 The header <a href="#7.21"><stdio.h></a> defines several macros, and declares three types and many
15607 functions for performing input and output.
15610 <pre>
15611 FILE
15612 </pre>
15613 which is an object type capable of recording all the information needed to control a
15614 stream, including its file position indicator, a pointer to its associated buffer (if any), an
15615 error indicator that records whether a read/write error has occurred, and an end-of-file
15616 indicator that records whether the end of the file has been reached; and
15617 <pre>
15618 fpos_t
15619 </pre>
15620 which is a complete object type other than an array type capable of recording all the
15621 information needed to specify uniquely every position within a file.
15624 <pre>
15625 _IOFBF
15626 _IOLBF
15627 _IONBF
15628 </pre>
15629 which expand to integer constant expressions with distinct values, suitable for use as the
15630 third argument to the setvbuf function;
15631 <pre>
15632 BUFSIZ
15633 </pre>
15634 which expands to an integer constant expression that is the size of the buffer used by the
15635 setbuf function;
15636 <pre>
15637 EOF
15638 </pre>
15639 which expands to an integer constant expression, with type int and a negative value, that
15640 is returned by several functions to indicate end-of-file, that is, no more input from a
15641 stream;
15642 <pre>
15643 FOPEN_MAX
15644 </pre>
15645 which expands to an integer constant expression that is the minimum number of files that
15646 the implementation guarantees can be open simultaneously;
15647 <pre>
15648 FILENAME_MAX
15649 </pre>
15650 which expands to an integer constant expression that is the size needed for an array of
15651 char large enough to hold the longest file name string that the implementation
15652 <!--page 315 -->
15654 <pre>
15655 L_tmpnam
15656 </pre>
15657 which expands to an integer constant expression that is the size needed for an array of
15658 char large enough to hold a temporary file name string generated by the tmpnam
15659 function;
15660 <pre>
15661 SEEK_CUR
15662 SEEK_END
15663 SEEK_SET
15664 </pre>
15665 which expand to integer constant expressions with distinct values, suitable for use as the
15666 third argument to the fseek function;
15667 <pre>
15668 TMP_MAX
15669 </pre>
15670 which expands to an integer constant expression that is the minimum number of unique
15671 file names that can be generated by the tmpnam function;
15672 <pre>
15673 stderr
15674 stdin
15675 stdout
15676 </pre>
15677 which are expressions of type ''pointer to FILE'' that point to the FILE objects
15678 associated, respectively, with the standard error, input, and output streams.
15680 The header <a href="#7.29"><wchar.h></a> declares a number of functions useful for wide character input
15681 and output. The wide character input/output functions described in that subclause
15682 provide operations analogous to most of those described here, except that the
15683 fundamental units internal to the program are wide characters. The external
15684 representation (in the file) is a sequence of ''generalized'' multibyte characters, as
15687 The input/output functions are given the following collective terms:
15688 <ul>
15689 <li> The wide character input functions -- those functions described in <a href="#7.29">7.29</a> that perform
15690 input into wide characters and wide strings: fgetwc, fgetws, getwc, getwchar,
15691 fwscanf, wscanf, vfwscanf, and vwscanf.
15692 <li> The wide character output functions -- those functions described in <a href="#7.29">7.29</a> that perform
15693 output from wide characters and wide strings: fputwc, fputws, putwc,
15694 putwchar, fwprintf, wprintf, vfwprintf, and vwprintf.
15697 <!--page 316 -->
15698 <li> The wide character input/output functions -- the union of the ungetwc function, the
15699 wide character input functions, and the wide character output functions.
15700 <li> The byte input/output functions -- those functions described in this subclause that
15701 perform input/output: fgetc, fgets, fprintf, fputc, fputs, fread,
15702 fscanf, fwrite, getc, getchar, printf, putc, putchar, puts, scanf,
15703 ungetc, vfprintf, vfscanf, vprintf, and vscanf.
15704 </ul>
15705 <p><b> Forward references</b>: files (<a href="#7.21.3">7.21.3</a>), the fseek function (<a href="#7.21.9.2">7.21.9.2</a>), streams (<a href="#7.21.2">7.21.2</a>), the
15706 tmpnam function (<a href="#7.21.4.4">7.21.4.4</a>), <a href="#7.29"><wchar.h></a> (<a href="#7.29">7.29</a>).
15708 <p><b>Footnotes</b>
15709 <p><small><a name="note265" href="#note265">265)</a> If the implementation imposes no practical limit on the length of file name strings, the value of
15710 FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
15711 string. Of course, file name string contents are subject to other system-specific constraints; therefore
15712 all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
15713 </small>
15718 Input and output, whether to or from physical devices such as terminals and tape drives,
15719 or whether to or from files supported on structured storage devices, are mapped into
15720 logical data streams, whose properties are more uniform than their various inputs and
15721 outputs. Two forms of mapping are supported, for text streams and for binary
15724 A text stream is an ordered sequence of characters composed into lines, each line
15725 consisting of zero or more characters plus a terminating new-line character. Whether the
15726 last line requires a terminating new-line character is implementation-defined. Characters
15727 may have to be added, altered, or deleted on input and output to conform to differing
15728 conventions for representing text in the host environment. Thus, there need not be a one-
15729 to-one correspondence between the characters in a stream and those in the external
15730 representation. Data read in from a text stream will necessarily compare equal to the data
15731 that were earlier written out to that stream only if: the data consist only of printing
15732 characters and the control characters horizontal tab and new-line; no new-line character is
15733 immediately preceded by space characters; and the last character is a new-line character.
15734 Whether space characters that are written out immediately before a new-line character
15735 appear when read in is implementation-defined.
15737 A binary stream is an ordered sequence of characters that can transparently record
15738 internal data. Data read in from a binary stream shall compare equal to the data that were
15739 earlier written out to that stream, under the same implementation. Such a stream may,
15740 however, have an implementation-defined number of null characters appended to the end
15741 of the stream.
15743 Each stream has an orientation. After a stream is associated with an external file, but
15744 before any operations are performed on it, the stream is without orientation. Once a wide
15745 character input/output function has been applied to a stream without orientation, the
15748 <!--page 317 -->
15749 stream becomes a wide-oriented stream. Similarly, once a byte input/output function has
15750 been applied to a stream without orientation, the stream becomes a byte-oriented stream.
15751 Only a call to the freopen function or the fwide function can otherwise alter the
15752 orientation of a stream. (A successful call to freopen removes any orientation.)<sup><a href="#note267"><b>267)</b></a></sup>
15754 Byte input/output functions shall not be applied to a wide-oriented stream and wide
15755 character input/output functions shall not be applied to a byte-oriented stream. The
15756 remaining stream operations do not affect, and are not affected by, a stream's orientation,
15757 except for the following additional restrictions:
15758 <ul>
15759 <li> Binary wide-oriented streams have the file-positioning restrictions ascribed to both
15760 text and binary streams.
15761 <li> For wide-oriented streams, after a successful call to a file-positioning function that
15762 leaves the file position indicator prior to the end-of-file, a wide character output
15763 function can overwrite a partial multibyte character; any file contents beyond the
15764 byte(s) written are henceforth indeterminate.
15765 </ul>
15767 Each wide-oriented stream has an associated mbstate_t object that stores the current
15768 parse state of the stream. A successful call to fgetpos stores a representation of the
15769 value of this mbstate_t object as part of the value of the fpos_t object. A later
15770 successful call to fsetpos using the same stored fpos_t value restores the value of
15771 the associated mbstate_t object as well as the position within the controlled stream.
15773 Each stream has an associated lock that is used to prevent data races when multiple
15774 threads of execution access a stream, and to restrict the interleaving of stream operations
15775 performed by multiple threads. Only one thread may hold this lock at a time. The lock is
15776 reentrant: a single thread may hold the lock multiple times at a given time.
15778 All functions that read, write, position, or query the position of a stream lock the stream
15779 before accessing it. They release the lock associated with the stream when the access is
15780 complete.
15781 <p><b>Environmental limits</b>
15783 An implementation shall support text files with lines containing at least 254 characters,
15784 including the terminating new-line character. The value of the macro BUFSIZ shall be at
15785 least 256.
15786 <p><b> Forward references</b>: the freopen function (<a href="#7.21.5.4">7.21.5.4</a>), the fwide function (<a href="#7.29.3.5">7.29.3.5</a>),
15787 mbstate_t (<a href="#7.30.1">7.30.1</a>), the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>), the fsetpos function
15793 <!--page 318 -->
15795 <p><b>Footnotes</b>
15796 <p><small><a name="note266" href="#note266">266)</a> An implementation need not distinguish between text streams and binary streams. In such an
15797 implementation, there need be no new-line characters in a text stream nor any limit to the length of a
15798 line.
15799 </small>
15800 <p><small><a name="note267" href="#note267">267)</a> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
15801 </small>
15806 A stream is associated with an external file (which may be a physical device) by opening
15807 a file, which may involve creating a new file. Creating an existing file causes its former
15808 contents to be discarded, if necessary. If a file can support positioning requests (such as a
15809 disk file, as opposed to a terminal), then a file position indicator associated with the
15810 stream is positioned at the start (character number zero) of the file, unless the file is
15811 opened with append mode in which case it is implementation-defined whether the file
15812 position indicator is initially positioned at the beginning or the end of the file. The file
15813 position indicator is maintained by subsequent reads, writes, and positioning requests, to
15814 facilitate an orderly progression through the file.
15816 Binary files are not truncated, except as defined in <a href="#7.21.5.3">7.21.5.3</a>. Whether a write on a text
15817 stream causes the associated file to be truncated beyond that point is implementation-
15818 defined.
15820 When a stream is unbuffered, characters are intended to appear from the source or at the
15821 destination as soon as possible. Otherwise characters may be accumulated and
15822 transmitted to or from the host environment as a block. When a stream is fully buffered,
15823 characters are intended to be transmitted to or from the host environment as a block when
15824 a buffer is filled. When a stream is line buffered, characters are intended to be
15825 transmitted to or from the host environment as a block when a new-line character is
15826 encountered. Furthermore, characters are intended to be transmitted as a block to the host
15827 environment when a buffer is filled, when input is requested on an unbuffered stream, or
15828 when input is requested on a line buffered stream that requires the transmission of
15829 characters from the host environment. Support for these characteristics is
15830 implementation-defined, and may be affected via the setbuf and setvbuf functions.
15832 A file may be disassociated from a controlling stream by closing the file. Output streams
15833 are flushed (any unwritten buffer contents are transmitted to the host environment) before
15834 the stream is disassociated from the file. The value of a pointer to a FILE object is
15835 indeterminate after the associated file is closed (including the standard text streams).
15836 Whether a file of zero length (on which no characters have been written by an output
15837 stream) actually exists is implementation-defined.
15839 The file may be subsequently reopened, by the same or another program execution, and
15840 its contents reclaimed or modified (if it can be repositioned at its start). If the main
15841 function returns to its original caller, or if the exit function is called, all open files are
15842 closed (hence all output streams are flushed) before program termination. Other paths to
15843 program termination, such as calling the abort function, need not close all files
15844 properly.
15846 The address of the FILE object used to control a stream may be significant; a copy of a
15847 FILE object need not serve in place of the original.
15848 <!--page 319 -->
15850 At program startup, three text streams are predefined and need not be opened explicitly
15851 -- standard input (for reading conventional input), standard output (for writing
15852 conventional output), and standard error (for writing diagnostic output). As initially
15853 opened, the standard error stream is not fully buffered; the standard input and standard
15854 output streams are fully buffered if and only if the stream can be determined not to refer
15855 to an interactive device.
15857 Functions that open additional (nontemporary) files require a file name, which is a string.
15858 The rules for composing valid file names are implementation-defined. Whether the same
15859 file can be simultaneously open multiple times is also implementation-defined.
15861 Although both text and binary wide-oriented streams are conceptually sequences of wide
15862 characters, the external file associated with a wide-oriented stream is a sequence of
15863 multibyte characters, generalized as follows:
15864 <ul>
15865 <li> Multibyte encodings within files may contain embedded null bytes (unlike multibyte
15866 encodings valid for use internal to the program).
15867 <li> A file need not begin nor end in the initial shift state.<sup><a href="#note268"><b>268)</b></a></sup>
15868 </ul>
15870 Moreover, the encodings used for multibyte characters may differ among files. Both the
15871 nature and choice of such encodings are implementation-defined.
15873 The wide character input functions read multibyte characters from the stream and convert
15874 them to wide characters as if they were read by successive calls to the fgetwc function.
15875 Each conversion occurs as if by a call to the mbrtowc function, with the conversion state
15876 described by the stream's own mbstate_t object. The byte input functions read
15877 characters from the stream as if by successive calls to the fgetc function.
15879 The wide character output functions convert wide characters to multibyte characters and
15880 write them to the stream as if they were written by successive calls to the fputwc
15881 function. Each conversion occurs as if by a call to the wcrtomb function, with the
15882 conversion state described by the stream's own mbstate_t object. The byte output
15883 functions write characters to the stream as if by successive calls to the fputc function.
15885 In some cases, some of the byte input/output functions also perform conversions between
15886 multibyte characters and wide characters. These conversions also occur as if by calls to
15887 the mbrtowc and wcrtomb functions.
15889 An encoding error occurs if the character sequence presented to the underlying
15890 mbrtowc function does not form a valid (generalized) multibyte character, or if the code
15891 value passed to the underlying wcrtomb does not correspond to a valid (generalized)
15894 <!--page 320 -->
15895 multibyte character. The wide character input/output functions and the byte input/output
15896 functions store the value of the macro EILSEQ in errno if and only if an encoding error
15897 occurs.
15898 <p><b>Environmental limits</b>
15900 The value of FOPEN_MAX shall be at least eight, including the three standard text
15901 streams.
15902 <p><b> Forward references</b>: the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the fgetc function (<a href="#7.21.7.1">7.21.7.1</a>), the
15903 fopen function (<a href="#7.21.5.3">7.21.5.3</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>), the setbuf function
15904 (<a href="#7.21.5.5">7.21.5.5</a>), the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>), the fgetwc function (<a href="#7.29.3.1">7.29.3.1</a>), the
15905 fputwc function (<a href="#7.29.3.3">7.29.3.3</a>), conversion state (<a href="#7.29.6">7.29.6</a>), the mbrtowc function
15906 (<a href="#7.29.6.3.2">7.29.6.3.2</a>), the wcrtomb function (<a href="#7.29.6.3.3">7.29.6.3.3</a>).
15908 <p><b>Footnotes</b>
15909 <p><small><a name="note268" href="#note268">268)</a> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
15910 undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
15911 with state-dependent encoding that does not assuredly end in the initial shift state.
15912 </small>
15919 <p><b>Synopsis</b>
15921 <pre>
15923 int remove(const char *filename);
15924 </pre>
15925 <p><b>Description</b>
15927 The remove function causes the file whose name is the string pointed to by filename
15928 to be no longer accessible by that name. A subsequent attempt to open that file using that
15929 name will fail, unless it is created anew. If the file is open, the behavior of the remove
15930 function is implementation-defined.
15931 <p><b>Returns</b>
15933 The remove function returns zero if the operation succeeds, nonzero if it fails.
15937 <p><b>Synopsis</b>
15939 <pre>
15941 int rename(const char *old, const char *new);
15942 </pre>
15943 <p><b>Description</b>
15945 The rename function causes the file whose name is the string pointed to by old to be
15946 henceforth known by the name given by the string pointed to by new. The file named
15947 old is no longer accessible by that name. If a file named by the string pointed to by new
15948 exists prior to the call to the rename function, the behavior is implementation-defined.
15949 <!--page 321 -->
15950 <p><b>Returns</b>
15952 The rename function returns zero if the operation succeeds, nonzero if it fails,<sup><a href="#note269"><b>269)</b></a></sup> in
15953 which case if the file existed previously it is still known by its original name.
15955 <p><b>Footnotes</b>
15956 <p><small><a name="note269" href="#note269">269)</a> Among the reasons the implementation may cause the rename function to fail are that the file is open
15957 or that it is necessary to copy its contents to effectuate its renaming.
15958 </small>
15962 <p><b>Synopsis</b>
15964 <pre>
15966 FILE *tmpfile(void);
15967 </pre>
15968 <p><b>Description</b>
15970 The tmpfile function creates a temporary binary file that is different from any other
15971 existing file and that will automatically be removed when it is closed or at program
15972 termination. If the program terminates abnormally, whether an open temporary file is
15974 <p><b>Recommended practice</b>
15976 It should be possible to open at least TMP_MAX temporary files during the lifetime of the
15977 program (this limit may be shared with tmpnam) and there should be no limit on the
15978 number simultaneously open other than this limit and any limit on the number of open
15979 files (FOPEN_MAX).
15980 <p><b>Returns</b>
15982 The tmpfile function returns a pointer to the stream of the file that it created. If the file
15983 cannot be created, the tmpfile function returns a null pointer.
15988 <p><b>Synopsis</b>
15990 <pre>
15992 char *tmpnam(char *s);
15993 </pre>
15994 <p><b>Description</b>
15996 The tmpnam function generates a string that is a valid file name and that is not the same
15997 as the name of an existing file.<sup><a href="#note270"><b>270)</b></a></sup> The function is potentially capable of generating at
16000 <!--page 322 -->
16001 least TMP_MAX different strings, but any or all of them may already be in use by existing
16002 files and thus not be suitable return values.
16004 The tmpnam function generates a different string each time it is called.
16006 Calls to the tmpnam function with a null pointer argument may introduce data races with
16007 each other. The implementation shall behave as if no library function calls the tmpnam
16008 function.
16009 <p><b>Returns</b>
16011 If no suitable string can be generated, the tmpnam function returns a null pointer.
16012 Otherwise, if the argument is a null pointer, the tmpnam function leaves its result in an
16013 internal static object and returns a pointer to that object (subsequent calls to the tmpnam
16014 function may modify the same object). If the argument is not a null pointer, it is assumed
16015 to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
16016 in that array and returns the argument as its value.
16017 <p><b>Environmental limits</b>
16019 The value of the macro TMP_MAX shall be at least 25.
16021 <p><b>Footnotes</b>
16022 <p><small><a name="note270" href="#note270">270)</a> Files created using strings generated by the tmpnam function are temporary only in the sense that
16023 their names should not collide with those generated by conventional naming rules for the
16024 implementation. It is still necessary to use the remove function to remove such files when their use
16025 is ended, and before program termination.
16026 </small>
16033 <p><b>Synopsis</b>
16035 <pre>
16037 int fclose(FILE *stream);
16038 </pre>
16039 <p><b>Description</b>
16041 A successful call to the fclose function causes the stream pointed to by stream to be
16042 flushed and the associated file to be closed. Any unwritten buffered data for the stream
16043 are delivered to the host environment to be written to the file; any unread buffered data
16044 are discarded. Whether or not the call succeeds, the stream is disassociated from the file
16045 and any buffer set by the setbuf or setvbuf function is disassociated from the stream
16046 (and deallocated if it was automatically allocated).
16047 <p><b>Returns</b>
16049 The fclose function returns zero if the stream was successfully closed, or EOF if any
16050 errors were detected.
16051 <!--page 323 -->
16055 <p><b>Synopsis</b>
16057 <pre>
16059 int fflush(FILE *stream);
16060 </pre>
16061 <p><b>Description</b>
16063 If stream points to an output stream or an update stream in which the most recent
16064 operation was not input, the fflush function causes any unwritten data for that stream
16065 to be delivered to the host environment to be written to the file; otherwise, the behavior is
16066 undefined.
16068 If stream is a null pointer, the fflush function performs this flushing action on all
16069 streams for which the behavior is defined above.
16070 <p><b>Returns</b>
16072 The fflush function sets the error indicator for the stream and returns EOF if a write
16073 error occurs, otherwise it returns zero.
16078 <p><b>Synopsis</b>
16080 <pre>
16082 FILE *fopen(const char * restrict filename,
16083 const char * restrict mode);
16084 </pre>
16085 <p><b>Description</b>
16087 The fopen function opens the file whose name is the string pointed to by filename,
16088 and associates a stream with it.
16090 The argument mode points to a string. If the string is one of the following, the file is
16091 open in the indicated mode. Otherwise, the behavior is undefined.<sup><a href="#note271"><b>271)</b></a></sup>
16092 <dl>
16093 <dt> r <dd>open text file for reading
16094 <dt> w <dd>truncate to zero length or create text file for writing
16095 <dt> wx <dd>create text file for writing
16096 <dt> a <dd>append; open or create text file for writing at end-of-file
16097 <dt> rb <dd>open binary file for reading
16098 <dt> wb <dd>truncate to zero length or create binary file for writing
16099 <!--page 324 -->
16100 <dt> wbx <dd>create binary file for writing
16101 <dt> ab <dd>append; open or create binary file for writing at end-of-file
16102 <dt> r+ <dd>open text file for update (reading and writing)
16103 <dt> w+ <dd>truncate to zero length or create text file for update
16104 <dt> w+x <dd>create text file for update
16105 <dt> a+ <dd>append; open or create text file for update, writing at end-of-file
16106 <dt> r+b or rb+ <dd>open binary file for update (reading and writing)
16107 <dt> w+b or wb+ <dd>truncate to zero length or create binary file for update
16108 <dt> w+bx or wb+x <dd>create binary file for update
16109 <dt> a+b or ab+ <dd>append; open or create binary file for update, writing at end-of-file
16110 </dl>
16112 Opening a file with read mode ('r' as the first character in the mode argument) fails if
16113 the file does not exist or cannot be read.
16115 Opening a file with exclusive mode ('x' as the last character in the mode argument)
16116 fails if the file already exists or cannot be created. Otherwise, the file is created with
16117 exclusive (also known as non-shared) access to the extent that the underlying system
16118 supports exclusive access.
16120 Opening a file with append mode ('a' as the first character in the mode argument)
16121 causes all subsequent writes to the file to be forced to the then current end-of-file,
16122 regardless of intervening calls to the fseek function. In some implementations, opening
16123 a binary file with append mode ('b' as the second or third character in the above list of
16124 mode argument values) may initially position the file position indicator for the stream
16125 beyond the last data written, because of null character padding.
16127 When a file is opened with update mode ('+' as the second or third character in the
16128 above list of mode argument values), both input and output may be performed on the
16129 associated stream. However, output shall not be directly followed by input without an
16130 intervening call to the fflush function or to a file positioning function (fseek,
16131 fsetpos, or rewind), and input shall not be directly followed by output without an
16132 intervening call to a file positioning function, unless the input operation encounters end-
16133 of-file. Opening (or creating) a text file with update mode may instead open (or create) a
16134 binary stream in some implementations.
16136 When opened, a stream is fully buffered if and only if it can be determined not to refer to
16137 an interactive device. The error and end-of-file indicators for the stream are cleared.
16138 <p><b>Returns</b>
16140 The fopen function returns a pointer to the object controlling the stream. If the open
16141 operation fails, fopen returns a null pointer.
16143 <!--page 325 -->
16145 <p><b>Footnotes</b>
16146 <p><small><a name="note271" href="#note271">271)</a> If the string begins with one of the above sequences, the implementation might choose to ignore the
16147 remaining characters, or it might use them to select different kinds of a file (some of which might not
16149 </small>
16153 <p><b>Synopsis</b>
16155 <pre>
16157 FILE *freopen(const char * restrict filename,
16158 const char * restrict mode,
16159 FILE * restrict stream);
16160 </pre>
16161 <p><b>Description</b>
16163 The freopen function opens the file whose name is the string pointed to by filename
16164 and associates the stream pointed to by stream with it. The mode argument is used just
16167 If filename is a null pointer, the freopen function attempts to change the mode of
16168 the stream to that specified by mode, as if the name of the file currently associated with
16169 the stream had been used. It is implementation-defined which changes of mode are
16170 permitted (if any), and under what circumstances.
16172 The freopen function first attempts to close any file that is associated with the specified
16173 stream. Failure to close the file is ignored. The error and end-of-file indicators for the
16174 stream are cleared.
16175 <p><b>Returns</b>
16177 The freopen function returns a null pointer if the open operation fails. Otherwise,
16178 freopen returns the value of stream.
16180 <p><b>Footnotes</b>
16181 <p><small><a name="note272" href="#note272">272)</a> The primary use of the freopen function is to change the file associated with a standard text stream
16182 (stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
16183 returned by the fopen function may be assigned.
16184 </small>
16188 <p><b>Synopsis</b>
16190 <pre>
16192 void setbuf(FILE * restrict stream,
16193 char * restrict buf);
16194 </pre>
16195 <p><b>Description</b>
16197 Except that it returns no value, the setbuf function is equivalent to the setvbuf
16198 function invoked with the values _IOFBF for mode and BUFSIZ for size, or (if buf
16199 is a null pointer), with the value _IONBF for mode.
16204 <!--page 326 -->
16205 <p><b>Returns</b>
16207 The setbuf function returns no value.
16212 <p><b>Synopsis</b>
16214 <pre>
16216 int setvbuf(FILE * restrict stream,
16217 char * restrict buf,
16218 int mode, size_t size);
16219 </pre>
16220 <p><b>Description</b>
16222 The setvbuf function may be used only after the stream pointed to by stream has
16223 been associated with an open file and before any other operation (other than an
16224 unsuccessful call to setvbuf) is performed on the stream. The argument mode
16225 determines how stream will be buffered, as follows: _IOFBF causes input/output to be
16226 fully buffered; _IOLBF causes input/output to be line buffered; _IONBF causes
16227 input/output to be unbuffered. If buf is not a null pointer, the array it points to may be
16228 used instead of a buffer allocated by the setvbuf function<sup><a href="#note273"><b>273)</b></a></sup> and the argument size
16229 specifies the size of the array; otherwise, size may determine the size of a buffer
16230 allocated by the setvbuf function. The contents of the array at any time are
16231 indeterminate.
16232 <p><b>Returns</b>
16234 The setvbuf function returns zero on success, or nonzero if an invalid value is given
16235 for mode or if the request cannot be honored.
16240 <!--page 327 -->
16242 <p><b>Footnotes</b>
16243 <p><small><a name="note273" href="#note273">273)</a> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
16244 before a buffer that has automatic storage duration is deallocated upon block exit.
16245 </small>
16250 The formatted input/output functions shall behave as if there is a sequence point after the
16253 <p><b>Footnotes</b>
16254 <p><small><a name="note274" href="#note274">274)</a> The fprintf functions perform writes to memory for the %n specifier.
16255 </small>
16259 <p><b>Synopsis</b>
16261 <pre>
16263 int fprintf(FILE * restrict stream,
16264 const char * restrict format, ...);
16265 </pre>
16266 <p><b>Description</b>
16268 The fprintf function writes output to the stream pointed to by stream, under control
16269 of the string pointed to by format that specifies how subsequent arguments are
16270 converted for output. If there are insufficient arguments for the format, the behavior is
16271 undefined. If the format is exhausted while arguments remain, the excess arguments are
16272 evaluated (as always) but are otherwise ignored. The fprintf function returns when
16273 the end of the format string is encountered.
16275 The format shall be a multibyte character sequence, beginning and ending in its initial
16276 shift state. The format is composed of zero or more directives: ordinary multibyte
16277 characters (not %), which are copied unchanged to the output stream; and conversion
16278 specifications, each of which results in fetching zero or more subsequent arguments,
16279 converting them, if applicable, according to the corresponding conversion specifier, and
16280 then writing the result to the output stream.
16282 Each conversion specification is introduced by the character %. After the %, the following
16283 appear in sequence:
16284 <ul>
16285 <li> Zero or more flags (in any order) that modify the meaning of the conversion
16286 specification.
16287 <li> An optional minimum field width. If the converted value has fewer characters than the
16288 field width, it is padded with spaces (by default) on the left (or right, if the left
16289 adjustment flag, described later, has been given) to the field width. The field width
16290 takes the form of an asterisk * (described later) or a nonnegative decimal integer.<sup><a href="#note275"><b>275)</b></a></sup>
16291 <li> An optional precision that gives the minimum number of digits to appear for the d, i,
16292 o, u, x, and X conversions, the number of digits to appear after the decimal-point
16293 character for a, A, e, E, f, and F conversions, the maximum number of significant
16294 digits for the g and G conversions, or the maximum number of bytes to be written for
16297 <!--page 328 -->
16298 s conversions. The precision takes the form of a period (.) followed either by an
16299 asterisk * (described later) or by an optional decimal integer; if only the period is
16300 specified, the precision is taken as zero. If a precision appears with any other
16301 conversion specifier, the behavior is undefined.
16302 <li> An optional length modifier that specifies the size of the argument.
16303 <li> A conversion specifier character that specifies the type of conversion to be applied.
16304 </ul>
16306 As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
16307 this case, an int argument supplies the field width or precision. The arguments
16308 specifying field width, or precision, or both, shall appear (in that order) before the
16309 argument (if any) to be converted. A negative field width argument is taken as a - flag
16310 followed by a positive field width. A negative precision argument is taken as if the
16311 precision were omitted.
16313 The flag characters and their meanings are:
16314 <dl>
16315 <dt> - <dd>The result of the conversion is left-justified within the field. (It is right-justified if
16316 this flag is not specified.)
16317 <dt> + <dd>The result of a signed conversion always begins with a plus or minus sign. (It
16318 begins with a sign only when a negative value is converted if this flag is not
16320 <dt> space <dd>If the first character of a signed conversion is not a sign, or if a signed conversion
16321 results in no characters, a space is prefixed to the result. If the space and + flags
16322 both appear, the space flag is ignored.
16323 <dt> # <dd>The result is converted to an ''alternative form''. For o conversion, it increases
16324 the precision, if and only if necessary, to force the first digit of the result to be a
16325 zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
16326 conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
16327 and G conversions, the result of converting a floating-point number always
16328 contains a decimal-point character, even if no digits follow it. (Normally, a
16329 decimal-point character appears in the result of these conversions only if a digit
16330 follows it.) For g and G conversions, trailing zeros are not removed from the
16331 result. For other conversions, the behavior is undefined.
16332 <dt> 0 <dd>For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
16333 (following any indication of sign or base) are used to pad to the field width rather
16334 than performing space padding, except when converting an infinity or NaN. If the
16335 0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
16336 <!--page 329 -->
16337 conversions, if a precision is specified, the 0 flag is ignored. For other
16338 conversions, the behavior is undefined.
16339 </dl>
16341 The length modifiers and their meanings are:
16342 <dl>
16343 <dt> hh <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
16344 signed char or unsigned char argument (the argument will have
16345 been promoted according to the integer promotions, but its value shall be
16346 converted to signed char or unsigned char before printing); or that
16347 a following n conversion specifier applies to a pointer to a signed char
16348 argument.
16349 <dt> h <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
16350 short int or unsigned short int argument (the argument will
16351 have been promoted according to the integer promotions, but its value shall
16352 be converted to short int or unsigned short int before printing);
16353 or that a following n conversion specifier applies to a pointer to a short
16354 int argument.
16355 <dt> l (ell) <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
16356 long int or unsigned long int argument; that a following n
16357 conversion specifier applies to a pointer to a long int argument; that a
16358 following c conversion specifier applies to a wint_t argument; that a
16359 following s conversion specifier applies to a pointer to a wchar_t
16360 argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
16361 specifier.
16362 <dt> ll (ell-ell) <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
16363 long long int or unsigned long long int argument; or that a
16364 following n conversion specifier applies to a pointer to a long long int
16365 argument.
16366 <dt> j <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to
16367 an intmax_t or uintmax_t argument; or that a following n conversion
16368 specifier applies to a pointer to an intmax_t argument.
16369 <dt> z <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
16370 size_t or the corresponding signed integer type argument; or that a
16371 following n conversion specifier applies to a pointer to a signed integer type
16372 corresponding to size_t argument.
16373 <dt> t <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
16374 <!--page 330 -->
16375 ptrdiff_t or the corresponding unsigned integer type argument; or that a
16376 following n conversion specifier applies to a pointer to a ptrdiff_t
16377 argument.
16378 <dt> L <dd>Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
16379 applies to a long double argument.
16380 </dl>
16381 If a length modifier appears with any conversion specifier other than as specified above,
16382 the behavior is undefined.
16384 The conversion specifiers and their meanings are:
16385 <dl>
16386 <dt> d,i <dd>The int argument is converted to signed decimal in the style [-]dddd. The
16387 precision specifies the minimum number of digits to appear; if the value
16388 being converted can be represented in fewer digits, it is expanded with
16389 leading zeros. The default precision is 1. The result of converting a zero
16390 value with a precision of zero is no characters.
16391 <dt> o,u,x,X <dd>The unsigned int argument is converted to unsigned octal (o), unsigned
16392 decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
16393 letters abcdef are used for x conversion and the letters ABCDEF for X
16394 conversion. The precision specifies the minimum number of digits to appear;
16395 if the value being converted can be represented in fewer digits, it is expanded
16396 with leading zeros. The default precision is 1. The result of converting a
16397 zero value with a precision of zero is no characters.
16398 <dt> f,F <dd>A double argument representing a floating-point number is converted to
16399 decimal notation in the style [-]ddd.ddd, where the number of digits after
16400 the decimal-point character is equal to the precision specification. If the
16401 precision is missing, it is taken as 6; if the precision is zero and the # flag is
16402 not specified, no decimal-point character appears. If a decimal-point
16403 character appears, at least one digit appears before it. The value is rounded to
16404 the appropriate number of digits.
16405 A double argument representing an infinity is converted in one of the styles
16406 [-]inf or [-]infinity -- which style is implementation-defined. A
16407 double argument representing a NaN is converted in one of the styles
16408 [-]nan or [-]nan(n-char-sequence) -- which style, and the meaning of
16409 any n-char-sequence, is implementation-defined. The F conversion specifier
16410 produces INF, INFINITY, or NAN instead of inf, infinity, or nan,
16412 <dt> e,E <dd>A double argument representing a floating-point number is converted in the
16413 style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
16414 argument is nonzero) before the decimal-point character and the number of
16415 digits after it is equal to the precision; if the precision is missing, it is taken as
16416 <!--page 331 -->
16417 6; if the precision is zero and the # flag is not specified, no decimal-point
16418 character appears. The value is rounded to the appropriate number of digits.
16419 The E conversion specifier produces a number with E instead of e
16420 introducing the exponent. The exponent always contains at least two digits,
16421 and only as many more digits as necessary to represent the exponent. If the
16422 value is zero, the exponent is zero.
16423 A double argument representing an infinity or NaN is converted in the style
16424 of an f or F conversion specifier.
16425 <dt> g,G <dd>A double argument representing a floating-point number is converted in
16426 style f or e (or in style F or E in the case of a G conversion specifier),
16427 depending on the value converted and the precision. Let P equal the
16428 precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
16429 Then, if a conversion with style E would have an exponent of X:
16430 <ul>
16431 <li> if P > X >= -4, the conversion is with style f (or F) and precision
16432 P - (X + 1).
16433 <li> otherwise, the conversion is with style e (or E) and precision P - 1.
16434 </ul>
16435 Finally, unless the # flag is used, any trailing zeros are removed from the
16436 fractional portion of the result and the decimal-point character is removed if
16437 there is no fractional portion remaining.
16438 A double argument representing an infinity or NaN is converted in the style
16439 of an f or F conversion specifier.
16440 <dt> a,A <dd>A double argument representing a floating-point number is converted in the
16441 style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
16442 nonzero if the argument is a normalized floating-point number and is
16443 otherwise unspecified) before the decimal-point character<sup><a href="#note278"><b>278)</b></a></sup> and the number
16444 of hexadecimal digits after it is equal to the precision; if the precision is
16445 missing and FLT_RADIX is a power of 2, then the precision is sufficient for
16446 an exact representation of the value; if the precision is missing and
16447 FLT_RADIX is not a power of 2, then the precision is sufficient to
16448 <!--page 332 -->
16449 distinguish<sup><a href="#note279"><b>279)</b></a></sup> values of type double, except that trailing zeros may be
16450 omitted; if the precision is zero and the # flag is not specified, no decimal-
16451 point character appears. The letters abcdef are used for a conversion and
16452 the letters ABCDEF for A conversion. The A conversion specifier produces a
16453 number with X and P instead of x and p. The exponent always contains at
16454 least one digit, and only as many more digits as necessary to represent the
16455 decimal exponent of 2. If the value is zero, the exponent is zero.
16456 A double argument representing an infinity or NaN is converted in the style
16457 of an f or F conversion specifier.
16458 <dt> c <dd>If no l length modifier is present, the int argument is converted to an
16459 unsigned char, and the resulting character is written.
16460 If an l length modifier is present, the wint_t argument is converted as if by
16461 an ls conversion specification with no precision and an argument that points
16462 to the initial element of a two-element array of wchar_t, the first element
16463 containing the wint_t argument to the lc conversion specification and the
16464 second a null wide character.
16465 <dt> s <dd>If no l length modifier is present, the argument shall be a pointer to the initial
16466 element of an array of character type.<sup><a href="#note280"><b>280)</b></a></sup> Characters from the array are
16467 written up to (but not including) the terminating null character. If the
16468 precision is specified, no more than that many bytes are written. If the
16469 precision is not specified or is greater than the size of the array, the array shall
16470 contain a null character.
16471 If an l length modifier is present, the argument shall be a pointer to the initial
16472 element of an array of wchar_t type. Wide characters from the array are
16473 converted to multibyte characters (each as if by a call to the wcrtomb
16474 function, with the conversion state described by an mbstate_t object
16475 initialized to zero before the first wide character is converted) up to and
16476 including a terminating null wide character. The resulting multibyte
16477 characters are written up to (but not including) the terminating null character
16478 (byte). If no precision is specified, the array shall contain a null wide
16479 character. If a precision is specified, no more than that many bytes are
16480 written (including shift sequences, if any), and the array shall contain a null
16481 wide character if, to equal the multibyte character sequence length given by
16482 <!--page 333 -->
16483 the precision, the function would need to access a wide character one past the
16484 end of the array. In no case is a partial multibyte character written.<sup><a href="#note281"><b>281)</b></a></sup>
16485 <dt> p <dd>The argument shall be a pointer to void. The value of the pointer is
16486 converted to a sequence of printing characters, in an implementation-defined
16487 manner.
16488 <dt> n <dd>The argument shall be a pointer to signed integer into which is written the
16489 number of characters written to the output stream so far by this call to
16490 fprintf. No argument is converted, but one is consumed. If the conversion
16491 specification includes any flags, a field width, or a precision, the behavior is
16492 undefined.
16493 <dt> % <dd>A % character is written. No argument is converted. The complete
16494 conversion specification shall be %%.
16495 </dl>
16497 If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note282"><b>282)</b></a></sup> If any argument is
16498 not the correct type for the corresponding conversion specification, the behavior is
16499 undefined.
16501 In no case does a nonexistent or small field width cause truncation of a field; if the result
16502 of a conversion is wider than the field width, the field is expanded to contain the
16503 conversion result.
16505 For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
16506 to a hexadecimal floating number with the given precision.
16507 <p><b>Recommended practice</b>
16509 For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
16510 representable in the given precision, the result should be one of the two adjacent numbers
16511 in hexadecimal floating style with the given precision, with the extra stipulation that the
16512 error should have a correct sign for the current rounding direction.
16514 For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
16515 DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note283"><b>283)</b></a></sup> If the number of
16516 significant decimal digits is more than DECIMAL_DIG but the source value is exactly
16517 representable with DECIMAL_DIG digits, then the result should be an exact
16518 representation with trailing zeros. Otherwise, the source value is bounded by two
16519 adjacent decimal strings L < U, both having DECIMAL_DIG significant digits; the value
16522 <!--page 334 -->
16523 of the resultant decimal string D should satisfy L <= D <= U, with the extra stipulation that
16524 the error should have a correct sign for the current rounding direction.
16525 <p><b>Returns</b>
16527 The fprintf function returns the number of characters transmitted, or a negative value
16528 if an output or encoding error occurred.
16529 <p><b>Environmental limits</b>
16531 The number of characters that can be produced by any single conversion shall be at least
16532 4095.
16534 EXAMPLE 1 To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
16535 places:
16536 <pre>
16539 /* ... */
16540 char *weekday, *month; // pointers to strings
16541 int day, hour, min;
16543 weekday, month, day, hour, min);
16545 </pre>
16548 EXAMPLE 2 In this example, multibyte characters do not have a state-dependent encoding, and the
16549 members of the extended character set that consist of more than one byte each consist of exactly two bytes,
16550 the first of which is denoted here by a # and the second by an uppercase letter.
16552 Given the following wide string with length seven,
16553 <pre>
16555 </pre>
16556 the seven calls
16557 <pre>
16565 </pre>
16566 will print the following seven lines:
16567 <pre>
16568 |1234567890123|
16569 | #X#Yabc#Z#W|
16570 |#X#Yabc#Z |
16571 | #X#Yabc#Z|
16572 | #X#Yabc#Z#W|
16573 | abc#Z#W|
16574 | #Z|
16575 </pre>
16577 <p><b> Forward references</b>: conversion state (<a href="#7.29.6">7.29.6</a>), the wcrtomb function (<a href="#7.29.6.3.3">7.29.6.3.3</a>).
16578 <!--page 335 -->
16580 <p><b>Footnotes</b>
16581 <p><small><a name="note275" href="#note275">275)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
16582 </small>
16583 <p><small><a name="note276" href="#note276">276)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
16584 include a minus sign.
16585 </small>
16586 <p><small><a name="note277" href="#note277">277)</a> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
16587 the # and 0 flag characters have no effect.
16588 </small>
16589 <p><small><a name="note278" href="#note278">278)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
16590 that subsequent digits align to nibble (4-bit) boundaries.
16591 </small>
16592 <p><small><a name="note279" href="#note279">279)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 > b n where b is
16593 FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
16594 might suffice depending on the implementation's scheme for determining the digit to the left of the
16595 decimal-point character.
16596 </small>
16597 <p><small><a name="note280" href="#note280">280)</a> No special provisions are made for multibyte characters.
16598 </small>
16599 <p><small><a name="note281" href="#note281">281)</a> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
16600 </small>
16601 <p><small><a name="note282" href="#note282">282)</a> See ''future library directions'' (<a href="#7.31.11">7.31.11</a>).
16602 </small>
16603 <p><small><a name="note283" href="#note283">283)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
16604 given format specifier. The number of significant digits is determined by the format specifier, and in
16605 the case of fixed-point conversion by the source value as well.
16606 </small>
16610 <p><b>Synopsis</b>
16612 <pre>
16614 int fscanf(FILE * restrict stream,
16615 const char * restrict format, ...);
16616 </pre>
16617 <p><b>Description</b>
16619 The fscanf function reads input from the stream pointed to by stream, under control
16620 of the string pointed to by format that specifies the admissible input sequences and how
16621 they are to be converted for assignment, using subsequent arguments as pointers to the
16622 objects to receive the converted input. If there are insufficient arguments for the format,
16623 the behavior is undefined. If the format is exhausted while arguments remain, the excess
16624 arguments are evaluated (as always) but are otherwise ignored.
16626 The format shall be a multibyte character sequence, beginning and ending in its initial
16627 shift state. The format is composed of zero or more directives: one or more white-space
16628 characters, an ordinary multibyte character (neither % nor a white-space character), or a
16629 conversion specification. Each conversion specification is introduced by the character %.
16630 After the %, the following appear in sequence:
16631 <ul>
16632 <li> An optional assignment-suppressing character *.
16633 <li> An optional decimal integer greater than zero that specifies the maximum field width
16634 (in characters).
16635 <li> An optional length modifier that specifies the size of the receiving object.
16636 <li> A conversion specifier character that specifies the type of conversion to be applied.
16637 </ul>
16639 The fscanf function executes each directive of the format in turn. When all directives
16640 have been executed, or if a directive fails (as detailed below), the function returns.
16641 Failures are described as input failures (due to the occurrence of an encoding error or the
16642 unavailability of input characters), or matching failures (due to inappropriate input).
16644 A directive composed of white-space character(s) is executed by reading input up to the
16645 first non-white-space character (which remains unread), or until no more characters can
16646 be read. The directive never fails.
16648 A directive that is an ordinary multibyte character is executed by reading the next
16649 characters of the stream. If any of those characters differ from the ones composing the
16650 directive, the directive fails and the differing and subsequent characters remain unread.
16651 Similarly, if end-of-file, an encoding error, or a read error prevents a character from being
16652 read, the directive fails.
16654 A directive that is a conversion specification defines a set of matching input sequences, as
16655 described below for each specifier. A conversion specification is executed in the
16656 <!--page 336 -->
16657 following steps:
16659 Input white-space characters (as specified by the isspace function) are skipped, unless
16660 the specification includes a [, c, or n specifier.<sup><a href="#note284"><b>284)</b></a></sup>
16662 An input item is read from the stream, unless the specification includes an n specifier. An
16663 input item is defined as the longest sequence of input characters which does not exceed
16664 any specified field width and which is, or is a prefix of, a matching input sequence.<sup><a href="#note285"><b>285)</b></a></sup>
16665 The first character, if any, after the input item remains unread. If the length of the input
16666 item is zero, the execution of the directive fails; this condition is a matching failure unless
16667 end-of-file, an encoding error, or a read error prevented input from the stream, in which
16668 case it is an input failure.
16670 Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
16671 count of input characters) is converted to a type appropriate to the conversion specifier. If
16672 the input item is not a matching sequence, the execution of the directive fails: this
16673 condition is a matching failure. Unless assignment suppression was indicated by a *, the
16674 result of the conversion is placed in the object pointed to by the first argument following
16675 the format argument that has not already received a conversion result. If this object
16676 does not have an appropriate type, or if the result of the conversion cannot be represented
16677 in the object, the behavior is undefined.
16679 The length modifiers and their meanings are:
16680 <dl>
16681 <dt> hh <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
16682 to an argument with type pointer to signed char or unsigned char.
16683 <dt> h <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
16684 to an argument with type pointer to short int or unsigned short
16685 int.
16686 <dt> l (ell) <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
16687 to an argument with type pointer to long int or unsigned long
16688 int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
16689 an argument with type pointer to double; or that a following c, s, or [
16690 conversion specifier applies to an argument with type pointer to wchar_t.
16691 <dt> ll (ell-ell) <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
16692 to an argument with type pointer to long long int or unsigned
16693 long long int.
16694 <!--page 337 -->
16695 <dt> j <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
16696 to an argument with type pointer to intmax_t or uintmax_t.
16697 <dt> z <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
16698 to an argument with type pointer to size_t or the corresponding signed
16699 integer type.
16700 <dt> t <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
16701 to an argument with type pointer to ptrdiff_t or the corresponding
16702 unsigned integer type.
16703 <dt> L <dd>Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
16704 applies to an argument with type pointer to long double.
16705 </dl>
16706 If a length modifier appears with any conversion specifier other than as specified above,
16707 the behavior is undefined.
16709 The conversion specifiers and their meanings are:
16710 <dl>
16711 <dt> d <dd>Matches an optionally signed decimal integer, whose format is the same as
16712 expected for the subject sequence of the strtol function with the value 10
16713 for the base argument. The corresponding argument shall be a pointer to
16714 signed integer.
16715 <dt> i <dd>Matches an optionally signed integer, whose format is the same as expected
16716 for the subject sequence of the strtol function with the value 0 for the
16717 base argument. The corresponding argument shall be a pointer to signed
16718 integer.
16719 <dt> o <dd>Matches an optionally signed octal integer, whose format is the same as
16720 expected for the subject sequence of the strtoul function with the value 8
16721 for the base argument. The corresponding argument shall be a pointer to
16722 unsigned integer.
16723 <dt> u <dd>Matches an optionally signed decimal integer, whose format is the same as
16724 expected for the subject sequence of the strtoul function with the value 10
16725 for the base argument. The corresponding argument shall be a pointer to
16726 unsigned integer.
16727 <dt> x <dd>Matches an optionally signed hexadecimal integer, whose format is the same
16728 as expected for the subject sequence of the strtoul function with the value
16729 16 for the base argument. The corresponding argument shall be a pointer to
16730 unsigned integer.
16731 <dt> a,e,f,g <dd>Matches an optionally signed floating-point number, infinity, or NaN, whose
16732 <!--page 338 -->
16733 format is the same as expected for the subject sequence of the strtod
16734 function. The corresponding argument shall be a pointer to floating.
16735 <dt> c <dd>Matches a sequence of characters of exactly the number specified by the field
16736 width (1 if no field width is present in the directive).<sup><a href="#note286"><b>286)</b></a></sup>
16737 If no l length modifier is present, the corresponding argument shall be a
16738 pointer to the initial element of a character array large enough to accept the
16739 sequence. No null character is added.
16740 If an l length modifier is present, the input shall be a sequence of multibyte
16741 characters that begins in the initial shift state. Each multibyte character in the
16742 sequence is converted to a wide character as if by a call to the mbrtowc
16743 function, with the conversion state described by an mbstate_t object
16744 initialized to zero before the first multibyte character is converted. The
16745 corresponding argument shall be a pointer to the initial element of an array of
16746 wchar_t large enough to accept the resulting sequence of wide characters.
16747 No null wide character is added.
16748 <dt> s <dd>Matches a sequence of non-white-space characters.<sup><a href="#note286"><b>286)</b></a></sup>
16749 If no l length modifier is present, the corresponding argument shall be a
16750 pointer to the initial element of a character array large enough to accept the
16751 sequence and a terminating null character, which will be added automatically.
16752 If an l length modifier is present, the input shall be a sequence of multibyte
16753 characters that begins in the initial shift state. Each multibyte character is
16754 converted to a wide character as if by a call to the mbrtowc function, with
16755 the conversion state described by an mbstate_t object initialized to zero
16756 before the first multibyte character is converted. The corresponding argument
16757 shall be a pointer to the initial element of an array of wchar_t large enough
16758 to accept the sequence and the terminating null wide character, which will be
16759 added automatically.
16760 <dt> [ <dd>Matches a nonempty sequence of characters from a set of expected characters
16762 If no l length modifier is present, the corresponding argument shall be a
16763 pointer to the initial element of a character array large enough to accept the
16764 sequence and a terminating null character, which will be added automatically.
16765 If an l length modifier is present, the input shall be a sequence of multibyte
16766 characters that begins in the initial shift state. Each multibyte character is
16767 converted to a wide character as if by a call to the mbrtowc function, with
16768 the conversion state described by an mbstate_t object initialized to zero
16769 <!--page 339 -->
16770 before the first multibyte character is converted. The corresponding argument
16771 shall be a pointer to the initial element of an array of wchar_t large enough
16772 to accept the sequence and the terminating null wide character, which will be
16773 added automatically.
16774 The conversion specifier includes all subsequent characters in the format
16775 string, up to and including the matching right bracket (]). The characters
16776 between the brackets (the scanlist) compose the scanset, unless the character
16777 after the left bracket is a circumflex (^), in which case the scanset contains all
16778 characters that do not appear in the scanlist between the circumflex and the
16779 right bracket. If the conversion specifier begins with [] or [^], the right
16780 bracket character is in the scanlist and the next following right bracket
16781 character is the matching right bracket that ends the specification; otherwise
16782 the first following right bracket character is the one that ends the
16783 specification. If a - character is in the scanlist and is not the first, nor the
16784 second where the first character is a ^, nor the last character, the behavior is
16785 implementation-defined.
16786 <dt> p <dd>Matches an implementation-defined set of sequences, which should be the
16787 same as the set of sequences that may be produced by the %p conversion of
16788 the fprintf function. The corresponding argument shall be a pointer to a
16789 pointer to void. The input item is converted to a pointer value in an
16790 implementation-defined manner. If the input item is a value converted earlier
16791 during the same program execution, the pointer that results shall compare
16792 equal to that value; otherwise the behavior of the %p conversion is undefined.
16793 <dt> n <dd>No input is consumed. The corresponding argument shall be a pointer to
16794 signed integer into which is to be written the number of characters read from
16795 the input stream so far by this call to the fscanf function. Execution of a
16796 %n directive does not increment the assignment count returned at the
16797 completion of execution of the fscanf function. No argument is converted,
16798 but one is consumed. If the conversion specification includes an assignment-
16799 suppressing character or a field width, the behavior is undefined.
16800 <dt> % <dd>Matches a single % character; no conversion or assignment occurs. The
16801 complete conversion specification shall be %%.
16802 </dl>
16804 If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note287"><b>287)</b></a></sup>
16806 The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
16807 respectively, a, e, f, g, and x.
16811 <!--page 340 -->
16813 Trailing white space (including new-line characters) is left unread unless matched by a
16814 directive. The success of literal matches and suppressed assignments is not directly
16815 determinable other than via the %n directive.
16816 <p><b>Returns</b>
16818 The fscanf function returns the value of the macro EOF if an input failure occurs
16819 before the first conversion (if any) has completed. Otherwise, the function returns the
16820 number of input items assigned, which can be fewer than provided for, or even zero, in
16821 the event of an early matching failure.
16823 EXAMPLE 1 The call:
16824 <pre>
16826 /* ... */
16827 int n, i; float x; char name[50];
16829 </pre>
16830 with the input line:
16831 <pre>
16832 25 54.32E-1 thompson
16833 </pre>
16834 will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
16835 thompson\0.
16838 EXAMPLE 2 The call:
16839 <pre>
16841 /* ... */
16842 int i; float x; char name[50];
16844 </pre>
16845 with input:
16846 <pre>
16847 56789 0123 56a72
16848 </pre>
16849 will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
16850 sequence 56\0. The next character read from the input stream will be a.
16853 EXAMPLE 3 To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
16854 <pre>
16856 /* ... */
16857 int count; float quant; char units[21], item[21];
16858 do {
16861 } while (!feof(stdin) && !ferror(stdin));
16862 </pre>
16864 If the stdin stream contains the following lines:
16865 <!--page 341 -->
16866 <pre>
16867 2 quarts of oil
16868 -12.8degrees Celsius
16869 lots of luck
16870 10.0LBS of
16871 dirt
16872 100ergs of energy
16873 </pre>
16874 the execution of the above example will be analogous to the following assignments:
16875 <pre>
16877 count = 3;
16882 count = 3;
16884 count = EOF;
16885 </pre>
16888 EXAMPLE 4 In:
16889 <pre>
16891 /* ... */
16892 int d1, d2, n1, n2, i;
16894 </pre>
16895 the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure, the value
16896 of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
16899 EXAMPLE 5 The call:
16900 <pre>
16902 /* ... */
16903 int n, i;
16905 </pre>
16906 will assign to n the value 1 and to i the value 42 because input white-space characters are skipped for both
16907 the % and d conversion specifiers.
16910 EXAMPLE 6 In these examples, multibyte characters do have a state-dependent encoding, and the
16911 members of the extended character set that consist of more than one byte each consist of exactly two bytes,
16912 the first of which is denoted here by a # and the second by an uppercase letter, but are only recognized as
16913 such when in the alternate shift state. The shift sequences are denoted by ^ and $, in which the first causes
16914 entry into the alternate shift state.
16916 After the call:
16917 <pre>
16919 /* ... */
16920 char str[50];
16922 </pre>
16923 with the input line:
16924 <pre>
16925 a^#X#Y$ bc
16926 </pre>
16927 str will contain ^#X#Y$\0 assuming that none of the bytes of the shift sequences (or of the multibyte
16928 characters, in the more general case) appears to be a single-byte white-space character.
16930 In contrast, after the call:
16931 <!--page 342 -->
16932 <pre>
16935 /* ... */
16936 wchar_t wstr[50];
16938 </pre>
16939 with the same input line, wstr will contain the two wide characters that correspond to #X and #Y and a
16940 terminating null wide character.
16942 However, the call:
16943 <pre>
16946 /* ... */
16947 wchar_t wstr[50];
16949 </pre>
16950 with the same input line will return zero due to a matching failure against the $ sequence in the format
16951 string.
16953 Assuming that the first byte of the multibyte character #X is the same as the first byte of the multibyte
16954 character #Y, after the call:
16955 <pre>
16958 /* ... */
16959 wchar_t wstr[50];
16961 </pre>
16962 with the same input line, zero will again be returned, but stdin will be left with a partially consumed
16963 multibyte character.
16965 <p><b> Forward references</b>: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>), the
16966 strtol, strtoll, strtoul, and strtoull functions (<a href="#7.22.1.4">7.22.1.4</a>), conversion state
16969 <p><b>Footnotes</b>
16970 <p><small><a name="note284" href="#note284">284)</a> These white-space characters are not counted against a specified field width.
16971 </small>
16972 <p><small><a name="note285" href="#note285">285)</a> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
16973 that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
16974 </small>
16975 <p><small><a name="note286" href="#note286">286)</a> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
16976 conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
16977 resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
16978 </small>
16979 <p><small><a name="note287" href="#note287">287)</a> See ''future library directions'' (<a href="#7.31.11">7.31.11</a>).
16980 </small>
16984 <p><b>Synopsis</b>
16986 <pre>
16988 int printf(const char * restrict format, ...);
16989 </pre>
16990 <p><b>Description</b>
16992 The printf function is equivalent to fprintf with the argument stdout interposed
16993 before the arguments to printf.
16994 <p><b>Returns</b>
16996 The printf function returns the number of characters transmitted, or a negative value if
16997 an output or encoding error occurred.
16998 <!--page 343 -->
17002 <p><b>Synopsis</b>
17004 <pre>
17006 int scanf(const char * restrict format, ...);
17007 </pre>
17008 <p><b>Description</b>
17010 The scanf function is equivalent to fscanf with the argument stdin interposed
17011 before the arguments to scanf.
17012 <p><b>Returns</b>
17014 The scanf function returns the value of the macro EOF if an input failure occurs before
17015 the first conversion (if any) has completed. Otherwise, the scanf function returns the
17016 number of input items assigned, which can be fewer than provided for, or even zero, in
17017 the event of an early matching failure.
17021 <p><b>Synopsis</b>
17023 <pre>
17025 int snprintf(char * restrict s, size_t n,
17026 const char * restrict format, ...);
17027 </pre>
17028 <p><b>Description</b>
17030 The snprintf function is equivalent to fprintf, except that the output is written into
17031 an array (specified by argument s) rather than to a stream. If n is zero, nothing is written,
17032 and s may be a null pointer. Otherwise, output characters beyond the n-1st are
17033 discarded rather than being written to the array, and a null character is written at the end
17034 of the characters actually written into the array. If copying takes place between objects
17035 that overlap, the behavior is undefined.
17036 <p><b>Returns</b>
17038 The snprintf function returns the number of characters that would have been written
17039 had n been sufficiently large, not counting the terminating null character, or a negative
17040 value if an encoding error occurred. Thus, the null-terminated output has been
17041 completely written if and only if the returned value is nonnegative and less than n.
17045 <p><b>Synopsis</b>
17047 <!--page 344 -->
17048 <pre>
17050 int sprintf(char * restrict s,
17051 const char * restrict format, ...);
17052 </pre>
17053 <p><b>Description</b>
17055 The sprintf function is equivalent to fprintf, except that the output is written into
17056 an array (specified by the argument s) rather than to a stream. A null character is written
17057 at the end of the characters written; it is not counted as part of the returned value. If
17058 copying takes place between objects that overlap, the behavior is undefined.
17059 <p><b>Returns</b>
17061 The sprintf function returns the number of characters written in the array, not
17062 counting the terminating null character, or a negative value if an encoding error occurred.
17066 <p><b>Synopsis</b>
17068 <pre>
17070 int sscanf(const char * restrict s,
17071 const char * restrict format, ...);
17072 </pre>
17073 <p><b>Description</b>
17075 The sscanf function is equivalent to fscanf, except that input is obtained from a
17076 string (specified by the argument s) rather than from a stream. Reaching the end of the
17077 string is equivalent to encountering end-of-file for the fscanf function. If copying
17078 takes place between objects that overlap, the behavior is undefined.
17079 <p><b>Returns</b>
17081 The sscanf function returns the value of the macro EOF if an input failure occurs
17082 before the first conversion (if any) has completed. Otherwise, the sscanf function
17083 returns the number of input items assigned, which can be fewer than provided for, or even
17084 zero, in the event of an early matching failure.
17088 <p><b>Synopsis</b>
17090 <pre>
17093 int vfprintf(FILE * restrict stream,
17094 const char * restrict format,
17095 va_list arg);
17096 </pre>
17097 <p><b>Description</b>
17099 The vfprintf function is equivalent to fprintf, with the variable argument list
17100 replaced by arg, which shall have been initialized by the va_start macro (and
17101 possibly subsequent va_arg calls). The vfprintf function does not invoke the
17102 <!--page 345 -->
17104 <p><b>Returns</b>
17106 The vfprintf function returns the number of characters transmitted, or a negative
17107 value if an output or encoding error occurred.
17109 EXAMPLE The following shows the use of the vfprintf function in a general error-reporting routine.
17110 <pre>
17113 void error(char *function_name, char *format, ...)
17114 {
17115 va_list args;
17116 va_start(args, format);
17117 // print out name of function causing error
17119 // print out remainder of message
17120 vfprintf(stderr, format, args);
17121 va_end(args);
17122 }
17123 </pre>
17126 <p><b>Footnotes</b>
17127 <p><small><a name="note288" href="#note288">288)</a> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
17128 vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
17129 </small>
17133 <p><b>Synopsis</b>
17135 <pre>
17138 int vfscanf(FILE * restrict stream,
17139 const char * restrict format,
17140 va_list arg);
17141 </pre>
17142 <p><b>Description</b>
17144 The vfscanf function is equivalent to fscanf, with the variable argument list
17145 replaced by arg, which shall have been initialized by the va_start macro (and
17146 possibly subsequent va_arg calls). The vfscanf function does not invoke the
17148 <p><b>Returns</b>
17150 The vfscanf function returns the value of the macro EOF if an input failure occurs
17151 before the first conversion (if any) has completed. Otherwise, the vfscanf function
17152 returns the number of input items assigned, which can be fewer than provided for, or even
17153 zero, in the event of an early matching failure.
17157 <!--page 346 -->
17161 <p><b>Synopsis</b>
17163 <pre>
17166 int vprintf(const char * restrict format,
17167 va_list arg);
17168 </pre>
17169 <p><b>Description</b>
17171 The vprintf function is equivalent to printf, with the variable argument list
17172 replaced by arg, which shall have been initialized by the va_start macro (and
17173 possibly subsequent va_arg calls). The vprintf function does not invoke the
17175 <p><b>Returns</b>
17177 The vprintf function returns the number of characters transmitted, or a negative value
17178 if an output or encoding error occurred.
17182 <p><b>Synopsis</b>
17184 <pre>
17187 int vscanf(const char * restrict format,
17188 va_list arg);
17189 </pre>
17190 <p><b>Description</b>
17192 The vscanf function is equivalent to scanf, with the variable argument list replaced
17193 by arg, which shall have been initialized by the va_start macro (and possibly
17194 subsequent va_arg calls). The vscanf function does not invoke the va_end
17196 <p><b>Returns</b>
17198 The vscanf function returns the value of the macro EOF if an input failure occurs
17199 before the first conversion (if any) has completed. Otherwise, the vscanf function
17200 returns the number of input items assigned, which can be fewer than provided for, or even
17201 zero, in the event of an early matching failure.
17202 <!--page 347 -->
17206 <p><b>Synopsis</b>
17208 <pre>
17211 int vsnprintf(char * restrict s, size_t n,
17212 const char * restrict format,
17213 va_list arg);
17214 </pre>
17215 <p><b>Description</b>
17217 The vsnprintf function is equivalent to snprintf, with the variable argument list
17218 replaced by arg, which shall have been initialized by the va_start macro (and
17219 possibly subsequent va_arg calls). The vsnprintf function does not invoke the
17220 va_end macro.<sup><a href="#note288"><b>288)</b></a></sup> If copying takes place between objects that overlap, the behavior is
17221 undefined.
17222 <p><b>Returns</b>
17224 The vsnprintf function returns the number of characters that would have been written
17225 had n been sufficiently large, not counting the terminating null character, or a negative
17226 value if an encoding error occurred. Thus, the null-terminated output has been
17227 completely written if and only if the returned value is nonnegative and less than n.
17231 <p><b>Synopsis</b>
17233 <pre>
17236 int vsprintf(char * restrict s,
17237 const char * restrict format,
17238 va_list arg);
17239 </pre>
17240 <p><b>Description</b>
17242 The vsprintf function is equivalent to sprintf, with the variable argument list
17243 replaced by arg, which shall have been initialized by the va_start macro (and
17244 possibly subsequent va_arg calls). The vsprintf function does not invoke the
17245 va_end macro.<sup><a href="#note288"><b>288)</b></a></sup> If copying takes place between objects that overlap, the behavior is
17246 undefined.
17247 <p><b>Returns</b>
17249 The vsprintf function returns the number of characters written in the array, not
17250 counting the terminating null character, or a negative value if an encoding error occurred.
17251 <!--page 348 -->
17255 <p><b>Synopsis</b>
17257 <pre>
17260 int vsscanf(const char * restrict s,
17261 const char * restrict format,
17262 va_list arg);
17263 </pre>
17264 <p><b>Description</b>
17266 The vsscanf function is equivalent to sscanf, with the variable argument list
17267 replaced by arg, which shall have been initialized by the va_start macro (and
17268 possibly subsequent va_arg calls). The vsscanf function does not invoke the
17270 <p><b>Returns</b>
17272 The vsscanf function returns the value of the macro EOF if an input failure occurs
17273 before the first conversion (if any) has completed. Otherwise, the vsscanf function
17274 returns the number of input items assigned, which can be fewer than provided for, or even
17275 zero, in the event of an early matching failure.
17282 <p><b>Synopsis</b>
17284 <pre>
17286 int fgetc(FILE *stream);
17287 </pre>
17288 <p><b>Description</b>
17290 If the end-of-file indicator for the input stream pointed to by stream is not set and a
17291 next character is present, the fgetc function obtains that character as an unsigned
17292 char converted to an int and advances the associated file position indicator for the
17293 stream (if defined).
17294 <p><b>Returns</b>
17296 If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
17297 of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the
17298 fgetc function returns the next character from the input stream pointed to by stream.
17299 If a read error occurs, the error indicator for the stream is set and the fgetc function
17303 <!--page 349 -->
17305 <p><b>Footnotes</b>
17306 <p><small><a name="note289" href="#note289">289)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
17307 </small>
17311 <p><b>Synopsis</b>
17313 <pre>
17315 char *fgets(char * restrict s, int n,
17316 FILE * restrict stream);
17317 </pre>
17318 <p><b>Description</b>
17320 The fgets function reads at most one less than the number of characters specified by n
17321 from the stream pointed to by stream into the array pointed to by s. No additional
17322 characters are read after a new-line character (which is retained) or after end-of-file. A
17323 null character is written immediately after the last character read into the array.
17324 <p><b>Returns</b>
17326 The fgets function returns s if successful. If end-of-file is encountered and no
17327 characters have been read into the array, the contents of the array remain unchanged and a
17328 null pointer is returned. If a read error occurs during the operation, the array contents are
17329 indeterminate and a null pointer is returned.
17333 <p><b>Synopsis</b>
17335 <pre>
17337 int fputc(int c, FILE *stream);
17338 </pre>
17339 <p><b>Description</b>
17341 The fputc function writes the character specified by c (converted to an unsigned
17342 char) to the output stream pointed to by stream, at the position indicated by the
17343 associated file position indicator for the stream (if defined), and advances the indicator
17344 appropriately. If the file cannot support positioning requests, or if the stream was opened
17345 with append mode, the character is appended to the output stream.
17346 <p><b>Returns</b>
17348 The fputc function returns the character written. If a write error occurs, the error
17349 indicator for the stream is set and fputc returns EOF.
17353 <p><b>Synopsis</b>
17355 <!--page 350 -->
17356 <pre>
17358 int fputs(const char * restrict s,
17359 FILE * restrict stream);
17360 </pre>
17361 <p><b>Description</b>
17363 The fputs function writes the string pointed to by s to the stream pointed to by
17364 stream. The terminating null character is not written.
17365 <p><b>Returns</b>
17367 The fputs function returns EOF if a write error occurs; otherwise it returns a
17368 nonnegative value.
17372 <p><b>Synopsis</b>
17374 <pre>
17376 int getc(FILE *stream);
17377 </pre>
17378 <p><b>Description</b>
17380 The getc function is equivalent to fgetc, except that if it is implemented as a macro, it
17381 may evaluate stream more than once, so the argument should never be an expression
17382 with side effects.
17383 <p><b>Returns</b>
17385 The getc function returns the next character from the input stream pointed to by
17386 stream. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
17387 getc returns EOF. If a read error occurs, the error indicator for the stream is set and
17388 getc returns EOF.
17392 <p><b>Synopsis</b>
17394 <pre>
17396 int getchar(void);
17397 </pre>
17398 <p><b>Description</b>
17400 The getchar function is equivalent to getc with the argument stdin.
17401 <p><b>Returns</b>
17403 The getchar function returns the next character from the input stream pointed to by
17404 stdin. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
17405 getchar returns EOF. If a read error occurs, the error indicator for the stream is set and
17406 getchar returns EOF.
17407 <!--page 351 -->
17411 <p><b>Synopsis</b>
17413 <pre>
17415 int putc(int c, FILE *stream);
17416 </pre>
17417 <p><b>Description</b>
17419 The putc function is equivalent to fputc, except that if it is implemented as a macro, it
17420 may evaluate stream more than once, so that argument should never be an expression
17421 with side effects.
17422 <p><b>Returns</b>
17424 The putc function returns the character written. If a write error occurs, the error
17425 indicator for the stream is set and putc returns EOF.
17429 <p><b>Synopsis</b>
17431 <pre>
17433 int putchar(int c);
17434 </pre>
17435 <p><b>Description</b>
17437 The putchar function is equivalent to putc with the second argument stdout.
17438 <p><b>Returns</b>
17440 The putchar function returns the character written. If a write error occurs, the error
17441 indicator for the stream is set and putchar returns EOF.
17445 <p><b>Synopsis</b>
17447 <pre>
17449 int puts(const char *s);
17450 </pre>
17451 <p><b>Description</b>
17453 The puts function writes the string pointed to by s to the stream pointed to by stdout,
17454 and appends a new-line character to the output. The terminating null character is not
17455 written.
17456 <p><b>Returns</b>
17458 The puts function returns EOF if a write error occurs; otherwise it returns a nonnegative
17459 value.
17460 <!--page 352 -->
17464 <p><b>Synopsis</b>
17466 <pre>
17468 int ungetc(int c, FILE *stream);
17469 </pre>
17470 <p><b>Description</b>
17472 The ungetc function pushes the character specified by c (converted to an unsigned
17473 char) back onto the input stream pointed to by stream. Pushed-back characters will be
17474 returned by subsequent reads on that stream in the reverse order of their pushing. A
17475 successful intervening call (with the stream pointed to by stream) to a file positioning
17476 function (fseek, fsetpos, or rewind) discards any pushed-back characters for the
17477 stream. The external storage corresponding to the stream is unchanged.
17479 One character of pushback is guaranteed. If the ungetc function is called too many
17480 times on the same stream without an intervening read or file positioning operation on that
17481 stream, the operation may fail.
17483 If the value of c equals that of the macro EOF, the operation fails and the input stream is
17484 unchanged.
17486 A successful call to the ungetc function clears the end-of-file indicator for the stream.
17487 The value of the file position indicator for the stream after reading or discarding all
17488 pushed-back characters shall be the same as it was before the characters were pushed
17489 back. For a text stream, the value of its file position indicator after a successful call to the
17490 ungetc function is unspecified until all pushed-back characters are read or discarded.
17491 For a binary stream, its file position indicator is decremented by each successful call to
17492 the ungetc function; if its value was zero before a call, it is indeterminate after the
17494 <p><b>Returns</b>
17496 The ungetc function returns the character pushed back after conversion, or EOF if the
17497 operation fails.
17503 <!--page 353 -->
17505 <p><b>Footnotes</b>
17506 <p><small><a name="note290" href="#note290">290)</a> See ''future library directions'' (<a href="#7.31.11">7.31.11</a>).
17507 </small>
17514 <p><b>Synopsis</b>
17516 <pre>
17518 size_t fread(void * restrict ptr,
17519 size_t size, size_t nmemb,
17520 FILE * restrict stream);
17521 </pre>
17522 <p><b>Description</b>
17524 The fread function reads, into the array pointed to by ptr, up to nmemb elements
17525 whose size is specified by size, from the stream pointed to by stream. For each
17526 object, size calls are made to the fgetc function and the results stored, in the order
17527 read, in an array of unsigned char exactly overlaying the object. The file position
17528 indicator for the stream (if defined) is advanced by the number of characters successfully
17529 read. If an error occurs, the resulting value of the file position indicator for the stream is
17530 indeterminate. If a partial element is read, its value is indeterminate.
17531 <p><b>Returns</b>
17533 The fread function returns the number of elements successfully read, which may be
17534 less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero,
17535 fread returns zero and the contents of the array and the state of the stream remain
17536 unchanged.
17540 <p><b>Synopsis</b>
17542 <pre>
17544 size_t fwrite(const void * restrict ptr,
17545 size_t size, size_t nmemb,
17546 FILE * restrict stream);
17547 </pre>
17548 <p><b>Description</b>
17550 The fwrite function writes, from the array pointed to by ptr, up to nmemb elements
17551 whose size is specified by size, to the stream pointed to by stream. For each object,
17552 size calls are made to the fputc function, taking the values (in order) from an array of
17553 unsigned char exactly overlaying the object. The file position indicator for the
17554 stream (if defined) is advanced by the number of characters successfully written. If an
17555 error occurs, the resulting value of the file position indicator for the stream is
17556 indeterminate.
17557 <!--page 354 -->
17558 <p><b>Returns</b>
17560 The fwrite function returns the number of elements successfully written, which will be
17561 less than nmemb only if a write error is encountered. If size or nmemb is zero,
17562 fwrite returns zero and the state of the stream remains unchanged.
17569 <p><b>Synopsis</b>
17571 <pre>
17573 int fgetpos(FILE * restrict stream,
17574 fpos_t * restrict pos);
17575 </pre>
17576 <p><b>Description</b>
17578 The fgetpos function stores the current values of the parse state (if any) and file
17579 position indicator for the stream pointed to by stream in the object pointed to by pos.
17580 The values stored contain unspecified information usable by the fsetpos function for
17581 repositioning the stream to its position at the time of the call to the fgetpos function.
17582 <p><b>Returns</b>
17584 If successful, the fgetpos function returns zero; on failure, the fgetpos function
17585 returns nonzero and stores an implementation-defined positive value in errno.
17590 <p><b>Synopsis</b>
17592 <pre>
17594 int fseek(FILE *stream, long int offset, int whence);
17595 </pre>
17596 <p><b>Description</b>
17598 The fseek function sets the file position indicator for the stream pointed to by stream.
17599 If a read or write error occurs, the error indicator for the stream is set and fseek fails.
17601 For a binary stream, the new position, measured in characters from the beginning of the
17602 file, is obtained by adding offset to the position specified by whence. The specified
17603 position is the beginning of the file if whence is SEEK_SET, the current value of the file
17604 position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
17605 meaningfully support fseek calls with a whence value of SEEK_END.
17607 For a text stream, either offset shall be zero, or offset shall be a value returned by
17608 an earlier successful call to the ftell function on a stream associated with the same file
17609 and whence shall be SEEK_SET.
17610 <!--page 355 -->
17612 After determining the new position, a successful call to the fseek function undoes any
17613 effects of the ungetc function on the stream, clears the end-of-file indicator for the
17614 stream, and then establishes the new position. After a successful fseek call, the next
17615 operation on an update stream may be either input or output.
17616 <p><b>Returns</b>
17618 The fseek function returns nonzero only for a request that cannot be satisfied.
17623 <p><b>Synopsis</b>
17625 <pre>
17627 int fsetpos(FILE *stream, const fpos_t *pos);
17628 </pre>
17629 <p><b>Description</b>
17631 The fsetpos function sets the mbstate_t object (if any) and file position indicator
17632 for the stream pointed to by stream according to the value of the object pointed to by
17633 pos, which shall be a value obtained from an earlier successful call to the fgetpos
17634 function on a stream associated with the same file. If a read or write error occurs, the
17635 error indicator for the stream is set and fsetpos fails.
17637 A successful call to the fsetpos function undoes any effects of the ungetc function
17638 on the stream, clears the end-of-file indicator for the stream, and then establishes the new
17639 parse state and position. After a successful fsetpos call, the next operation on an
17640 update stream may be either input or output.
17641 <p><b>Returns</b>
17643 If successful, the fsetpos function returns zero; on failure, the fsetpos function
17644 returns nonzero and stores an implementation-defined positive value in errno.
17648 <p><b>Synopsis</b>
17650 <pre>
17652 long int ftell(FILE *stream);
17653 </pre>
17654 <p><b>Description</b>
17656 The ftell function obtains the current value of the file position indicator for the stream
17657 pointed to by stream. For a binary stream, the value is the number of characters from
17658 the beginning of the file. For a text stream, its file position indicator contains unspecified
17659 information, usable by the fseek function for returning the file position indicator for the
17660 stream to its position at the time of the ftell call; the difference between two such
17661 return values is not necessarily a meaningful measure of the number of characters written
17662 <!--page 356 -->
17663 or read.
17664 <p><b>Returns</b>
17666 If successful, the ftell function returns the current value of the file position indicator
17667 for the stream. On failure, the ftell function returns -1L and stores an
17668 implementation-defined positive value in errno.
17672 <p><b>Synopsis</b>
17674 <pre>
17676 void rewind(FILE *stream);
17677 </pre>
17678 <p><b>Description</b>
17680 The rewind function sets the file position indicator for the stream pointed to by
17681 stream to the beginning of the file. It is equivalent to
17682 <pre>
17683 (void)fseek(stream, 0L, SEEK_SET)
17684 </pre>
17685 except that the error indicator for the stream is also cleared.
17686 <p><b>Returns</b>
17688 The rewind function returns no value.
17695 <p><b>Synopsis</b>
17697 <pre>
17699 void clearerr(FILE *stream);
17700 </pre>
17701 <p><b>Description</b>
17703 The clearerr function clears the end-of-file and error indicators for the stream pointed
17704 to by stream.
17705 <p><b>Returns</b>
17707 The clearerr function returns no value.
17708 <!--page 357 -->
17712 <p><b>Synopsis</b>
17714 <pre>
17716 int feof(FILE *stream);
17717 </pre>
17718 <p><b>Description</b>
17720 The feof function tests the end-of-file indicator for the stream pointed to by stream.
17721 <p><b>Returns</b>
17723 The feof function returns nonzero if and only if the end-of-file indicator is set for
17724 stream.
17728 <p><b>Synopsis</b>
17730 <pre>
17732 int ferror(FILE *stream);
17733 </pre>
17734 <p><b>Description</b>
17736 The ferror function tests the error indicator for the stream pointed to by stream.
17737 <p><b>Returns</b>
17739 The ferror function returns nonzero if and only if the error indicator is set for
17740 stream.
17744 <p><b>Synopsis</b>
17746 <pre>
17748 void perror(const char *s);
17749 </pre>
17750 <p><b>Description</b>
17752 The perror function maps the error number in the integer expression errno to an
17753 error message. It writes a sequence of characters to the standard error stream thus: first
17754 (if s is not a null pointer and the character pointed to by s is not the null character), the
17755 string pointed to by s followed by a colon (:) and a space; then an appropriate error
17756 message string followed by a new-line character. The contents of the error message
17757 strings are the same as those returned by the strerror function with argument errno.
17758 <p><b>Returns</b>
17760 The perror function returns no value.
17762 <!--page 358 -->
17767 The header <a href="#7.22"><stdlib.h></a> declares five types and several functions of general utility, and
17771 <pre>
17772 div_t
17773 </pre>
17774 which is a structure type that is the type of the value returned by the div function,
17775 <pre>
17776 ldiv_t
17777 </pre>
17778 which is a structure type that is the type of the value returned by the ldiv function, and
17779 <pre>
17780 lldiv_t
17781 </pre>
17782 which is a structure type that is the type of the value returned by the lldiv function.
17785 <pre>
17786 EXIT_FAILURE
17787 </pre>
17788 and
17789 <pre>
17790 EXIT_SUCCESS
17791 </pre>
17792 which expand to integer constant expressions that can be used as the argument to the
17793 exit function to return unsuccessful or successful termination status, respectively, to the
17794 host environment;
17795 <pre>
17796 RAND_MAX
17797 </pre>
17798 which expands to an integer constant expression that is the maximum value returned by
17799 the rand function; and
17800 <pre>
17801 MB_CUR_MAX
17802 </pre>
17803 which expands to a positive integer expression with type size_t that is the maximum
17804 number of bytes in a multibyte character for the extended character set specified by the
17805 current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
17810 <!--page 359 -->
17812 <p><b>Footnotes</b>
17813 <p><small><a name="note291" href="#note291">291)</a> See ''future library directions'' (<a href="#7.31.12">7.31.12</a>).
17814 </small>
17819 The functions atof, atoi, atol, and atoll need not affect the value of the integer
17820 expression errno on an error. If the value of the result cannot be represented, the
17821 behavior is undefined.
17825 <p><b>Synopsis</b>
17827 <pre>
17829 double atof(const char *nptr);
17830 </pre>
17831 <p><b>Description</b>
17833 The atof function converts the initial portion of the string pointed to by nptr to
17834 double representation. Except for the behavior on error, it is equivalent to
17835 <pre>
17836 strtod(nptr, (char **)NULL)
17837 </pre>
17838 <p><b>Returns</b>
17840 The atof function returns the converted value.
17841 <p><b> Forward references</b>: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
17845 <p><b>Synopsis</b>
17847 <pre>
17849 int atoi(const char *nptr);
17850 long int atol(const char *nptr);
17851 long long int atoll(const char *nptr);
17852 </pre>
17853 <p><b>Description</b>
17855 The atoi, atol, and atoll functions convert the initial portion of the string pointed
17856 to by nptr to int, long int, and long long int representation, respectively.
17857 Except for the behavior on error, they are equivalent to
17858 <pre>
17859 atoi: (int)strtol(nptr, (char **)NULL, 10)
17860 atol: strtol(nptr, (char **)NULL, 10)
17861 atoll: strtoll(nptr, (char **)NULL, 10)
17862 </pre>
17863 <p><b>Returns</b>
17865 The atoi, atol, and atoll functions return the converted value.
17866 <p><b> Forward references</b>: the strtol, strtoll, strtoul, and strtoull functions
17868 <!--page 360 -->
17871 <h5><a name="7.22.1.3" href="#7.22.1.3">7.22.1.3 The strtod, strtof, and strtold functions</a></h5>
17872 <p><b>Synopsis</b>
17874 <pre>
17876 double strtod(const char * restrict nptr,
17877 char ** restrict endptr);
17878 float strtof(const char * restrict nptr,
17879 char ** restrict endptr);
17880 long double strtold(const char * restrict nptr,
17881 char ** restrict endptr);
17882 </pre>
17883 <p><b>Description</b>
17885 The strtod, strtof, and strtold functions convert the initial portion of the string
17886 pointed to by nptr to double, float, and long double representation,
17887 respectively. First, they decompose the input string into three parts: an initial, possibly
17888 empty, sequence of white-space characters (as specified by the isspace function), a
17889 subject sequence resembling a floating-point constant or representing an infinity or NaN;
17890 and a final string of one or more unrecognized characters, including the terminating null
17891 character of the input string. Then, they attempt to convert the subject sequence to a
17892 floating-point number, and return the result.
17894 The expected form of the subject sequence is an optional plus or minus sign, then one of
17895 the following:
17896 <ul>
17897 <li> a nonempty sequence of decimal digits optionally containing a decimal-point
17899 <li> a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
17900 decimal-point character, then an optional binary exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
17901 <li> INF or INFINITY, ignoring case
17902 <li> NAN or NAN(n-char-sequence<sub>opt</sub>), ignoring case in the NAN part, where:
17903 <pre>
17904 n-char-sequence:
17905 digit
17906 nondigit
17907 n-char-sequence digit
17908 n-char-sequence nondigit
17909 </pre>
17910 </ul>
17911 The subject sequence is defined as the longest initial subsequence of the input string,
17912 starting with the first non-white-space character, that is of the expected form. The subject
17913 sequence contains no characters if the input string is not of the expected form.
17915 If the subject sequence has the expected form for a floating-point number, the sequence of
17916 characters starting with the first digit or the decimal-point character (whichever occurs
17917 first) is interpreted as a floating constant according to the rules of <a href="#6.4.4.2">6.4.4.2</a>, except that the
17918 <!--page 361 -->
17919 decimal-point character is used in place of a period, and that if neither an exponent part
17920 nor a decimal-point character appears in a decimal floating point number, or if a binary
17921 exponent part does not appear in a hexadecimal floating point number, an exponent part
17922 of the appropriate type with value zero is assumed to follow the last digit in the string. If
17923 the subject sequence begins with a minus sign, the sequence is interpreted as negated.<sup><a href="#note292"><b>292)</b></a></sup>
17924 A character sequence INF or INFINITY is interpreted as an infinity, if representable in
17925 the return type, else like a floating constant that is too large for the range of the return
17926 type. A character sequence NAN or NAN(n-char-sequence<sub>opt</sub>) is interpreted as a quiet
17927 NaN, if supported in the return type, else like a subject sequence part that does not have
17928 the expected form; the meaning of the n-char sequence is implementation-defined.<sup><a href="#note293"><b>293)</b></a></sup> A
17929 pointer to the final string is stored in the object pointed to by endptr, provided that
17930 endptr is not a null pointer.
17932 If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
17933 value resulting from the conversion is correctly rounded.
17936 accepted.
17938 If the subject sequence is empty or does not have the expected form, no conversion is
17939 performed; the value of nptr is stored in the object pointed to by endptr, provided
17940 that endptr is not a null pointer.
17941 <p><b>Recommended practice</b>
17943 If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
17944 the result is not exactly representable, the result should be one of the two numbers in the
17945 appropriate internal format that are adjacent to the hexadecimal floating source value,
17946 with the extra stipulation that the error should have a correct sign for the current rounding
17947 direction.
17949 If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
17950 <a href="#7.7"><float.h></a>) significant digits, the result should be correctly rounded. If the subject
17951 sequence D has the decimal form and more than DECIMAL_DIG significant digits,
17952 consider the two bounding, adjacent decimal strings L and U, both having
17953 DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L <= D <= U.
17954 The result should be one of the (equal or adjacent) values that would be obtained by
17955 correctly rounding L and U according to the current rounding direction, with the extra
17957 <!--page 362 -->
17958 stipulation that the error with respect to D should have a correct sign for the current
17960 <p><b>Returns</b>
17962 The functions return the converted value, if any. If no conversion could be performed,
17963 zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
17964 plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
17965 return type and sign of the value), and the value of the macro ERANGE is stored in
17966 errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
17967 no greater than the smallest normalized positive number in the return type; whether
17968 errno acquires the value ERANGE is implementation-defined.
17970 <p><b>Footnotes</b>
17971 <p><small><a name="note292" href="#note292">292)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
17972 negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
17973 methods may yield different results if rounding is toward positive or negative infinity. In either case,
17974 the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
17975 </small>
17976 <p><small><a name="note293" href="#note293">293)</a> An implementation may use the n-char sequence to determine extra information to be represented in
17977 the NaN's significand.
17978 </small>
17979 <p><small><a name="note294" href="#note294">294)</a> DECIMAL_DIG, defined in <a href="#7.7"><float.h></a>, should be sufficiently large that L and U will usually round
17980 to the same internal floating value, but if not will round to adjacent values.
17981 </small>
17984 <h5><a name="7.22.1.4" href="#7.22.1.4">7.22.1.4 The strtol, strtoll, strtoul, and strtoull functions</a></h5>
17985 <p><b>Synopsis</b>
17987 <pre>
17989 long int strtol(
17990 const char * restrict nptr,
17991 char ** restrict endptr,
17992 int base);
17993 long long int strtoll(
17994 const char * restrict nptr,
17995 char ** restrict endptr,
17996 int base);
17997 unsigned long int strtoul(
17998 const char * restrict nptr,
17999 char ** restrict endptr,
18000 int base);
18001 unsigned long long int strtoull(
18002 const char * restrict nptr,
18003 char ** restrict endptr,
18004 int base);
18005 </pre>
18006 <p><b>Description</b>
18008 The strtol, strtoll, strtoul, and strtoull functions convert the initial
18009 portion of the string pointed to by nptr to long int, long long int, unsigned
18010 long int, and unsigned long long int representation, respectively. First,
18011 they decompose the input string into three parts: an initial, possibly empty, sequence of
18012 white-space characters (as specified by the isspace function), a subject sequence
18015 <!--page 363 -->
18016 resembling an integer represented in some radix determined by the value of base, and a
18017 final string of one or more unrecognized characters, including the terminating null
18018 character of the input string. Then, they attempt to convert the subject sequence to an
18019 integer, and return the result.
18021 If the value of base is zero, the expected form of the subject sequence is that of an
18022 integer constant as described in <a href="#6.4.4.1">6.4.4.1</a>, optionally preceded by a plus or minus sign, but
18023 not including an integer suffix. If the value of base is between 2 and 36 (inclusive), the
18024 expected form of the subject sequence is a sequence of letters and digits representing an
18025 integer with the radix specified by base, optionally preceded by a plus or minus sign,
18026 but not including an integer suffix. The letters from a (or A) through z (or Z) are
18027 ascribed the values 10 through 35; only letters and digits whose ascribed values are less
18028 than that of base are permitted. If the value of base is 16, the characters 0x or 0X may
18029 optionally precede the sequence of letters and digits, following the sign if present.
18031 The subject sequence is defined as the longest initial subsequence of the input string,
18032 starting with the first non-white-space character, that is of the expected form. The subject
18033 sequence contains no characters if the input string is empty or consists entirely of white
18034 space, or if the first non-white-space character is other than a sign or a permissible letter
18035 or digit.
18037 If the subject sequence has the expected form and the value of base is zero, the sequence
18038 of characters starting with the first digit is interpreted as an integer constant according to
18039 the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the value of base
18040 is between 2 and 36, it is used as the base for conversion, ascribing to each letter its value
18041 as given above. If the subject sequence begins with a minus sign, the value resulting from
18042 the conversion is negated (in the return type). A pointer to the final string is stored in the
18043 object pointed to by endptr, provided that endptr is not a null pointer.
18046 accepted.
18048 If the subject sequence is empty or does not have the expected form, no conversion is
18049 performed; the value of nptr is stored in the object pointed to by endptr, provided
18050 that endptr is not a null pointer.
18051 <p><b>Returns</b>
18053 The strtol, strtoll, strtoul, and strtoull functions return the converted
18054 value, if any. If no conversion could be performed, zero is returned. If the correct value
18055 is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
18056 LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
18057 and sign of the value, if any), and the value of the macro ERANGE is stored in errno.
18058 <!--page 364 -->
18061 <h4><a name="7.22.2" href="#7.22.2">7.22.2 Pseudo-random sequence generation functions</a></h4>
18065 <p><b>Synopsis</b>
18067 <pre>
18069 int rand(void);
18070 </pre>
18071 <p><b>Description</b>
18073 The rand function computes a sequence of pseudo-random integers in the range 0 to
18076 The rand function is not required to avoid data races with other calls to pseudo-random
18077 sequence generation functions. The implementation shall behave as if no library function
18078 calls the rand function.
18079 <p><b>Returns</b>
18081 The rand function returns a pseudo-random integer.
18082 <p><b>Environmental limits</b>
18084 The value of the RAND_MAX macro shall be at least 32767.
18086 <p><b>Footnotes</b>
18087 <p><small><a name="note295" href="#note295">295)</a> There are no guarantees as to the quality of the random sequence produced and some implementations
18088 are known to produce sequences with distressingly non-random low-order bits. Applications with
18089 particular requirements should use a generator that is known to be sufficient for their needs.
18090 </small>
18094 <p><b>Synopsis</b>
18096 <pre>
18098 void srand(unsigned int seed);
18099 </pre>
18100 <p><b>Description</b>
18102 The srand function uses the argument as a seed for a new sequence of pseudo-random
18103 numbers to be returned by subsequent calls to rand. If srand is then called with the
18104 same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is
18105 called before any calls to srand have been made, the same sequence shall be generated
18106 as when srand is first called with a seed value of 1.
18108 The srand function is not required to avoid data races with other calls to pseudo-
18109 random sequence generation functions. The implementation shall behave as if no library
18110 function calls the srand function.
18115 <!--page 365 -->
18116 <p><b>Returns</b>
18118 The srand function returns no value.
18120 EXAMPLE The following functions define a portable implementation of rand and srand.
18121 <pre>
18122 static unsigned long int next = 1;
18123 int rand(void) // RAND_MAX assumed to be 32767
18124 {
18125 next = next * 1103515245 + 12345;
18126 return (unsigned int)(next/65536) % 32768;
18127 }
18128 void srand(unsigned int seed)
18129 {
18130 next = seed;
18131 }
18132 </pre>
18138 The order and contiguity of storage allocated by successive calls to the
18139 aligned_alloc, calloc, malloc, and realloc functions is unspecified. The
18140 pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to
18141 a pointer to any type of object with a fundamental alignment requirement and then used
18142 to access such an object or an array of such objects in the space allocated (until the space
18143 is explicitly deallocated). The lifetime of an allocated object extends from the allocation
18144 until the deallocation. Each such allocation shall yield a pointer to an object disjoint from
18145 any other object. The pointer returned points to the start (lowest byte address) of the
18146 allocated space. If the space cannot be allocated, a null pointer is returned. If the size of
18147 the space requested is zero, the behavior is implementation-defined: either a null pointer
18148 is returned, or the behavior is as if the size were some nonzero value, except that the
18149 returned pointer shall not be used to access an object.
18151 For purposes of determining the existence of a data race, memory allocation functions
18152 behave as though they accessed only memory locations accessible through their
18153 arguments and not other static duration storage. These functions may, however, visibly
18154 modify the storage that they allocate or deallocate. A call to free or realloc that
18155 deallocates a region p of memory synchronizes with any allocation call that allocates all
18156 or part of the region p. This synchronization occurs after any access of p by the
18157 deallocating function, and before any such access by the allocating function.
18161 <p><b>Synopsis</b>
18163 <!--page 366 -->
18164 <pre>
18166 void *aligned_alloc(size_t alignment, size_t size);
18167 </pre>
18168 <p><b>Description</b>
18170 The aligned_alloc function allocates space for an object whose alignment is
18171 specified by alignment, whose size is specified by size, and whose value is
18172 indeterminate. The value of alignment shall be a valid alignment supported by the
18173 implementation and the value of size shall be an integral multiple of alignment.
18174 <p><b>Returns</b>
18176 The aligned_alloc function returns either a null pointer or a pointer to the allocated
18177 space.
18181 <p><b>Synopsis</b>
18183 <pre>
18185 void *calloc(size_t nmemb, size_t size);
18186 </pre>
18187 <p><b>Description</b>
18189 The calloc function allocates space for an array of nmemb objects, each of whose size
18190 is size. The space is initialized to all bits zero.<sup><a href="#note296"><b>296)</b></a></sup>
18191 <p><b>Returns</b>
18193 The calloc function returns either a null pointer or a pointer to the allocated space.
18195 <p><b>Footnotes</b>
18196 <p><small><a name="note296" href="#note296">296)</a> Note that this need not be the same as the representation of floating-point zero or a null pointer
18197 constant.
18198 </small>
18202 <p><b>Synopsis</b>
18204 <pre>
18206 void free(void *ptr);
18207 </pre>
18208 <p><b>Description</b>
18210 The free function causes the space pointed to by ptr to be deallocated, that is, made
18211 available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if
18212 the argument does not match a pointer earlier returned by a memory management
18213 function, or if the space has been deallocated by a call to free or realloc, the
18214 behavior is undefined.
18215 <p><b>Returns</b>
18217 The free function returns no value.
18222 <!--page 367 -->
18226 <p><b>Synopsis</b>
18228 <pre>
18230 void *malloc(size_t size);
18231 </pre>
18232 <p><b>Description</b>
18234 The malloc function allocates space for an object whose size is specified by size and
18235 whose value is indeterminate.
18236 <p><b>Returns</b>
18238 The malloc function returns either a null pointer or a pointer to the allocated space.
18242 <p><b>Synopsis</b>
18244 <pre>
18246 void *realloc(void *ptr, size_t size);
18247 </pre>
18248 <p><b>Description</b>
18250 The realloc function deallocates the old object pointed to by ptr and returns a
18251 pointer to a new object that has the size specified by size. The contents of the new
18252 object shall be the same as that of the old object prior to deallocation, up to the lesser of
18253 the new and old sizes. Any bytes in the new object beyond the size of the old object have
18254 indeterminate values.
18256 If ptr is a null pointer, the realloc function behaves like the malloc function for the
18257 specified size. Otherwise, if ptr does not match a pointer earlier returned by a memory
18258 management function, or if the space has been deallocated by a call to the free or
18259 realloc function, the behavior is undefined. If memory for the new object cannot be
18260 allocated, the old object is not deallocated and its value is unchanged.
18261 <p><b>Returns</b>
18263 The realloc function returns a pointer to the new object (which may have the same
18264 value as a pointer to the old object), or a null pointer if the new object could not be
18265 allocated.
18266 <!--page 368 -->
18273 <p><b>Synopsis</b>
18275 <pre>
18277 _Noreturn void abort(void);
18278 </pre>
18279 <p><b>Description</b>
18281 The abort function causes abnormal program termination to occur, unless the signal
18282 SIGABRT is being caught and the signal handler does not return. Whether open streams
18283 with unwritten buffered data are flushed, open streams are closed, or temporary files are
18284 removed is implementation-defined. An implementation-defined form of the status
18285 unsuccessful termination is returned to the host environment by means of the function
18286 call raise(SIGABRT).
18287 <p><b>Returns</b>
18289 The abort function does not return to its caller.
18293 <p><b>Synopsis</b>
18295 <pre>
18297 int atexit(void (*func)(void));
18298 </pre>
18299 <p><b>Description</b>
18301 The atexit function registers the function pointed to by func, to be called without
18302 arguments at normal program termination.<sup><a href="#note297"><b>297)</b></a></sup> It is unspecified whether a call to the
18303 atexit function that does not happen before the exit function is called will succeed.
18304 <p><b>Environmental limits</b>
18306 The implementation shall support the registration of at least 32 functions.
18307 <p><b>Returns</b>
18309 The atexit function returns zero if the registration succeeds, nonzero if it fails.
18310 <p><b> Forward references</b>: the at_quick_exit function (<a href="#7.22.4.3">7.22.4.3</a>), the exit function
18316 <!--page 369 -->
18318 <p><b>Footnotes</b>
18319 <p><small><a name="note297" href="#note297">297)</a> The atexit function registrations are distinct from the at_quick_exit registrations, so
18320 applications may need to call both registration functions with the same argument.
18321 </small>
18325 <p><b>Synopsis</b>
18327 <pre>
18329 int at_quick_exit(void (*func)(void));
18330 </pre>
18331 <p><b>Description</b>
18333 The at_quick_exit function registers the function pointed to by func, to be called
18334 without arguments should quick_exit be called.<sup><a href="#note298"><b>298)</b></a></sup> It is unspecified whether a call to
18335 the at_quick_exit function that does not happen before the quick_exit function
18336 is called will succeed.
18337 <p><b>Environmental limits</b>
18339 The implementation shall support the registration of at least 32 functions.
18340 <p><b>Returns</b>
18342 The at_quick_exit function returns zero if the registration succeeds, nonzero if it
18343 fails.
18346 <p><b>Footnotes</b>
18347 <p><small><a name="note298" href="#note298">298)</a> The at_quick_exit function registrations are distinct from the atexit registrations, so
18348 applications may need to call both registration functions with the same argument.
18349 </small>
18353 <p><b>Synopsis</b>
18355 <pre>
18357 _Noreturn void exit(int status);
18358 </pre>
18359 <p><b>Description</b>
18361 The exit function causes normal program termination to occur. No functions registered
18362 by the at_quick_exit function are called. If a program calls the exit function
18363 more than once, or calls the quick_exit function in addition to the exit function, the
18364 behavior is undefined.
18366 First, all functions registered by the atexit function are called, in the reverse order of
18367 their registration,<sup><a href="#note299"><b>299)</b></a></sup> except that a function is called after any previously registered
18368 functions that had already been called at the time it was registered. If, during the call to
18369 any such function, a call to the longjmp function is made that would terminate the call
18370 to the registered function, the behavior is undefined.
18374 <!--page 370 -->
18376 Next, all open streams with unwritten buffered data are flushed, all open streams are
18377 closed, and all files created by the tmpfile function are removed.
18379 Finally, control is returned to the host environment. If the value of status is zero or
18380 EXIT_SUCCESS, an implementation-defined form of the status successful termination is
18381 returned. If the value of status is EXIT_FAILURE, an implementation-defined form
18382 of the status unsuccessful termination is returned. Otherwise the status returned is
18383 implementation-defined.
18384 <p><b>Returns</b>
18386 The exit function cannot return to its caller.
18388 <p><b>Footnotes</b>
18389 <p><small><a name="note299" href="#note299">299)</a> Each function is called as many times as it was registered, and in the correct order with respect to
18390 other registered functions.
18391 </small>
18395 <p><b>Synopsis</b>
18397 <pre>
18399 _Noreturn void _Exit(int status);
18400 </pre>
18401 <p><b>Description</b>
18403 The _Exit function causes normal program termination to occur and control to be
18404 returned to the host environment. No functions registered by the atexit function, the
18405 at_quick_exit function, or signal handlers registered by the signal function are
18406 called. The status returned to the host environment is determined in the same way as for
18407 the exit function (<a href="#7.22.4.4">7.22.4.4</a>). Whether open streams with unwritten buffered data are
18408 flushed, open streams are closed, or temporary files are removed is implementation-
18409 defined.
18410 <p><b>Returns</b>
18412 The _Exit function cannot return to its caller.
18416 <p><b>Synopsis</b>
18418 <pre>
18420 char *getenv(const char *name);
18421 </pre>
18422 <p><b>Description</b>
18424 The getenv function searches an environment list, provided by the host environment,
18425 for a string that matches the string pointed to by name. The set of environment names
18426 and the method for altering the environment list are implementation-defined. The
18427 getenv function need not avoid data races with other threads of execution that modify
18430 <!--page 371 -->
18432 The implementation shall behave as if no library function calls the getenv function.
18433 <p><b>Returns</b>
18435 The getenv function returns a pointer to a string associated with the matched list
18436 member. The string pointed to shall not be modified by the program, but may be
18437 overwritten by a subsequent call to the getenv function. If the specified name cannot
18438 be found, a null pointer is returned.
18440 <p><b>Footnotes</b>
18441 <p><small><a name="note300" href="#note300">300)</a> Many implementations provide non-standard functions that modify the environment list.
18442 </small>
18446 <p><b>Synopsis</b>
18448 <pre>
18450 _Noreturn void quick_exit(int status);
18451 </pre>
18452 <p><b>Description</b>
18454 The quick_exit function causes normal program termination to occur. No functions
18455 registered by the atexit function or signal handlers registered by the signal function
18456 are called. If a program calls the quick_exit function more than once, or calls the
18457 exit function in addition to the quick_exit function, the behavior is undefined. If a
18458 signal is raised while the quick_exit function is executing, the behavior is undefined.
18460 The quick_exit function first calls all functions registered by the at_quick_exit
18461 function, in the reverse order of their registration,<sup><a href="#note301"><b>301)</b></a></sup> except that a function is called after
18462 any previously registered functions that had already been called at the time it was
18463 registered. If, during the call to any such function, a call to the longjmp function is
18464 made that would terminate the call to the registered function, the behavior is undefined.
18466 Then control is returned to the host environment by means of the function call
18467 _Exit(status).
18468 <p><b>Returns</b>
18470 The quick_exit function cannot return to its caller.
18472 <p><b>Footnotes</b>
18473 <p><small><a name="note301" href="#note301">301)</a> Each function is called as many times as it was registered, and in the correct order with respect to
18474 other registered functions.
18475 </small>
18479 <p><b>Synopsis</b>
18481 <pre>
18483 int system(const char *string);
18484 </pre>
18485 <p><b>Description</b>
18487 If string is a null pointer, the system function determines whether the host
18488 environment has a command processor. If string is not a null pointer, the system
18490 <!--page 372 -->
18491 function passes the string pointed to by string to that command processor to be
18492 executed in a manner which the implementation shall document; this might then cause the
18493 program calling system to behave in a non-conforming manner or to terminate.
18494 <p><b>Returns</b>
18496 If the argument is a null pointer, the system function returns nonzero only if a
18497 command processor is available. If the argument is not a null pointer, and the system
18498 function does return, it returns an implementation-defined value.
18503 These utilities make use of a comparison function to search or sort arrays of unspecified
18504 type. Where an argument declared as size_t nmemb specifies the length of the array
18505 for a function, nmemb can have the value zero on a call to that function; the comparison
18506 function is not called, a search finds no matching element, and sorting performs no
18507 rearrangement. Pointer arguments on such a call shall still have valid values, as described
18510 The implementation shall ensure that the second argument of the comparison function
18511 (when called from bsearch), or both arguments (when called from qsort), are
18512 pointers to elements of the array.<sup><a href="#note302"><b>302)</b></a></sup> The first argument when called from bsearch
18513 shall equal key.
18515 The comparison function shall not alter the contents of the array. The implementation
18516 may reorder elements of the array between calls to the comparison function, but shall not
18517 alter the contents of any individual element.
18519 When the same objects (consisting of size bytes, irrespective of their current positions
18520 in the array) are passed more than once to the comparison function, the results shall be
18521 consistent with one another. That is, for qsort they shall define a total ordering on the
18522 array, and for bsearch the same object shall always compare the same way with the
18523 key.
18525 A sequence point occurs immediately before and immediately after each call to the
18526 comparison function, and also between any call to the comparison function and any
18527 movement of the objects passed as arguments to that call.
18532 <!--page 373 -->
18534 <p><b>Footnotes</b>
18535 <p><small><a name="note302" href="#note302">302)</a> That is, if the value passed is p, then the following expressions are always nonzero:
18537 <pre>
18538 ((char *)p - (char *)base) % size == 0
18539 (char *)p >= (char *)base
18540 (char *)p < (char *)base + nmemb * size
18541 </pre>
18542 </small>
18546 <p><b>Synopsis</b>
18548 <pre>
18550 void *bsearch(const void *key, const void *base,
18551 size_t nmemb, size_t size,
18552 int (*compar)(const void *, const void *));
18553 </pre>
18554 <p><b>Description</b>
18556 The bsearch function searches an array of nmemb objects, the initial element of which
18557 is pointed to by base, for an element that matches the object pointed to by key. The
18558 size of each element of the array is specified by size.
18560 The comparison function pointed to by compar is called with two arguments that point
18561 to the key object and to an array element, in that order. The function shall return an
18562 integer less than, equal to, or greater than zero if the key object is considered,
18563 respectively, to be less than, to match, or to be greater than the array element. The array
18564 shall consist of: all the elements that compare less than, all the elements that compare
18565 equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note303"><b>303)</b></a></sup>
18566 <p><b>Returns</b>
18568 The bsearch function returns a pointer to a matching element of the array, or a null
18569 pointer if no match is found. If two elements compare as equal, which element is
18570 matched is unspecified.
18572 <p><b>Footnotes</b>
18573 <p><small><a name="note303" href="#note303">303)</a> In practice, the entire array is sorted according to the comparison function.
18574 </small>
18578 <p><b>Synopsis</b>
18580 <pre>
18582 void qsort(void *base, size_t nmemb, size_t size,
18583 int (*compar)(const void *, const void *));
18584 </pre>
18585 <p><b>Description</b>
18587 The qsort function sorts an array of nmemb objects, the initial element of which is
18588 pointed to by base. The size of each object is specified by size.
18590 The contents of the array are sorted into ascending order according to a comparison
18591 function pointed to by compar, which is called with two arguments that point to the
18592 objects being compared. The function shall return an integer less than, equal to, or
18593 greater than zero if the first argument is considered to be respectively less than, equal to,
18594 or greater than the second.
18597 <!--page 374 -->
18599 If two elements compare as equal, their order in the resulting sorted array is unspecified.
18600 <p><b>Returns</b>
18602 The qsort function returns no value.
18609 <p><b>Synopsis</b>
18611 <pre>
18613 int abs(int j);
18614 long int labs(long int j);
18615 long long int llabs(long long int j);
18616 </pre>
18617 <p><b>Description</b>
18619 The abs, labs, and llabs functions compute the absolute value of an integer j. If the
18620 result cannot be represented, the behavior is undefined.<sup><a href="#note304"><b>304)</b></a></sup>
18621 <p><b>Returns</b>
18623 The abs, labs, and llabs, functions return the absolute value.
18625 <p><b>Footnotes</b>
18626 <p><small><a name="note304" href="#note304">304)</a> The absolute value of the most negative number cannot be represented in two's complement.
18627 </small>
18631 <p><b>Synopsis</b>
18633 <pre>
18635 div_t div(int numer, int denom);
18636 ldiv_t ldiv(long int numer, long int denom);
18637 lldiv_t lldiv(long long int numer, long long int denom);
18638 </pre>
18639 <p><b>Description</b>
18641 The div, ldiv, and lldiv, functions compute numer / denom and numer %
18642 denom in a single operation.
18643 <p><b>Returns</b>
18645 The div, ldiv, and lldiv functions return a structure of type div_t, ldiv_t, and
18646 lldiv_t, respectively, comprising both the quotient and the remainder. The structures
18647 shall contain (in either order) the members quot (the quotient) and rem (the remainder),
18648 each of which has the same type as the arguments numer and denom. If either part of
18649 the result cannot be represented, the behavior is undefined.
18654 <!--page 375 -->
18657 <h4><a name="7.22.7" href="#7.22.7">7.22.7 Multibyte/wide character conversion functions</a></h4>
18659 The behavior of the multibyte character functions is affected by the LC_CTYPE category
18660 of the current locale. For a state-dependent encoding, each function is placed into its
18661 initial conversion state at program startup and can be returned to that state by a call for
18662 which its character pointer argument, s, is a null pointer. Subsequent calls with s as
18663 other than a null pointer cause the internal conversion state of the function to be altered as
18664 necessary. A call with s as a null pointer causes these functions to return a nonzero value
18665 if encodings have state dependency, and zero otherwise.<sup><a href="#note305"><b>305)</b></a></sup> Changing the LC_CTYPE
18666 category causes the conversion state of these functions to be indeterminate.
18668 <p><b>Footnotes</b>
18669 <p><small><a name="note305" href="#note305">305)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
18670 character codes, but are grouped with an adjacent multibyte character.
18671 </small>
18675 <p><b>Synopsis</b>
18677 <pre>
18679 int mblen(const char *s, size_t n);
18680 </pre>
18681 <p><b>Description</b>
18683 If s is not a null pointer, the mblen function determines the number of bytes contained
18684 in the multibyte character pointed to by s. Except that the conversion state of the
18685 mbtowc function is not affected, it is equivalent to
18686 <pre>
18687 mbtowc((wchar_t *)0, (const char *)0, 0);
18688 mbtowc((wchar_t *)0, s, n);
18689 </pre>
18691 The implementation shall behave as if no library function calls the mblen function.
18692 <p><b>Returns</b>
18694 If s is a null pointer, the mblen function returns a nonzero or zero value, if multibyte
18695 character encodings, respectively, do or do not have state-dependent encodings. If s is
18696 not a null pointer, the mblen function either returns 0 (if s points to the null character),
18697 or returns the number of bytes that are contained in the multibyte character (if the next n
18698 or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
18699 multibyte character).
18705 <!--page 376 -->
18709 <p><b>Synopsis</b>
18711 <pre>
18713 int mbtowc(wchar_t * restrict pwc,
18714 const char * restrict s,
18715 size_t n);
18716 </pre>
18717 <p><b>Description</b>
18719 If s is not a null pointer, the mbtowc function inspects at most n bytes beginning with
18720 the byte pointed to by s to determine the number of bytes needed to complete the next
18721 multibyte character (including any shift sequences). If the function determines that the
18722 next multibyte character is complete and valid, it determines the value of the
18723 corresponding wide character and then, if pwc is not a null pointer, stores that value in
18724 the object pointed to by pwc. If the corresponding wide character is the null wide
18725 character, the function is left in the initial conversion state.
18727 The implementation shall behave as if no library function calls the mbtowc function.
18728 <p><b>Returns</b>
18730 If s is a null pointer, the mbtowc function returns a nonzero or zero value, if multibyte
18731 character encodings, respectively, do or do not have state-dependent encodings. If s is
18732 not a null pointer, the mbtowc function either returns 0 (if s points to the null character),
18733 or returns the number of bytes that are contained in the converted multibyte character (if
18734 the next n or fewer bytes form a valid multibyte character), or returns -1 (if they do not
18735 form a valid multibyte character).
18737 In no case will the value returned be greater than n or the value of the MB_CUR_MAX
18738 macro.
18742 <p><b>Synopsis</b>
18744 <pre>
18746 int wctomb(char *s, wchar_t wc);
18747 </pre>
18748 <p><b>Description</b>
18750 The wctomb function determines the number of bytes needed to represent the multibyte
18751 character corresponding to the wide character given by wc (including any shift
18752 sequences), and stores the multibyte character representation in the array whose first
18753 element is pointed to by s (if s is not a null pointer). At most MB_CUR_MAX characters
18754 are stored. If wc is a null wide character, a null byte is stored, preceded by any shift
18755 sequence needed to restore the initial shift state, and the function is left in the initial
18756 conversion state.
18757 <!--page 377 -->
18759 The implementation shall behave as if no library function calls the wctomb function.
18760 <p><b>Returns</b>
18762 If s is a null pointer, the wctomb function returns a nonzero or zero value, if multibyte
18763 character encodings, respectively, do or do not have state-dependent encodings. If s is
18764 not a null pointer, the wctomb function returns -1 if the value of wc does not correspond
18765 to a valid multibyte character, or returns the number of bytes that are contained in the
18766 multibyte character corresponding to the value of wc.
18768 In no case will the value returned be greater than the value of the MB_CUR_MAX macro.
18771 <h4><a name="7.22.8" href="#7.22.8">7.22.8 Multibyte/wide string conversion functions</a></h4>
18773 The behavior of the multibyte string functions is affected by the LC_CTYPE category of
18774 the current locale.
18778 <p><b>Synopsis</b>
18780 <pre>
18782 size_t mbstowcs(wchar_t * restrict pwcs,
18783 const char * restrict s,
18784 size_t n);
18785 </pre>
18786 <p><b>Description</b>
18788 The mbstowcs function converts a sequence of multibyte characters that begins in the
18789 initial shift state from the array pointed to by s into a sequence of corresponding wide
18790 characters and stores not more than n wide characters into the array pointed to by pwcs.
18791 No multibyte characters that follow a null character (which is converted into a null wide
18792 character) will be examined or converted. Each multibyte character is converted as if by
18793 a call to the mbtowc function, except that the conversion state of the mbtowc function is
18794 not affected.
18796 No more than n elements will be modified in the array pointed to by pwcs. If copying
18797 takes place between objects that overlap, the behavior is undefined.
18798 <p><b>Returns</b>
18800 If an invalid multibyte character is encountered, the mbstowcs function returns
18801 (size_t)(-1). Otherwise, the mbstowcs function returns the number of array
18802 elements modified, not including a terminating null wide character, if any.<sup><a href="#note306"><b>306)</b></a></sup>
18807 <!--page 378 -->
18809 <p><b>Footnotes</b>
18810 <p><small><a name="note306" href="#note306">306)</a> The array will not be null-terminated if the value returned is n.
18811 </small>
18815 <p><b>Synopsis</b>
18817 <pre>
18819 size_t wcstombs(char * restrict s,
18820 const wchar_t * restrict pwcs,
18821 size_t n);
18822 </pre>
18823 <p><b>Description</b>
18825 The wcstombs function converts a sequence of wide characters from the array pointed
18826 to by pwcs into a sequence of corresponding multibyte characters that begins in the
18827 initial shift state, and stores these multibyte characters into the array pointed to by s,
18828 stopping if a multibyte character would exceed the limit of n total bytes or if a null
18829 character is stored. Each wide character is converted as if by a call to the wctomb
18830 function, except that the conversion state of the wctomb function is not affected.
18832 No more than n bytes will be modified in the array pointed to by s. If copying takes place
18833 between objects that overlap, the behavior is undefined.
18834 <p><b>Returns</b>
18836 If a wide character is encountered that does not correspond to a valid multibyte character,
18837 the wcstombs function returns (size_t)(-1). Otherwise, the wcstombs function
18838 returns the number of bytes modified, not including a terminating null character, if
18840 <!--page 379 -->
18846 <pre>
18847 noreturn
18848 </pre>
18849 which expands to _Noreturn.
18850 <!--page 380 -->
18858 The header <a href="#7.24"><string.h></a> declares one type and several functions, and defines one
18859 macro useful for manipulating arrays of character type and other objects treated as arrays
18860 of character type.<sup><a href="#note307"><b>307)</b></a></sup> The type is size_t and the macro is NULL (both described in
18861 <a href="#7.19">7.19</a>). Various methods are used for determining the lengths of the arrays, but in all cases
18862 a char * or void * argument points to the initial (lowest addressed) character of the
18863 array. If an array is accessed beyond the end of an object, the behavior is undefined.
18865 Where an argument declared as size_t n specifies the length of the array for a
18866 function, n can have the value zero on a call to that function. Unless explicitly stated
18867 otherwise in the description of a particular function in this subclause, pointer arguments
18868 on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
18869 function that locates a character finds no occurrence, a function that compares two
18870 character sequences returns zero, and a function that copies characters copies zero
18871 characters.
18873 For all functions in this subclause, each character shall be interpreted as if it had the type
18874 unsigned char (and therefore every possible object representation is valid and has a
18875 different value).
18877 <p><b>Footnotes</b>
18878 <p><small><a name="note307" href="#note307">307)</a> See ''future library directions'' (<a href="#7.31.13">7.31.13</a>).
18879 </small>
18886 <p><b>Synopsis</b>
18888 <pre>
18890 void *memcpy(void * restrict s1,
18891 const void * restrict s2,
18892 size_t n);
18893 </pre>
18894 <p><b>Description</b>
18896 The memcpy function copies n characters from the object pointed to by s2 into the
18897 object pointed to by s1. If copying takes place between objects that overlap, the behavior
18898 is undefined.
18899 <p><b>Returns</b>
18901 The memcpy function returns the value of s1.
18906 <!--page 381 -->
18910 <p><b>Synopsis</b>
18912 <pre>
18914 void *memmove(void *s1, const void *s2, size_t n);
18915 </pre>
18916 <p><b>Description</b>
18918 The memmove function copies n characters from the object pointed to by s2 into the
18919 object pointed to by s1. Copying takes place as if the n characters from the object
18920 pointed to by s2 are first copied into a temporary array of n characters that does not
18921 overlap the objects pointed to by s1 and s2, and then the n characters from the
18922 temporary array are copied into the object pointed to by s1.
18923 <p><b>Returns</b>
18925 The memmove function returns the value of s1.
18929 <p><b>Synopsis</b>
18931 <pre>
18933 char *strcpy(char * restrict s1,
18934 const char * restrict s2);
18935 </pre>
18936 <p><b>Description</b>
18938 The strcpy function copies the string pointed to by s2 (including the terminating null
18939 character) into the array pointed to by s1. If copying takes place between objects that
18940 overlap, the behavior is undefined.
18941 <p><b>Returns</b>
18943 The strcpy function returns the value of s1.
18947 <p><b>Synopsis</b>
18949 <pre>
18951 char *strncpy(char * restrict s1,
18952 const char * restrict s2,
18953 size_t n);
18954 </pre>
18955 <p><b>Description</b>
18957 The strncpy function copies not more than n characters (characters that follow a null
18958 character are not copied) from the array pointed to by s2 to the array pointed to by
18959 <!--page 382 -->
18960 s1.<sup><a href="#note308"><b>308)</b></a></sup> If copying takes place between objects that overlap, the behavior is undefined.
18962 If the array pointed to by s2 is a string that is shorter than n characters, null characters
18963 are appended to the copy in the array pointed to by s1, until n characters in all have been
18964 written.
18965 <p><b>Returns</b>
18967 The strncpy function returns the value of s1.
18969 <p><b>Footnotes</b>
18970 <p><small><a name="note308" href="#note308">308)</a> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
18971 not be null-terminated.
18972 </small>
18979 <p><b>Synopsis</b>
18981 <pre>
18983 char *strcat(char * restrict s1,
18984 const char * restrict s2);
18985 </pre>
18986 <p><b>Description</b>
18988 The strcat function appends a copy of the string pointed to by s2 (including the
18989 terminating null character) to the end of the string pointed to by s1. The initial character
18990 of s2 overwrites the null character at the end of s1. If copying takes place between
18991 objects that overlap, the behavior is undefined.
18992 <p><b>Returns</b>
18994 The strcat function returns the value of s1.
18998 <p><b>Synopsis</b>
19000 <pre>
19002 char *strncat(char * restrict s1,
19003 const char * restrict s2,
19004 size_t n);
19005 </pre>
19006 <p><b>Description</b>
19008 The strncat function appends not more than n characters (a null character and
19009 characters that follow it are not appended) from the array pointed to by s2 to the end of
19010 the string pointed to by s1. The initial character of s2 overwrites the null character at the
19011 end of s1. A terminating null character is always appended to the result.<sup><a href="#note309"><b>309)</b></a></sup> If copying
19013 <!--page 383 -->
19014 takes place between objects that overlap, the behavior is undefined.
19015 <p><b>Returns</b>
19017 The strncat function returns the value of s1.
19020 <p><b>Footnotes</b>
19021 <p><small><a name="note309" href="#note309">309)</a> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
19022 strlen(s1)+n+1.
19023 </small>
19028 The sign of a nonzero value returned by the comparison functions memcmp, strcmp,
19029 and strncmp is determined by the sign of the difference between the values of the first
19030 pair of characters (both interpreted as unsigned char) that differ in the objects being
19031 compared.
19035 <p><b>Synopsis</b>
19037 <pre>
19039 int memcmp(const void *s1, const void *s2, size_t n);
19040 </pre>
19041 <p><b>Description</b>
19043 The memcmp function compares the first n characters of the object pointed to by s1 to
19044 the first n characters of the object pointed to by s2.<sup><a href="#note310"><b>310)</b></a></sup>
19045 <p><b>Returns</b>
19047 The memcmp function returns an integer greater than, equal to, or less than zero,
19048 accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
19049 pointed to by s2.
19051 <p><b>Footnotes</b>
19052 <p><small><a name="note310" href="#note310">310)</a> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
19053 indeterminate. Strings shorter than their allocated space and unions may also cause problems in
19054 comparison.
19055 </small>
19059 <p><b>Synopsis</b>
19061 <pre>
19063 int strcmp(const char *s1, const char *s2);
19064 </pre>
19065 <p><b>Description</b>
19067 The strcmp function compares the string pointed to by s1 to the string pointed to by
19068 s2.
19069 <p><b>Returns</b>
19071 The strcmp function returns an integer greater than, equal to, or less than zero,
19072 accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
19074 <!--page 384 -->
19075 pointed to by s2.
19079 <p><b>Synopsis</b>
19081 <pre>
19083 int strcoll(const char *s1, const char *s2);
19084 </pre>
19085 <p><b>Description</b>
19087 The strcoll function compares the string pointed to by s1 to the string pointed to by
19088 s2, both interpreted as appropriate to the LC_COLLATE category of the current locale.
19089 <p><b>Returns</b>
19091 The strcoll function returns an integer greater than, equal to, or less than zero,
19092 accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
19093 pointed to by s2 when both are interpreted as appropriate to the current locale.
19097 <p><b>Synopsis</b>
19099 <pre>
19101 int strncmp(const char *s1, const char *s2, size_t n);
19102 </pre>
19103 <p><b>Description</b>
19105 The strncmp function compares not more than n characters (characters that follow a
19106 null character are not compared) from the array pointed to by s1 to the array pointed to
19107 by s2.
19108 <p><b>Returns</b>
19110 The strncmp function returns an integer greater than, equal to, or less than zero,
19111 accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
19112 to, or less than the possibly null-terminated array pointed to by s2.
19116 <p><b>Synopsis</b>
19118 <pre>
19120 size_t strxfrm(char * restrict s1,
19121 const char * restrict s2,
19122 size_t n);
19123 </pre>
19124 <p><b>Description</b>
19126 The strxfrm function transforms the string pointed to by s2 and places the resulting
19127 string into the array pointed to by s1. The transformation is such that if the strcmp
19128 function is applied to two transformed strings, it returns a value greater than, equal to, or
19129 <!--page 385 -->
19130 less than zero, corresponding to the result of the strcoll function applied to the same
19131 two original strings. No more than n characters are placed into the resulting array
19132 pointed to by s1, including the terminating null character. If n is zero, s1 is permitted to
19133 be a null pointer. If copying takes place between objects that overlap, the behavior is
19134 undefined.
19135 <p><b>Returns</b>
19137 The strxfrm function returns the length of the transformed string (not including the
19138 terminating null character). If the value returned is n or more, the contents of the array
19139 pointed to by s1 are indeterminate.
19141 EXAMPLE The value of the following expression is the size of the array needed to hold the
19142 transformation of the string pointed to by s.
19143 <pre>
19144 1 + strxfrm(NULL, s, 0)
19145 </pre>
19153 <p><b>Synopsis</b>
19155 <pre>
19157 void *memchr(const void *s, int c, size_t n);
19158 </pre>
19159 <p><b>Description</b>
19161 The memchr function locates the first occurrence of c (converted to an unsigned
19162 char) in the initial n characters (each interpreted as unsigned char) of the object
19163 pointed to by s. The implementation shall behave as if it reads the characters sequentially
19164 and stops as soon as a matching character is found.
19165 <p><b>Returns</b>
19167 The memchr function returns a pointer to the located character, or a null pointer if the
19168 character does not occur in the object.
19172 <p><b>Synopsis</b>
19174 <pre>
19176 char *strchr(const char *s, int c);
19177 </pre>
19178 <p><b>Description</b>
19180 The strchr function locates the first occurrence of c (converted to a char) in the
19181 string pointed to by s. The terminating null character is considered to be part of the
19182 string.
19183 <!--page 386 -->
19184 <p><b>Returns</b>
19186 The strchr function returns a pointer to the located character, or a null pointer if the
19187 character does not occur in the string.
19191 <p><b>Synopsis</b>
19193 <pre>
19195 size_t strcspn(const char *s1, const char *s2);
19196 </pre>
19197 <p><b>Description</b>
19199 The strcspn function computes the length of the maximum initial segment of the string
19200 pointed to by s1 which consists entirely of characters not from the string pointed to by
19201 s2.
19202 <p><b>Returns</b>
19204 The strcspn function returns the length of the segment.
19208 <p><b>Synopsis</b>
19210 <pre>
19212 char *strpbrk(const char *s1, const char *s2);
19213 </pre>
19214 <p><b>Description</b>
19216 The strpbrk function locates the first occurrence in the string pointed to by s1 of any
19217 character from the string pointed to by s2.
19218 <p><b>Returns</b>
19220 The strpbrk function returns a pointer to the character, or a null pointer if no character
19221 from s2 occurs in s1.
19225 <p><b>Synopsis</b>
19227 <pre>
19229 char *strrchr(const char *s, int c);
19230 </pre>
19231 <p><b>Description</b>
19233 The strrchr function locates the last occurrence of c (converted to a char) in the
19234 string pointed to by s. The terminating null character is considered to be part of the
19235 string.
19236 <!--page 387 -->
19237 <p><b>Returns</b>
19239 The strrchr function returns a pointer to the character, or a null pointer if c does not
19240 occur in the string.
19244 <p><b>Synopsis</b>
19246 <pre>
19248 size_t strspn(const char *s1, const char *s2);
19249 </pre>
19250 <p><b>Description</b>
19252 The strspn function computes the length of the maximum initial segment of the string
19253 pointed to by s1 which consists entirely of characters from the string pointed to by s2.
19254 <p><b>Returns</b>
19256 The strspn function returns the length of the segment.
19260 <p><b>Synopsis</b>
19262 <pre>
19264 char *strstr(const char *s1, const char *s2);
19265 </pre>
19266 <p><b>Description</b>
19268 The strstr function locates the first occurrence in the string pointed to by s1 of the
19269 sequence of characters (excluding the terminating null character) in the string pointed to
19270 by s2.
19271 <p><b>Returns</b>
19273 The strstr function returns a pointer to the located string, or a null pointer if the string
19274 is not found. If s2 points to a string with zero length, the function returns s1.
19278 <p><b>Synopsis</b>
19280 <pre>
19282 char *strtok(char * restrict s1,
19283 const char * restrict s2);
19284 </pre>
19285 <p><b>Description</b>
19287 A sequence of calls to the strtok function breaks the string pointed to by s1 into a
19288 sequence of tokens, each of which is delimited by a character from the string pointed to
19289 by s2. The first call in the sequence has a non-null first argument; subsequent calls in the
19290 sequence have a null first argument. The separator string pointed to by s2 may be
19291 different from call to call.
19292 <!--page 388 -->
19294 The first call in the sequence searches the string pointed to by s1 for the first character
19295 that is not contained in the current separator string pointed to by s2. If no such character
19296 is found, then there are no tokens in the string pointed to by s1 and the strtok function
19297 returns a null pointer. If such a character is found, it is the start of the first token.
19299 The strtok function then searches from there for a character that is contained in the
19300 current separator string. If no such character is found, the current token extends to the
19301 end of the string pointed to by s1, and subsequent searches for a token will return a null
19302 pointer. If such a character is found, it is overwritten by a null character, which
19303 terminates the current token. The strtok function saves a pointer to the following
19304 character, from which the next search for a token will start.
19306 Each subsequent call, with a null pointer as the value of the first argument, starts
19307 searching from the saved pointer and behaves as described above.
19309 The strtok function is not required to avoid data races with other calls to the strtok
19310 function.<sup><a href="#note311"><b>311)</b></a></sup> The implementation shall behave as if no library function calls the strtok
19311 function.
19312 <p><b>Returns</b>
19314 The strtok function returns a pointer to the first character of a token, or a null pointer
19315 if there is no token.
19317 EXAMPLE
19318 <pre>
19321 char *t;
19326 </pre>
19333 <!--page 389 -->
19335 <p><b>Footnotes</b>
19336 <p><small><a name="note311" href="#note311">311)</a> The strtok_s function can be used instead to avoid data races.
19337 </small>
19344 <p><b>Synopsis</b>
19346 <pre>
19348 void *memset(void *s, int c, size_t n);
19349 </pre>
19350 <p><b>Description</b>
19352 The memset function copies the value of c (converted to an unsigned char) into
19353 each of the first n characters of the object pointed to by s.
19354 <p><b>Returns</b>
19356 The memset function returns the value of s.
19360 <p><b>Synopsis</b>
19362 <pre>
19364 char *strerror(int errnum);
19365 </pre>
19366 <p><b>Description</b>
19368 The strerror function maps the number in errnum to a message string. Typically,
19369 the values for errnum come from errno, but strerror shall map any value of type
19370 int to a message.
19372 The strerror function is not required to avoid data races with other calls to the
19373 strerror function.<sup><a href="#note312"><b>312)</b></a></sup> The implementation shall behave as if no library function calls
19374 the strerror function.
19375 <p><b>Returns</b>
19377 The strerror function returns a pointer to the string, the contents of which are locale-
19378 specific. The array pointed to shall not be modified by the program, but may be
19379 overwritten by a subsequent call to the strerror function.
19385 <!--page 390 -->
19387 <p><b>Footnotes</b>
19388 <p><small><a name="note312" href="#note312">312)</a> The strerror_s function can be used instead to avoid data races.
19389 </small>
19393 <p><b>Synopsis</b>
19395 <pre>
19397 size_t strlen(const char *s);
19398 </pre>
19399 <p><b>Description</b>
19401 The strlen function computes the length of the string pointed to by s.
19402 <p><b>Returns</b>
19404 The strlen function returns the number of characters that precede the terminating null
19405 character.
19406 <!--page 391 -->
19411 The header <a href="#7.25"><tgmath.h></a> includes the headers <a href="#7.12"><math.h></a> and <a href="#7.3"><complex.h></a> and
19412 defines several type-generic macros.
19414 Of the <a href="#7.12"><math.h></a> and <a href="#7.3"><complex.h></a> functions without an f (float) or l (long
19415 double) suffix, several have one or more parameters whose corresponding real type is
19416 double. For each such function, except modf, there is a corresponding type-generic
19417 macro.<sup><a href="#note313"><b>313)</b></a></sup> The parameters whose corresponding real type is double in the function
19418 synopsis are generic parameters. Use of the macro invokes a function whose
19419 corresponding real type and type domain are determined by the arguments for the generic
19422 Use of the macro invokes a function whose generic parameters have the corresponding
19423 real type determined as follows:
19424 <ul>
19425 <li> First, if any argument for generic parameters has type long double, the type
19426 determined is long double.
19427 <li> Otherwise, if any argument for generic parameters has type double or is of integer
19428 type, the type determined is double.
19429 <li> Otherwise, the type determined is float.
19430 </ul>
19432 For each unsuffixed function in <a href="#7.12"><math.h></a> for which there is a function in
19433 <a href="#7.3"><complex.h></a> with the same name except for a c prefix, the corresponding type-
19434 generic macro (for both functions) has the same name as the function in <a href="#7.12"><math.h></a>. The
19435 corresponding type-generic macro for fabs and cabs is fabs.
19440 <!--page 392 -->
19441 <pre>
19443 function function macro
19445 acos cacos acos
19446 asin casin asin
19447 atan catan atan
19448 acosh cacosh acosh
19449 asinh casinh asinh
19450 atanh catanh atanh
19451 cos ccos cos
19452 sin csin sin
19453 tan ctan tan
19454 cosh ccosh cosh
19455 sinh csinh sinh
19456 tanh ctanh tanh
19457 exp cexp exp
19458 log clog log
19459 pow cpow pow
19460 sqrt csqrt sqrt
19461 fabs cabs fabs
19462 </pre>
19463 If at least one argument for a generic parameter is complex, then use of the macro invokes
19464 a complex function; otherwise, use of the macro invokes a real function.
19466 For each unsuffixed function in <a href="#7.12"><math.h></a> without a c-prefixed counterpart in
19467 <a href="#7.3"><complex.h></a> (except modf), the corresponding type-generic macro has the same
19468 name as the function. These type-generic macros are:
19469 <pre>
19470 atan2 fma llround remainder
19471 cbrt fmax log10 remquo
19472 ceil fmin log1p rint
19473 copysign fmod log2 round
19474 erf frexp logb scalbn
19475 erfc hypot lrint scalbln
19476 exp2 ilogb lround tgamma
19477 expm1 ldexp nearbyint trunc
19478 fdim lgamma nextafter
19479 floor llrint nexttoward
19480 </pre>
19481 If all arguments for generic parameters are real, then use of the macro invokes a real
19482 function; otherwise, use of the macro results in undefined behavior.
19483 <!--page 393 -->
19485 For each unsuffixed function in <a href="#7.3"><complex.h></a> that is not a c-prefixed counterpart to a
19486 function in <a href="#7.12"><math.h></a>, the corresponding type-generic macro has the same name as the
19487 function. These type-generic macros are:
19488 <pre>
19489 carg conj creal
19490 cimag cproj
19491 </pre>
19492 Use of the macro with any real or complex argument invokes a complex function.
19494 EXAMPLE With the declarations
19495 <pre>
19497 int n;
19498 float f;
19499 double d;
19500 long double ld;
19501 float complex fc;
19502 double complex dc;
19503 long double complex ldc;
19504 </pre>
19505 functions invoked by use of type-generic macros are shown in the following table:
19506 <!--page 394 -->
19507 <pre>
19508 macro use invokes
19510 exp(n) exp(n), the function
19511 acosh(f) acoshf(f)
19512 sin(d) sin(d), the function
19513 atan(ld) atanl(ld)
19514 log(fc) clogf(fc)
19515 sqrt(dc) csqrt(dc)
19516 pow(ldc, f) cpowl(ldc, f)
19517 remainder(n, n) remainder(n, n), the function
19518 nextafter(d, f) nextafter(d, f), the function
19519 nexttoward(f, ld) nexttowardf(f, ld)
19520 copysign(n, ld) copysignl(n, ld)
19521 ceil(fc) undefined behavior
19522 rint(dc) undefined behavior
19523 fmax(ldc, ld) undefined behavior
19524 carg(n) carg(n), the function
19525 cproj(f) cprojf(f)
19526 creal(d) creal(d), the function
19527 cimag(ld) cimagl(ld)
19528 fabs(fc) cabsf(fc)
19529 carg(dc) carg(dc), the function
19530 cproj(ldc) cprojl(ldc)
19531 </pre>
19533 <p><b>Footnotes</b>
19534 <p><small><a name="note313" href="#note313">313)</a> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
19535 make available the corresponding ordinary function.
19536 </small>
19537 <p><small><a name="note314" href="#note314">314)</a> If the type of the argument is not compatible with the type of the parameter for the selected function,
19538 the behavior is undefined.
19539 </small>
19547 The header <a href="#7.26"><threads.h></a> includes the header <a href="#7.27"><time.h></a>, defines macros, and
19548 declares types, enumeration constants, and functions that support multiple threads of
19551 Implementations that define the macro __STDC_NO_THREADS__ need not provide
19552 this header nor support any of its facilities.
19554 The macros are
19555 <pre>
19556 thread_local
19557 </pre>
19558 which expands to _Thread_local;
19559 <pre>
19560 ONCE_FLAG_INIT
19561 </pre>
19562 which expands to a value that can be used to initialize an object of type once_flag;
19563 and
19564 <pre>
19565 TSS_DTOR_ITERATIONS
19566 </pre>
19567 which expands to an integer constant expression representing the maximum number of
19568 times that destructors will be called when a thread terminates.
19570 The types are
19571 <pre>
19572 cnd_t
19573 </pre>
19574 which is a complete object type that holds an identifier for a condition variable;
19575 <pre>
19576 thrd_t
19577 </pre>
19578 which is a complete object type that holds an identifier for a thread;
19579 <pre>
19580 tss_t
19581 </pre>
19582 which is a complete object type that holds an identifier for a thread-specific storage
19583 pointer;
19584 <pre>
19585 mtx_t
19586 </pre>
19587 which is a complete object type that holds an identifier for a mutex;
19588 <pre>
19589 tss_dtor_t
19590 </pre>
19591 which is the function pointer type void (*)(void*), used for a destructor for a
19592 thread-specific storage pointer;
19596 <!--page 395 -->
19597 <pre>
19598 thrd_start_t
19599 </pre>
19600 which is the function pointer type int (*)(void*) that is passed to thrd_create
19601 to create a new thread; and
19602 <pre>
19603 once_flag
19604 </pre>
19605 which is a complete object type that holds a flag for use by call_once.
19607 The enumeration constants are
19608 <pre>
19609 mtx_plain
19610 </pre>
19611 which is passed to mtx_init to create a mutex object that supports neither timeout nor
19612 test and return;
19613 <pre>
19614 mtx_recursive
19615 </pre>
19616 which is passed to mtx_init to create a mutex object that supports recursive locking;
19617 <pre>
19618 mtx_timed
19619 </pre>
19620 which is passed to mtx_init to create a mutex object that supports timeout;
19621 <pre>
19622 thrd_timedout
19623 </pre>
19624 which is returned by a timed wait function to indicate that the time specified in the call
19625 was reached without acquiring the requested resource;
19626 <pre>
19627 thrd_success
19628 </pre>
19629 which is returned by a function to indicate that the requested operation succeeded;
19630 <pre>
19631 thrd_busy
19632 </pre>
19633 which is returned by a function to indicate that the requested operation failed because a
19634 resource requested by a test and return function is already in use;
19635 <pre>
19636 thrd_error
19637 </pre>
19638 which is returned by a function to indicate that the requested operation failed; and
19639 <pre>
19640 thrd_nomem
19641 </pre>
19642 which is returned by a function to indicate that the requested operation failed because it
19643 was unable to allocate memory.
19645 <!--page 396 -->
19647 <p><b>Footnotes</b>
19648 <p><small><a name="note315" href="#note315">315)</a> See ''future library directions'' (<a href="#7.31.15">7.31.15</a>).
19649 </small>
19656 <p><b>Synopsis</b>
19658 <pre>
19660 void call_once(once_flag *flag, void (*func)(void));
19661 </pre>
19662 <p><b>Description</b>
19664 The call_once function uses the once_flag pointed to by flag to ensure that
19665 func is called exactly once, the first time the call_once function is called with that
19666 value of flag. Completion of an effective call to the call_once function synchronizes
19667 with all subsequent calls to the call_once function with the same value of flag.
19668 <p><b>Returns</b>
19670 The call_once function returns no value.
19677 <p><b>Synopsis</b>
19679 <pre>
19681 int cnd_broadcast(cnd_t *cond);
19682 </pre>
19683 <p><b>Description</b>
19685 The cnd_broadcast function unblocks all of the threads that are blocked on the
19686 condition variable pointed to by cond at the time of the call. If no threads are blocked
19687 on the condition variable pointed to by cond at the time of the call, the function does
19688 nothing.
19689 <p><b>Returns</b>
19691 The cnd_broadcast function returns thrd_success on success, or thrd_error
19692 if the request could not be honored.
19696 <p><b>Synopsis</b>
19698 <pre>
19700 void cnd_destroy(cnd_t *cond);
19701 </pre>
19702 <p><b>Description</b>
19704 The cnd_destroy function releases all resources used by the condition variable
19705 pointed to by cond. The cnd_destroy function requires that no threads be blocked
19706 waiting for the condition variable pointed to by cond.
19707 <!--page 397 -->
19708 <p><b>Returns</b>
19710 The cnd_destroy function returns no value.
19714 <p><b>Synopsis</b>
19716 <pre>
19718 int cnd_init(cnd_t *cond);
19719 </pre>
19720 <p><b>Description</b>
19722 The cnd_init function creates a condition variable. If it succeeds it sets the variable
19723 pointed to by cond to a value that uniquely identifies the newly created condition
19724 variable. A thread that calls cnd_wait on a newly created condition variable will
19725 block.
19726 <p><b>Returns</b>
19728 The cnd_init function returns thrd_success on success, or thrd_nomem if no
19729 memory could be allocated for the newly created condition, or thrd_error if the
19730 request could not be honored.
19734 <p><b>Synopsis</b>
19736 <pre>
19738 int cnd_signal(cnd_t *cond);
19739 </pre>
19740 <p><b>Description</b>
19742 The cnd_signal function unblocks one of the threads that are blocked on the
19743 condition variable pointed to by cond at the time of the call. If no threads are blocked
19744 on the condition variable at the time of the call, the function does nothing and return
19745 success.
19746 <p><b>Returns</b>
19748 The cnd_signal function returns thrd_success on success or thrd_error if
19749 the request could not be honored.
19753 <p><b>Synopsis</b>
19755 <!--page 398 -->
19756 <pre>
19758 int cnd_timedwait(cnd_t *restrict cond,
19759 mtx_t *restrict mtx,
19760 const struct timespec *restrict ts);
19761 </pre>
19762 <p><b>Description</b>
19764 The cnd_timedwait function atomically unlocks the mutex pointed to by mtx and
19765 endeavors to block until the condition variable pointed to by cond is signaled by a call to
19766 cnd_signal or to cnd_broadcast, or until after the TIME_UTC-based calendar
19767 time pointed to by ts. When the calling thread becomes unblocked it locks the variable
19768 pointed to by mtx before it returns. The cnd_timedwait function requires that the
19769 mutex pointed to by mtx be locked by the calling thread.
19770 <p><b>Returns</b>
19772 The cnd_timedwait function returns thrd_success upon success, or
19773 thrd_timedout if the time specified in the call was reached without acquiring the
19774 requested resource, or thrd_error if the request could not be honored.
19778 <p><b>Synopsis</b>
19780 <pre>
19782 int cnd_wait(cnd_t *cond, mtx_t *mtx);
19783 </pre>
19784 <p><b>Description</b>
19786 The cnd_wait function atomically unlocks the mutex pointed to by mtx and endeavors
19787 to block until the condition variable pointed to by cond is signaled by a call to
19788 cnd_signal or to cnd_broadcast. When the calling thread becomes unblocked it
19789 locks the mutex pointed to by mtx before it returns. The cnd_wait function requires
19790 that the mutex pointed to by mtx be locked by the calling thread.
19791 <p><b>Returns</b>
19793 The cnd_wait function returns thrd_success on success or thrd_error if the
19794 request could not be honored.
19801 <p><b>Synopsis</b>
19803 <pre>
19805 void mtx_destroy(mtx_t *mtx);
19806 </pre>
19807 <p><b>Description</b>
19809 The mtx_destroy function releases any resources used by the mutex pointed to by
19810 mtx. No threads can be blocked waiting for the mutex pointed to by mtx.
19811 <p><b>Returns</b>
19813 The mtx_destroy function returns no value.
19814 <!--page 399 -->
19818 <p><b>Synopsis</b>
19820 <pre>
19822 int mtx_init(mtx_t *mtx, int type);
19823 </pre>
19824 <p><b>Description</b>
19826 The mtx_init function creates a mutex object with properties indicated by type,
19827 which must have one of the six values:
19828 <dl>
19829 <dt> mtx_plain <dd>for a simple non-recursive mutex,
19830 <dt> mtx_timed <dd>for a non-recursive mutex that supports timeout,
19831 <dt> mtx_plain | mtx_recursive <dd>for a simple recursive mutex, or
19832 <dt> mtx_timed | mtx_recursive <dd>for a recursive mutex that supports timeout.
19833 </dl>
19835 If the mtx_init function succeeds, it sets the mutex pointed to by mtx to a value that
19836 uniquely identifies the newly created mutex.
19837 <p><b>Returns</b>
19839 The mtx_init function returns thrd_success on success, or thrd_error if the
19840 request could not be honored.
19844 <p><b>Synopsis</b>
19846 <pre>
19848 int mtx_lock(mtx_t *mtx);
19849 </pre>
19850 <p><b>Description</b>
19852 The mtx_lock function blocks until it locks the mutex pointed to by mtx. If the mutex
19853 is non-recursive, it shall not be locked by the calling thread. Prior calls to mtx_unlock
19854 on the same mutex shall synchronize with this operation.
19855 <p><b>Returns</b>
19857 The mtx_lock function returns thrd_success on success, or thrd_error if the
19858 request could not be honored.
19862 <p><b>Synopsis</b>
19864 <!--page 400 -->
19865 <pre>
19867 int mtx_timedlock(mtx_t *restrict mtx,
19868 const struct timespec *restrict ts);
19869 </pre>
19870 <p><b>Description</b>
19872 The mtx_timedlock function endeavors to block until it locks the mutex pointed to by
19873 mtx or until after the TIME_UTC-based calendar time pointed to by ts. The specified
19874 mutex shall support timeout. If the operation succeeds, prior calls to mtx_unlock on
19875 the same mutex shall synchronize with this operation.
19876 <p><b>Returns</b>
19878 The mtx_timedlock function returns thrd_success on success, or
19879 thrd_timedout if the time specified was reached without acquiring the requested
19880 resource, or thrd_error if the request could not be honored.
19884 <p><b>Synopsis</b>
19886 <pre>
19888 int mtx_trylock(mtx_t *mtx);
19889 </pre>
19890 <p><b>Description</b>
19892 The mtx_trylock function endeavors to lock the mutex pointed to by mtx. If the
19893 mutex is already locked, the function returns without blocking. If the operation succeeds,
19894 prior calls to mtx_unlock on the same mutex shall synchronize with this operation.
19895 <p><b>Returns</b>
19897 The mtx_trylock function returns thrd_success on success, or thrd_busy if
19898 the resource requested is already in use, or thrd_error if the request could not be
19899 honored.
19903 <p><b>Synopsis</b>
19905 <pre>
19907 int mtx_unlock(mtx_t *mtx);
19908 </pre>
19909 <p><b>Description</b>
19911 The mtx_unlock function unlocks the mutex pointed to by mtx. The mutex pointed to
19912 by mtx shall be locked by the calling thread.
19913 <p><b>Returns</b>
19915 The mtx_unlock function returns thrd_success on success or thrd_error if
19916 the request could not be honored.
19917 <!--page 401 -->
19924 <p><b>Synopsis</b>
19926 <pre>
19928 int thrd_create(thrd_t *thr, thrd_start_t func,
19929 void *arg);
19930 </pre>
19931 <p><b>Description</b>
19933 The thrd_create function creates a new thread executing func(arg). If the
19934 thrd_create function succeeds, it sets the object pointed to by thr to the identifier of
19935 the newly created thread. (A thread's identifier may be reused for a different thread once
19936 the original thread has exited and either been detached or joined to another thread.) The
19937 completion of the thrd_create function synchronizes with the beginning of the
19938 execution of the new thread.
19939 <p><b>Returns</b>
19941 The thrd_create function returns thrd_success on success, or thrd_nomem if
19942 no memory could be allocated for the thread requested, or thrd_error if the request
19943 could not be honored.
19947 <p><b>Synopsis</b>
19949 <pre>
19951 thrd_t thrd_current(void);
19952 </pre>
19953 <p><b>Description</b>
19955 The thrd_current function identifies the thread that called it.
19956 <p><b>Returns</b>
19958 The thrd_current function returns the identifier of the thread that called it.
19962 <p><b>Synopsis</b>
19964 <pre>
19966 int thrd_detach(thrd_t thr);
19967 </pre>
19968 <p><b>Description</b>
19970 The thrd_detach function tells the operating system to dispose of any resources
19971 allocated to the thread identified by thr when that thread terminates. The thread
19972 identified by thr shall not have been previously detached or joined with another thread.
19973 <!--page 402 -->
19974 <p><b>Returns</b>
19976 The thrd_detach function returns thrd_success on success or thrd_error if
19977 the request could not be honored.
19981 <p><b>Synopsis</b>
19983 <pre>
19985 int thrd_equal(thrd_t thr0, thrd_t thr1);
19986 </pre>
19987 <p><b>Description</b>
19989 The thrd_equal function will determine whether the thread identified by thr0 refers
19990 to the thread identified by thr1.
19991 <p><b>Returns</b>
19993 The thrd_equal function returns zero if the thread thr0 and the thread thr1 refer to
19994 different threads. Otherwise the thrd_equal function returns a nonzero value.
19998 <p><b>Synopsis</b>
20000 <pre>
20002 _Noreturn void thrd_exit(int res);
20003 </pre>
20004 <p><b>Description</b>
20006 The thrd_exit function terminates execution of the calling thread and sets its result
20007 code to res.
20009 The program shall terminate normally after the last thread has been terminated. The
20010 behavior shall be as if the program called the exit function with the status
20011 EXIT_SUCCESS at thread termination time.
20012 <p><b>Returns</b>
20014 The thrd_exit function returns no value.
20018 <p><b>Synopsis</b>
20020 <pre>
20022 int thrd_join(thrd_t thr, int *res);
20023 </pre>
20024 <p><b>Description</b>
20026 The thrd_join function joins the thread identified by thr with the current thread by
20027 blocking until the other thread has terminated. If the parameter res is not a null pointer,
20028 it stores the thread's result code in the integer pointed to by res. The termination of the
20029 <!--page 403 -->
20030 other thread synchronizes with the completion of the thrd_join function. The thread
20031 identified by thr shall not have been previously detached or joined with another thread.
20032 <p><b>Returns</b>
20034 The thrd_join function returns thrd_success on success or thrd_error if the
20035 request could not be honored.
20039 <p><b>Synopsis</b>
20041 <pre>
20043 int thrd_sleep(const struct timespec *duration,
20044 struct timespec *remaining);
20045 </pre>
20046 <p><b>Description</b>
20048 The thrd_sleep function suspends execution of the calling thread until either the
20049 interval specified by duration has elapsed or a signal which is not being ignored is
20050 received. If interrupted by a signal and the remaining argument is not null, the
20051 amount of time remaining (the requested interval minus the time actually slept) is stored
20052 in the interval it points to. The duration and remaining arguments may point to the
20053 same object.
20055 The suspension time may be longer than requested because the interval is rounded up to
20056 an integer multiple of the sleep resolution or because of the scheduling of other activity
20057 by the system. But, except for the case of being interrupted by a signal, the suspension
20058 time shall not be less than that specified, as measured by the system clock TIME_UTC.
20059 <p><b>Returns</b>
20061 The thrd_sleep function returns zero if the requested time has elapsed, -1 if it has
20062 been interrupted by a signal, or a negative value if it fails.
20066 <p><b>Synopsis</b>
20068 <pre>
20070 void thrd_yield(void);
20071 </pre>
20072 <p><b>Description</b>
20074 The thrd_yield function endeavors to permit other threads to run, even if the current
20075 thread would ordinarily continue to run.
20076 <p><b>Returns</b>
20078 The thrd_yield function returns no value.
20079 <!--page 404 -->
20086 <p><b>Synopsis</b>
20088 <pre>
20090 int tss_create(tss_t *key, tss_dtor_t dtor);
20091 </pre>
20092 <p><b>Description</b>
20094 The tss_create function creates a thread-specific storage pointer with destructor
20095 dtor, which may be null.
20096 <p><b>Returns</b>
20098 If the tss_create function is successful, it sets the thread-specific storage pointed to
20099 by key to a value that uniquely identifies the newly created pointer and returns
20100 thrd_success; otherwise, thrd_error is returned and the thread-specific storage
20101 pointed to by key is set to an undefined value.
20105 <p><b>Synopsis</b>
20107 <pre>
20109 void tss_delete(tss_t key);
20110 </pre>
20111 <p><b>Description</b>
20113 The tss_delete function releases any resources used by the thread-specific storage
20114 identified by key.
20115 <p><b>Returns</b>
20117 The tss_delete function returns no value.
20121 <p><b>Synopsis</b>
20123 <pre>
20125 void *tss_get(tss_t key);
20126 </pre>
20127 <p><b>Description</b>
20129 The tss_get function returns the value for the current thread held in the thread-specific
20130 storage identified by key.
20131 <p><b>Returns</b>
20133 The tss_get function returns the value for the current thread if successful, or zero if
20134 unsuccessful.
20135 <!--page 405 -->
20139 <p><b>Synopsis</b>
20141 <pre>
20143 int tss_set(tss_t key, void *val);
20144 </pre>
20145 <p><b>Description</b>
20147 The tss_set function sets the value for the current thread held in the thread-specific
20148 storage identified by key to val.
20149 <p><b>Returns</b>
20151 The tss_set function returns thrd_success on success or thrd_error if the
20152 request could not be honored.
20153 <!--page 406 -->
20161 The header <a href="#7.27"><time.h></a> defines two macros, and declares several types and functions for
20162 manipulating time. Many functions deal with a calendar time that represents the current
20163 date (according to the Gregorian calendar) and time. Some functions deal with local
20164 time, which is the calendar time expressed for some specific time zone, and with Daylight
20165 Saving Time, which is a temporary change in the algorithm for determining local time.
20166 The local time zone and Daylight Saving Time are implementation-defined.
20169 <pre>
20170 CLOCKS_PER_SEC
20171 </pre>
20172 which expands to an expression with type clock_t (described below) that is the
20173 number per second of the value returned by the clock function; and
20174 <pre>
20175 TIME_UTC
20176 </pre>
20177 which expands to an integer constant greater than 0 that designates the UTC time
20181 <pre>
20182 clock_t
20183 </pre>
20184 and
20185 <pre>
20186 time_t
20187 </pre>
20188 which are real types capable of representing times;
20189 <pre>
20190 struct timespec
20191 </pre>
20192 which holds an interval specified in seconds and nanoseconds (which may represent a
20193 calendar time based on a particular epoch); and
20194 <pre>
20195 struct tm
20196 </pre>
20197 which holds the components of a calendar time, called the broken-down time.
20199 The range and precision of times representable in clock_t and time_t are
20200 implementation-defined. The timespec structure shall contain at least the following
20205 <!--page 407 -->
20206 <pre>
20207 time_t tv_sec; // whole seconds -- >= 0
20208 long tv_nsec; // nanoseconds -- [0, 999999999]
20209 </pre>
20210 The tm structure shall contain at least the following members, in any order. The
20211 semantics of the members and their normal ranges are expressed in the comments.<sup><a href="#note318"><b>318)</b></a></sup>
20212 <pre>
20213 int tm_sec; // seconds after the minute -- [0, 60]
20214 int tm_min; // minutes after the hour -- [0, 59]
20215 int tm_hour; // hours since midnight -- [0, 23]
20216 int tm_mday; // day of the month -- [1, 31]
20217 int tm_mon; // months since January -- [0, 11]
20218 int tm_year; // years since 1900
20219 int tm_wday; // days since Sunday -- [0, 6]
20220 int tm_yday; // days since January 1 -- [0, 365]
20221 int tm_isdst; // Daylight Saving Time flag
20222 </pre>
20223 The value of tm_isdst is positive if Daylight Saving Time is in effect, zero if Daylight
20224 Saving Time is not in effect, and negative if the information is not available.
20226 <p><b>Footnotes</b>
20227 <p><small><a name="note316" href="#note316">316)</a> Implementations may define additional time bases, but are only required to support a real time clock
20228 based on UTC.
20229 </small>
20230 <p><small><a name="note317" href="#note317">317)</a> The tv_sec member is a linear count of seconds and may not have the normal semantics of a
20231 time_t. The semantics of the members and their normal ranges are expressed in the comments.
20232 </small>
20233 <p><small><a name="note318" href="#note318">318)</a> The range [0, 60] for tm_sec allows for a positive leap second.
20234 </small>
20241 <p><b>Synopsis</b>
20243 <pre>
20245 clock_t clock(void);
20246 </pre>
20247 <p><b>Description</b>
20249 The clock function determines the processor time used.
20250 <p><b>Returns</b>
20252 The clock function returns the implementation's best approximation to the processor
20253 time used by the program since the beginning of an implementation-defined era related
20254 only to the program invocation. To determine the time in seconds, the value returned by
20255 the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
20256 the processor time used is not available or its value cannot be represented, the function
20262 <!--page 408 -->
20264 <p><b>Footnotes</b>
20265 <p><small><a name="note319" href="#note319">319)</a> In order to measure the time spent in a program, the clock function should be called at the start of
20266 the program and its return value subtracted from the value returned by subsequent calls.
20267 </small>
20271 <p><b>Synopsis</b>
20273 <pre>
20275 double difftime(time_t time1, time_t time0);
20276 </pre>
20277 <p><b>Description</b>
20279 The difftime function computes the difference between two calendar times: time1 -
20280 time0.
20281 <p><b>Returns</b>
20283 The difftime function returns the difference expressed in seconds as a double.
20287 <p><b>Synopsis</b>
20289 <pre>
20291 time_t mktime(struct tm *timeptr);
20292 </pre>
20293 <p><b>Description</b>
20295 The mktime function converts the broken-down time, expressed as local time, in the
20296 structure pointed to by timeptr into a calendar time value with the same encoding as
20297 that of the values returned by the time function. The original values of the tm_wday
20298 and tm_yday components of the structure are ignored, and the original values of the
20299 other components are not restricted to the ranges indicated above.<sup><a href="#note320"><b>320)</b></a></sup> On successful
20300 completion, the values of the tm_wday and tm_yday components of the structure are
20301 set appropriately, and the other components are set to represent the specified calendar
20302 time, but with their values forced to the ranges indicated above; the final value of
20303 tm_mday is not set until tm_mon and tm_year are determined.
20304 <p><b>Returns</b>
20306 The mktime function returns the specified calendar time encoded as a value of type
20307 time_t. If the calendar time cannot be represented, the function returns the value
20308 (time_t)(-1).
20310 EXAMPLE What day of the week is July 4, 2001?
20315 <!--page 409 -->
20316 <pre>
20319 static const char *const wday[] = {
20322 };
20323 struct tm time_str;
20324 /* ... */
20325 time_str.tm_year = 2001 - 1900;
20326 time_str.tm_mon = 7 - 1;
20327 time_str.tm_mday = 4;
20328 time_str.tm_hour = 0;
20329 time_str.tm_min = 0;
20330 time_str.tm_sec = 1;
20331 time_str.tm_isdst = -1;
20332 if (mktime(&time_str) == (time_t)(-1))
20333 time_str.tm_wday = 7;
20335 </pre>
20338 <p><b>Footnotes</b>
20339 <p><small><a name="note320" href="#note320">320)</a> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
20340 Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
20341 causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
20342 </small>
20346 <p><b>Synopsis</b>
20348 <pre>
20350 time_t time(time_t *timer);
20351 </pre>
20352 <p><b>Description</b>
20354 The time function determines the current calendar time. The encoding of the value is
20355 unspecified.
20356 <p><b>Returns</b>
20358 The time function returns the implementation's best approximation to the current
20359 calendar time. The value (time_t)(-1) is returned if the calendar time is not
20360 available. If timer is not a null pointer, the return value is also assigned to the object it
20361 points to.
20365 <p><b>Synopsis</b>
20367 <pre>
20369 int timespec_get(struct timespec *ts, int base);
20370 </pre>
20371 <p><b>Description</b>
20373 The timespec_get function sets the interval pointed to by ts to hold the current
20374 calendar time based on the specified time base.
20376 If base is TIME_UTC, the tv_sec member is set to the number of seconds since an
20377 implementation defined epoch, truncated to a whole value and the tv_nsec member is
20378 set to the integral number of nanoseconds, rounded to the resolution of the system
20379 <!--page 410 -->
20381 <p><b>Returns</b>
20383 If the timespec_get function is successful it returns the nonzero value base;
20384 otherwise, it returns zero.
20386 <p><b>Footnotes</b>
20387 <p><small><a name="note321" href="#note321">321)</a> Although a struct timespec object describes times with nanosecond resolution, the available
20388 resolution is system dependent and may even be greater than 1 second.
20389 </small>
20394 Except for the strftime function, these functions each return a pointer to one of two
20395 types of static objects: a broken-down time structure or an array of char. Execution of
20396 any of the functions that return a pointer to one of these object types may overwrite the
20397 information in any object of the same type pointed to by the value returned from any
20398 previous call to any of them and the functions are not required to avoid data races with
20399 each other.<sup><a href="#note322"><b>322)</b></a></sup> The implementation shall behave as if no other library functions call these
20400 functions.
20402 <p><b>Footnotes</b>
20403 <p><small><a name="note322" href="#note322">322)</a> Alternative time conversion functions that do avoid data races are specified in <a href="#K.3.8.2">K.3.8.2</a>.
20404 </small>
20408 <p><b>Synopsis</b>
20410 <pre>
20412 char *asctime(const struct tm *timeptr);
20413 </pre>
20414 <p><b>Description</b>
20416 The asctime function converts the broken-down time in the structure pointed to by
20417 timeptr into a string in the form
20418 <pre>
20419 Sun Sep 16 01:03:52 1973\n\0
20420 </pre>
20421 using the equivalent of the following algorithm.
20422 <pre>
20423 char *asctime(const struct tm *timeptr)
20424 {
20425 static const char wday_name[7][3] = {
20427 };
20428 static const char mon_name[12][3] = {
20431 };
20432 static char result[26];
20433 <!--page 411 -->
20435 wday_name[timeptr->tm_wday],
20436 mon_name[timeptr->tm_mon],
20437 timeptr->tm_mday, timeptr->tm_hour,
20438 timeptr->tm_min, timeptr->tm_sec,
20439 1900 + timeptr->tm_year);
20440 return result;
20441 }
20442 </pre>
20444 If any of the members of the broken-down time contain values that are outside their
20445 normal ranges,<sup><a href="#note323"><b>323)</b></a></sup> the behavior of the asctime function is undefined. Likewise, if the
20446 calculated year exceeds four digits or is less than the year 1000, the behavior is
20447 undefined.
20448 <p><b>Returns</b>
20450 The asctime function returns a pointer to the string.
20452 <p><b>Footnotes</b>
20454 </small>
20458 <p><b>Synopsis</b>
20460 <pre>
20462 char *ctime(const time_t *timer);
20463 </pre>
20464 <p><b>Description</b>
20466 The ctime function converts the calendar time pointed to by timer to local time in the
20467 form of a string. It is equivalent to
20468 <pre>
20469 asctime(localtime(timer))
20470 </pre>
20471 <p><b>Returns</b>
20473 The ctime function returns the pointer returned by the asctime function with that
20474 broken-down time as argument.
20479 <p><b>Synopsis</b>
20481 <pre>
20483 struct tm *gmtime(const time_t *timer);
20484 </pre>
20489 <!--page 412 -->
20490 <p><b>Description</b>
20492 The gmtime function converts the calendar time pointed to by timer into a broken-
20493 down time, expressed as UTC.
20494 <p><b>Returns</b>
20496 The gmtime function returns a pointer to the broken-down time, or a null pointer if the
20497 specified time cannot be converted to UTC.
20501 <p><b>Synopsis</b>
20503 <pre>
20505 struct tm *localtime(const time_t *timer);
20506 </pre>
20507 <p><b>Description</b>
20509 The localtime function converts the calendar time pointed to by timer into a
20510 broken-down time, expressed as local time.
20511 <p><b>Returns</b>
20513 The localtime function returns a pointer to the broken-down time, or a null pointer if
20514 the specified time cannot be converted to local time.
20518 <p><b>Synopsis</b>
20520 <pre>
20522 size_t strftime(char * restrict s,
20523 size_t maxsize,
20524 const char * restrict format,
20525 const struct tm * restrict timeptr);
20526 </pre>
20527 <p><b>Description</b>
20529 The strftime function places characters into the array pointed to by s as controlled by
20530 the string pointed to by format. The format shall be a multibyte character sequence,
20531 beginning and ending in its initial shift state. The format string consists of zero or
20532 more conversion specifiers and ordinary multibyte characters. A conversion specifier
20533 consists of a % character, possibly followed by an E or O modifier character (described
20534 below), followed by a character that determines the behavior of the conversion specifier.
20535 All ordinary multibyte characters (including the terminating null character) are copied
20536 unchanged into the array. If copying takes place between objects that overlap, the
20537 behavior is undefined. No more than maxsize characters are placed into the array.
20539 Each conversion specifier is replaced by appropriate characters as described in the
20540 following list. The appropriate characters are determined using the LC_TIME category
20541 <!--page 413 -->
20542 of the current locale and by the values of zero or more members of the broken-down time
20543 structure pointed to by timeptr, as specified in brackets in the description. If any of
20544 the specified values is outside the normal range, the characters stored are unspecified.
20545 <dl>
20546 <dt> %a <dd>is replaced by the locale's abbreviated weekday name. [tm_wday]
20547 <dt> %A <dd>is replaced by the locale's full weekday name. [tm_wday]
20548 <dt> %b <dd>is replaced by the locale's abbreviated month name. [tm_mon]
20549 <dt> %B <dd>is replaced by the locale's full month name. [tm_mon]
20550 <dt> %c <dd>is replaced by the locale's appropriate date and time representation. [all specified
20552 <dt> %C <dd>is replaced by the year divided by 100 and truncated to an integer, as a decimal
20553 number (00-99). [tm_year]
20554 <dt> %d <dd>is replaced by the day of the month as a decimal number (01-31). [tm_mday]
20555 <dt> %D <dd>is equivalent to ''%m/%d/%y''. [tm_mon, tm_mday, tm_year]
20556 <dt> %e <dd>is replaced by the day of the month as a decimal number (1-31); a single digit is
20557 preceded by a space. [tm_mday]
20558 <dt> %F <dd>is equivalent to ''%Y-%m-%d'' (the ISO 8601 date format). [tm_year, tm_mon,
20559 tm_mday]
20560 <dt> %g <dd>is replaced by the last 2 digits of the week-based year (see below) as a decimal
20561 number (00-99). [tm_year, tm_wday, tm_yday]
20562 <dt> %G <dd>is replaced by the week-based year (see below) as a decimal number (e.g., 1997).
20563 [tm_year, tm_wday, tm_yday]
20564 <dt> %h <dd>is equivalent to ''%b''. [tm_mon]
20565 <dt> %H <dd>is replaced by the hour (24-hour clock) as a decimal number (00-23). [tm_hour]
20566 <dt> %I <dd>is replaced by the hour (12-hour clock) as a decimal number (01-12). [tm_hour]
20567 <dt> %j <dd>is replaced by the day of the year as a decimal number (001-366). [tm_yday]
20568 <dt> %m <dd>is replaced by the month as a decimal number (01-12). [tm_mon]
20569 <dt> %M <dd>is replaced by the minute as a decimal number (00-59). [tm_min]
20570 <dt> %n <dd>is replaced by a new-line character.
20571 <dt> %p <dd>is replaced by the locale's equivalent of the AM/PM designations associated with a
20572 12-hour clock. [tm_hour]
20573 <dt> %r <dd>is replaced by the locale's 12-hour clock time. [tm_hour, tm_min, tm_sec]
20574 <dt> %R <dd>is equivalent to ''%H:%M''. [tm_hour, tm_min]
20575 <dt> %S <dd>is replaced by the second as a decimal number (00-60). [tm_sec]
20576 <dt> %t <dd>is replaced by a horizontal-tab character.
20577 <dt> %T <dd>is equivalent to ''%H:%M:%S'' (the ISO 8601 time format). [tm_hour, tm_min,
20578 tm_sec]
20579 <dt> %u <dd>is replaced by the ISO 8601 weekday as a decimal number (1-7), where Monday
20580 is 1. [tm_wday]
20581 <dt> %U <dd>is replaced by the week number of the year (the first Sunday as the first day of week
20582 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
20583 <dt> %V <dd>is replaced by the ISO 8601 week number (see below) as a decimal number
20584 <!--page 414 -->
20585 (01-53). [tm_year, tm_wday, tm_yday]
20586 <dt> %w <dd>is replaced by the weekday as a decimal number (0-6), where Sunday is 0.
20587 [tm_wday]
20588 <dt> %W <dd>is replaced by the week number of the year (the first Monday as the first day of
20589 week 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
20590 <dt> %x <dd>is replaced by the locale's appropriate date representation. [all specified in <a href="#7.27.1">7.27.1</a>]
20591 <dt> %X <dd>is replaced by the locale's appropriate time representation. [all specified in <a href="#7.27.1">7.27.1</a>]
20592 <dt> %y <dd>is replaced by the last 2 digits of the year as a decimal number (00-99).
20593 [tm_year]
20594 <dt> %Y <dd>is replaced by the year as a decimal number (e.g., 1997). [tm_year]
20595 <dt> %z <dd>is replaced by the offset from UTC in the ISO 8601 format ''-0430'' (meaning 4
20596 hours 30 minutes behind UTC, west of Greenwich), or by no characters if no time
20597 zone is determinable. [tm_isdst]
20598 <dt> %Z <dd>is replaced by the locale's time zone name or abbreviation, or by no characters if no
20599 time zone is determinable. [tm_isdst]
20600 <dt> %% <dd>is replaced by %.
20601 </dl>
20603 Some conversion specifiers can be modified by the inclusion of an E or O modifier
20604 character to indicate an alternative format or specification. If the alternative format or
20605 specification does not exist for the current locale, the modifier is ignored.
20606 <dl>
20607 <dt> %Ec <dd>is replaced by the locale's alternative date and time representation.
20608 <dt> %EC <dd>is replaced by the name of the base year (period) in the locale's alternative
20609 representation.
20610 <dt> %Ex <dd>is replaced by the locale's alternative date representation.
20611 <dt> %EX <dd>is replaced by the locale's alternative time representation.
20612 <dt> %Ey <dd>is replaced by the offset from %EC (year only) in the locale's alternative
20613 representation.
20614 <dt> %EY <dd>is replaced by the locale's full alternative year representation.
20615 <dt> %Od <dd>is replaced by the day of the month, using the locale's alternative numeric symbols
20616 (filled as needed with leading zeros, or with leading spaces if there is no alternative
20617 symbol for zero).
20618 <dt> %Oe <dd>is replaced by the day of the month, using the locale's alternative numeric symbols
20619 (filled as needed with leading spaces).
20620 <dt> %OH <dd>is replaced by the hour (24-hour clock), using the locale's alternative numeric
20621 symbols.
20622 <dt> %OI <dd>is replaced by the hour (12-hour clock), using the locale's alternative numeric
20623 symbols.
20624 <dt> %Om <dd>is replaced by the month, using the locale's alternative numeric symbols.
20625 <dt> %OM <dd>is replaced by the minutes, using the locale's alternative numeric symbols.
20626 <dt> %OS <dd>is replaced by the seconds, using the locale's alternative numeric symbols.
20627 <dt> %Ou <dd>is replaced by the ISO 8601 weekday as a number in the locale's alternative
20628 <!--page 415 -->
20629 representation, where Monday is 1.
20630 <dt> %OU <dd>is replaced by the week number, using the locale's alternative numeric symbols.
20631 <dt> %OV <dd>is replaced by the ISO 8601 week number, using the locale's alternative numeric
20632 symbols.
20633 <dt> %Ow <dd>is replaced by the weekday as a number, using the locale's alternative numeric
20634 symbols.
20635 <dt> %OW <dd>is replaced by the week number of the year, using the locale's alternative numeric
20636 symbols.
20637 <dt> %Oy <dd>is replaced by the last 2 digits of the year, using the locale's alternative numeric
20638 symbols.
20639 </dl>
20641 %g, %G, and %V give values according to the ISO 8601 week-based year. In this system,
20642 weeks begin on a Monday and week 1 of the year is the week that includes January 4th,
20643 which is also the week that includes the first Thursday of the year, and is also the first
20644 week that contains at least four days in the year. If the first Monday of January is the
20645 2nd, 3rd, or 4th, the preceding days are part of the last week of the preceding year; thus,
20646 for Saturday 2nd January 1999, %G is replaced by 1998 and %V is replaced by 53. If
20647 December 29th, 30th, or 31st is a Monday, it and any following days are part of week 1 of
20648 the following year. Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and
20649 %V is replaced by 01.
20651 If a conversion specifier is not one of the above, the behavior is undefined.
20654 following specifiers are:
20655 <dl>
20656 <dt> %a <dd>the first three characters of %A.
20657 <dt> %A <dd>one of ''Sunday'', ''Monday'', ... , ''Saturday''.
20658 <dt> %b <dd>the first three characters of %B.
20659 <dt> %B <dd>one of ''January'', ''February'', ... , ''December''.
20660 <dt> %c <dd>equivalent to ''%a %b %e %T %Y''.
20661 <dt> %p <dd>one of ''AM'' or ''PM''.
20662 <dt> %r <dd>equivalent to ''%I:%M:%S %p''.
20663 <dt> %x <dd>equivalent to ''%m/%d/%y''.
20664 <dt> %X <dd>equivalent to %T.
20665 <dt> %Z <dd>implementation-defined.
20666 </dl>
20667 <p><b>Returns</b>
20669 If the total number of resulting characters including the terminating null character is not
20670 more than maxsize, the strftime function returns the number of characters placed
20671 into the array pointed to by s not including the terminating null character. Otherwise,
20672 zero is returned and the contents of the array are indeterminate.
20673 <!--page 416 -->
20678 The header <a href="#7.28"><uchar.h></a> declares types and functions for manipulating Unicode
20679 characters.
20681 The types declared are mbstate_t (described in <a href="#7.30.1">7.30.1</a>) and size_t (described in
20683 <pre>
20684 char16_t
20685 </pre>
20686 which is an unsigned integer type used for 16-bit characters and is the same type as
20688 <pre>
20689 char32_t
20690 </pre>
20691 which is an unsigned integer type used for 32-bit characters and is the same type as
20695 <h4><a name="7.28.1" href="#7.28.1">7.28.1 Restartable multibyte/wide character conversion functions</a></h4>
20697 These functions have a parameter, ps, of type pointer to mbstate_t that points to an
20698 object that can completely describe the current conversion state of the associated
20699 multibyte character sequence, which the functions alter as necessary. If ps is a null
20700 pointer, each function uses its own internal mbstate_t object instead, which is
20701 initialized at program startup to the initial conversion state; the functions are not required
20702 to avoid data races with other calls to the same function in this case. The implementation
20703 behaves as if no library function calls these functions with a null pointer for ps.
20707 <p><b>Synopsis</b>
20709 <pre>
20711 size_t mbrtoc16(char16_t * restrict pc16,
20712 const char * restrict s, size_t n,
20713 mbstate_t * restrict ps);
20714 </pre>
20715 <p><b>Description</b>
20717 If s is a null pointer, the mbrtoc16 function is equivalent to the call:
20718 <pre>
20720 </pre>
20721 In this case, the values of the parameters pc16 and n are ignored.
20723 If s is not a null pointer, the mbrtoc16 function inspects at most n bytes beginning with
20724 the byte pointed to by s to determine the number of bytes needed to complete the next
20725 multibyte character (including any shift sequences). If the function determines that the
20726 next multibyte character is complete and valid, it determines the values of the
20727 corresponding wide characters and then, if pc16 is not a null pointer, stores the value of
20728 the first (or only) such character in the object pointed to by pc16. Subsequent calls will
20729 <!--page 417 -->
20730 store successive wide characters without consuming any additional input until all the
20731 characters have been stored. If the corresponding wide character is the null wide
20732 character, the resulting state described is the initial conversion state.
20733 <p><b>Returns</b>
20735 The mbrtoc16 function returns the first of the following that applies (given the current
20736 conversion state):
20737 <dl>
20738 <dt> 0 <dd>if the next n or fewer bytes complete the multibyte character that
20739 corresponds to the null wide character (which is the value stored).
20740 <dt> between 1 and n inclusive <dd>if the next n or fewer bytes complete a valid multibyte
20741 character (which is the value stored); the value returned is the number
20742 of bytes that complete the multibyte character.
20743 <dt> (size_t)(-3) <dd>if the next character resulting from a previous call has been stored (no
20744 bytes from the input have been consumed by this call).
20745 <dt> (size_t)(-2) <dd>if the next n bytes contribute to an incomplete (but potentially valid)
20746 multibyte character, and all n bytes have been processed (no value is
20748 <dt> (size_t)(-1) <dd>if an encoding error occurs, in which case the next n or fewer bytes
20749 do not contribute to a complete and valid multibyte character (no
20750 value is stored); the value of the macro EILSEQ is stored in errno,
20751 and the conversion state is unspecified.
20752 </dl>
20754 <p><b>Footnotes</b>
20755 <p><small><a name="note324" href="#note324">324)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
20756 sequence of redundant shift sequences (for implementations with state-dependent encodings).
20757 </small>
20761 <p><b>Synopsis</b>
20763 <pre>
20765 size_t c16rtomb(char * restrict s, char16_t c16,
20766 mbstate_t * restrict ps);
20767 </pre>
20768 <p><b>Description</b>
20770 If s is a null pointer, the c16rtomb function is equivalent to the call
20771 <pre>
20772 c16rtomb(buf, L'\0', ps)
20773 </pre>
20774 where buf is an internal buffer.
20776 If s is not a null pointer, the c16rtomb function determines the number of bytes needed
20777 to represent the multibyte character that corresponds to the wide character given by c16
20778 (including any shift sequences), and stores the multibyte character representation in the
20780 <!--page 418 -->
20781 array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
20782 c16 is a null wide character, a null byte is stored, preceded by any shift sequence needed
20783 to restore the initial shift state; the resulting state described is the initial conversion state.
20784 <p><b>Returns</b>
20786 The c16rtomb function returns the number of bytes stored in the array object (including
20787 any shift sequences). When c16 is not a valid wide character, an encoding error occurs:
20788 the function stores the value of the macro EILSEQ in errno and returns
20789 (size_t)(-1); the conversion state is unspecified.
20793 <p><b>Synopsis</b>
20795 <pre>
20797 size_t mbrtoc32(char32_t * restrict pc32,
20798 const char * restrict s, size_t n,
20799 mbstate_t * restrict ps);
20800 </pre>
20801 <p><b>Description</b>
20803 If s is a null pointer, the mbrtoc32 function is equivalent to the call:
20804 <pre>
20806 </pre>
20807 In this case, the values of the parameters pc32 and n are ignored.
20809 If s is not a null pointer, the mbrtoc32 function inspects at most n bytes beginning with
20810 the byte pointed to by s to determine the number of bytes needed to complete the next
20811 multibyte character (including any shift sequences). If the function determines that the
20812 next multibyte character is complete and valid, it determines the values of the
20813 corresponding wide characters and then, if pc32 is not a null pointer, stores the value of
20814 the first (or only) such character in the object pointed to by pc32. Subsequent calls will
20815 store successive wide characters without consuming any additional input until all the
20816 characters have been stored. If the corresponding wide character is the null wide
20817 character, the resulting state described is the initial conversion state.
20818 <p><b>Returns</b>
20820 The mbrtoc32 function returns the first of the following that applies (given the current
20821 conversion state):
20822 <dl>
20823 <dt> 0 <dd>if the next n or fewer bytes complete the multibyte character that
20824 corresponds to the null wide character (which is the value stored).
20825 <dt> between 1 and n inclusive <dd>if the next n or fewer bytes complete a valid multibyte
20826 <!--page 419 -->
20827 character (which is the value stored); the value returned is the number
20828 of bytes that complete the multibyte character.
20829 <dt> (size_t)(-3) <dd>if the next character resulting from a previous call has been stored (no
20830 bytes from the input have been consumed by this call).
20831 <dt> (size_t)(-2) <dd>if the next n bytes contribute to an incomplete (but potentially valid)
20832 multibyte character, and all n bytes have been processed (no value is
20834 <dt> (size_t)(-1) <dd>if an encoding error occurs, in which case the next n or fewer bytes
20835 do not contribute to a complete and valid multibyte character (no
20836 value is stored); the value of the macro EILSEQ is stored in errno,
20837 and the conversion state is unspecified.
20838 </dl>
20840 <p><b>Footnotes</b>
20841 <p><small><a name="note325" href="#note325">325)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
20842 sequence of redundant shift sequences (for implementations with state-dependent encodings).
20843 </small>
20847 <p><b>Synopsis</b>
20849 <pre>
20851 size_t c32rtomb(char * restrict s, char32_t c32,
20852 mbstate_t * restrict ps);
20853 </pre>
20854 <p><b>Description</b>
20856 If s is a null pointer, the c32rtomb function is equivalent to the call
20857 <pre>
20858 c32rtomb(buf, L'\0', ps)
20859 </pre>
20860 where buf is an internal buffer.
20862 If s is not a null pointer, the c32rtomb function determines the number of bytes needed
20863 to represent the multibyte character that corresponds to the wide character given by c32
20864 (including any shift sequences), and stores the multibyte character representation in the
20865 array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
20866 c32 is a null wide character, a null byte is stored, preceded by any shift sequence needed
20867 to restore the initial shift state; the resulting state described is the initial conversion state.
20868 <p><b>Returns</b>
20870 The c32rtomb function returns the number of bytes stored in the array object (including
20871 any shift sequences). When c32 is not a valid wide character, an encoding error occurs:
20872 the function stores the value of the macro EILSEQ in errno and returns
20873 (size_t)(-1); the conversion state is unspecified.
20878 <!--page 420 -->
20881 <h3><a name="7.29" href="#7.29">7.29 Extended multibyte and wide character utilities <wchar.h></a></h3>
20886 The header <a href="#7.29"><wchar.h></a> defines four macros, and declares four data types, one tag, and
20890 <pre>
20891 mbstate_t
20892 </pre>
20893 which is a complete object type other than an array type that can hold the conversion state
20894 information necessary to convert between sequences of multibyte characters and wide
20895 characters;
20896 <pre>
20897 wint_t
20898 </pre>
20899 which is an integer type unchanged by default argument promotions that can hold any
20900 value corresponding to members of the extended character set, as well as at least one
20901 value that does not correspond to any member of the extended character set (see WEOF
20903 <pre>
20904 struct tm
20905 </pre>
20906 which is declared as an incomplete structure type (the contents are described in <a href="#7.27.1">7.27.1</a>).
20910 <pre>
20911 WEOF
20912 </pre>
20913 which expands to a constant expression of type wint_t whose value does not
20914 correspond to any member of the extended character set.<sup><a href="#note328"><b>328)</b></a></sup> It is accepted (and returned)
20915 by several functions in this subclause to indicate end-of-file, that is, no more input from a
20916 stream. It is also used as a wide character value that does not correspond to any member
20917 of the extended character set.
20919 The functions declared are grouped as follows:
20920 <ul>
20921 <li> Functions that perform input and output of wide characters, or multibyte characters,
20922 or both;
20923 <li> Functions that provide wide string numeric conversion;
20924 <li> Functions that perform general wide string manipulation;
20927 <!--page 421 -->
20928 <li> Functions for wide string date and time conversion; and
20929 <li> Functions that provide extended capabilities for conversion between multibyte and
20930 wide character sequences.
20931 </ul>
20933 Arguments to the functions in this subclause may point to arrays containing wchar_t
20934 values that do not correspond to members of the extended character set. Such values
20935 shall be processed according to the specified semantics, except that it is unspecified
20936 whether an encoding error occurs if such a value appears in the format string for a
20937 function in <a href="#7.29.2">7.29.2</a> or <a href="#7.29.5">7.29.5</a> and the specified semantics do not require that value to be
20938 processed by wcrtomb.
20940 Unless explicitly stated otherwise, if the execution of a function described in this
20941 subclause causes copying to take place between objects that overlap, the behavior is
20942 undefined.
20944 <p><b>Footnotes</b>
20945 <p><small><a name="note326" href="#note326">326)</a> See ''future library directions'' (<a href="#7.31.16">7.31.16</a>).
20946 </small>
20947 <p><small><a name="note327" href="#note327">327)</a> wchar_t and wint_t can be the same integer type.
20948 </small>
20949 <p><small><a name="note328" href="#note328">328)</a> The value of the macro WEOF may differ from that of EOF and need not be negative.
20950 </small>
20953 <h4><a name="7.29.2" href="#7.29.2">7.29.2 Formatted wide character input/output functions</a></h4>
20955 The formatted wide character input/output functions shall behave as if there is a sequence
20956 point after the actions associated with each specifier.<sup><a href="#note329"><b>329)</b></a></sup>
20958 <p><b>Footnotes</b>
20959 <p><small><a name="note329" href="#note329">329)</a> The fwprintf functions perform writes to memory for the %n specifier.
20960 </small>
20964 <p><b>Synopsis</b>
20966 <pre>
20969 int fwprintf(FILE * restrict stream,
20970 const wchar_t * restrict format, ...);
20971 </pre>
20972 <p><b>Description</b>
20974 The fwprintf function writes output to the stream pointed to by stream, under
20975 control of the wide string pointed to by format that specifies how subsequent arguments
20976 are converted for output. If there are insufficient arguments for the format, the behavior
20977 is undefined. If the format is exhausted while arguments remain, the excess arguments
20978 are evaluated (as always) but are otherwise ignored. The fwprintf function returns
20979 when the end of the format string is encountered.
20981 The format is composed of zero or more directives: ordinary wide characters (not %),
20982 which are copied unchanged to the output stream; and conversion specifications, each of
20983 which results in fetching zero or more subsequent arguments, converting them, if
20984 applicable, according to the corresponding conversion specifier, and then writing the
20985 result to the output stream.
20989 <!--page 422 -->
20991 Each conversion specification is introduced by the wide character %. After the %, the
20992 following appear in sequence:
20993 <ul>
20994 <li> Zero or more flags (in any order) that modify the meaning of the conversion
20995 specification.
20996 <li> An optional minimum field width. If the converted value has fewer wide characters
20997 than the field width, it is padded with spaces (by default) on the left (or right, if the
20998 left adjustment flag, described later, has been given) to the field width. The field
20999 width takes the form of an asterisk * (described later) or a nonnegative decimal
21001 <li> An optional precision that gives the minimum number of digits to appear for the d, i,
21002 o, u, x, and X conversions, the number of digits to appear after the decimal-point
21003 wide character for a, A, e, E, f, and F conversions, the maximum number of
21004 significant digits for the g and G conversions, or the maximum number of wide
21005 characters to be written for s conversions. The precision takes the form of a period
21006 (.) followed either by an asterisk * (described later) or by an optional decimal
21007 integer; if only the period is specified, the precision is taken as zero. If a precision
21008 appears with any other conversion specifier, the behavior is undefined.
21009 <li> An optional length modifier that specifies the size of the argument.
21010 <li> A conversion specifier wide character that specifies the type of conversion to be
21011 applied.
21012 </ul>
21014 As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
21015 this case, an int argument supplies the field width or precision. The arguments
21016 specifying field width, or precision, or both, shall appear (in that order) before the
21017 argument (if any) to be converted. A negative field width argument is taken as a - flag
21018 followed by a positive field width. A negative precision argument is taken as if the
21019 precision were omitted.
21021 The flag wide characters and their meanings are:
21022 <dl>
21023 <dt> - <dd>The result of the conversion is left-justified within the field. (It is right-justified if
21024 this flag is not specified.)
21025 <dt> + <dd>The result of a signed conversion always begins with a plus or minus sign. (It
21026 begins with a sign only when a negative value is converted if this flag is not
21027 <!--page 423 -->
21029 <dt> space <dd>If the first wide character of a signed conversion is not a sign, or if a signed
21030 conversion results in no wide characters, a space is prefixed to the result. If the
21031 space and + flags both appear, the space flag is ignored.
21032 <dt> # <dd>The result is converted to an ''alternative form''. For o conversion, it increases
21033 the precision, if and only if necessary, to force the first digit of the result to be a
21034 zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
21035 conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
21036 and G conversions, the result of converting a floating-point number always
21037 contains a decimal-point wide character, even if no digits follow it. (Normally, a
21038 decimal-point wide character appears in the result of these conversions only if a
21039 digit follows it.) For g and G conversions, trailing zeros are not removed from the
21040 result. For other conversions, the behavior is undefined.
21041 <dt> 0 <dd>For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
21042 (following any indication of sign or base) are used to pad to the field width rather
21043 than performing space padding, except when converting an infinity or NaN. If the
21044 0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
21045 conversions, if a precision is specified, the 0 flag is ignored. For other
21046 conversions, the behavior is undefined.
21047 </dl>
21049 The length modifiers and their meanings are:
21050 <dl>
21051 <dt> hh <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
21052 signed char or unsigned char argument (the argument will have
21053 been promoted according to the integer promotions, but its value shall be
21054 converted to signed char or unsigned char before printing); or that
21055 a following n conversion specifier applies to a pointer to a signed char
21056 argument.
21057 <dt> h <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
21058 short int or unsigned short int argument (the argument will
21059 have been promoted according to the integer promotions, but its value shall
21060 be converted to short int or unsigned short int before printing);
21061 or that a following n conversion specifier applies to a pointer to a short
21062 int argument.
21063 <dt> l (ell) <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
21064 long int or unsigned long int argument; that a following n
21065 conversion specifier applies to a pointer to a long int argument; that a
21066 <!--page 424 -->
21067 following c conversion specifier applies to a wint_t argument; that a
21068 following s conversion specifier applies to a pointer to a wchar_t
21069 argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
21070 specifier.
21071 <dt> ll (ell-ell) <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
21072 long long int or unsigned long long int argument; or that a
21073 following n conversion specifier applies to a pointer to a long long int
21074 argument.
21075 <dt> j <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to
21076 an intmax_t or uintmax_t argument; or that a following n conversion
21077 specifier applies to a pointer to an intmax_t argument.
21078 <dt> z <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
21079 size_t or the corresponding signed integer type argument; or that a
21080 following n conversion specifier applies to a pointer to a signed integer type
21081 corresponding to size_t argument.
21082 <dt> t <dd>Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
21083 ptrdiff_t or the corresponding unsigned integer type argument; or that a
21084 following n conversion specifier applies to a pointer to a ptrdiff_t
21085 argument.
21086 <dt> L <dd>Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
21087 applies to a long double argument.
21088 </dl>
21089 If a length modifier appears with any conversion specifier other than as specified above,
21090 the behavior is undefined.
21092 The conversion specifiers and their meanings are:
21093 <dt> d,i <dd>The int argument is converted to signed decimal in the style [-]dddd. The
21094 precision specifies the minimum number of digits to appear; if the value
21095 being converted can be represented in fewer digits, it is expanded with
21096 leading zeros. The default precision is 1. The result of converting a zero
21097 value with a precision of zero is no wide characters.
21098 <dt> o,u,x,X <dd>The unsigned int argument is converted to unsigned octal (o), unsigned
21099 <!--page 425 -->
21100 decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
21101 letters abcdef are used for x conversion and the letters ABCDEF for X
21102 conversion. The precision specifies the minimum number of digits to appear;
21103 if the value being converted can be represented in fewer digits, it is expanded
21104 with leading zeros. The default precision is 1. The result of converting a
21105 zero value with a precision of zero is no wide characters.
21106 <dt> f,F <dd>A double argument representing a floating-point number is converted to
21107 decimal notation in the style [-]ddd.ddd, where the number of digits after
21108 the decimal-point wide character is equal to the precision specification. If the
21109 precision is missing, it is taken as 6; if the precision is zero and the # flag is
21110 not specified, no decimal-point wide character appears. If a decimal-point
21111 wide character appears, at least one digit appears before it. The value is
21112 rounded to the appropriate number of digits.
21113 A double argument representing an infinity is converted in one of the styles
21114 [-]inf or [-]infinity -- which style is implementation-defined. A
21115 double argument representing a NaN is converted in one of the styles
21116 [-]nan or [-]nan(n-wchar-sequence) -- which style, and the meaning of
21117 any n-wchar-sequence, is implementation-defined. The F conversion
21118 specifier produces INF, INFINITY, or NAN instead of inf, infinity, or
21120 <dt> e,E <dd>A double argument representing a floating-point number is converted in the
21121 style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
21122 argument is nonzero) before the decimal-point wide character and the number
21123 of digits after it is equal to the precision; if the precision is missing, it is taken
21124 as 6; if the precision is zero and the # flag is not specified, no decimal-point
21125 wide character appears. The value is rounded to the appropriate number of
21126 digits. The E conversion specifier produces a number with E instead of e
21127 introducing the exponent. The exponent always contains at least two digits,
21128 and only as many more digits as necessary to represent the exponent. If the
21129 value is zero, the exponent is zero.
21130 A double argument representing an infinity or NaN is converted in the style
21131 of an f or F conversion specifier.
21132 <dt> g,G <dd>A double argument representing a floating-point number is converted in
21133 style f or e (or in style F or E in the case of a G conversion specifier),
21134 depending on the value converted and the precision. Let P equal the
21135 precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
21136 Then, if a conversion with style E would have an exponent of X:
21137 <ul>
21138 <li> if P > X >= -4, the conversion is with style f (or F) and precision
21139 P - (X + 1).
21140 <li> otherwise, the conversion is with style e (or E) and precision P - 1.
21141 </ul>
21142 Finally, unless the # flag is used, any trailing zeros are removed from the
21143 <!--page 426 -->
21144 fractional portion of the result and the decimal-point wide character is
21145 removed if there is no fractional portion remaining.
21146 A double argument representing an infinity or NaN is converted in the style
21147 of an f or F conversion specifier.
21148 <dt> a,A <dd>A double argument representing a floating-point number is converted in the
21149 style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
21150 nonzero if the argument is a normalized floating-point number and is
21151 otherwise unspecified) before the decimal-point wide character<sup><a href="#note333"><b>333)</b></a></sup> and the
21152 number of hexadecimal digits after it is equal to the precision; if the precision
21153 is missing and FLT_RADIX is a power of 2, then the precision is sufficient
21154 for an exact representation of the value; if the precision is missing and
21155 FLT_RADIX is not a power of 2, then the precision is sufficient to
21156 distinguish<sup><a href="#note334"><b>334)</b></a></sup> values of type double, except that trailing zeros may be
21157 omitted; if the precision is zero and the # flag is not specified, no decimal-
21158 point wide character appears. The letters abcdef are used for a conversion
21159 and the letters ABCDEF for A conversion. The A conversion specifier
21160 produces a number with X and P instead of x and p. The exponent always
21161 contains at least one digit, and only as many more digits as necessary to
21162 represent the decimal exponent of 2. If the value is zero, the exponent is
21163 zero.
21164 A double argument representing an infinity or NaN is converted in the style
21165 of an f or F conversion specifier.
21166 <dt> c <dd>If no l length modifier is present, the int argument is converted to a wide
21167 character as if by calling btowc and the resulting wide character is written.
21168 If an l length modifier is present, the wint_t argument is converted to
21169 wchar_t and written.
21170 <dt> s <dd>If no l length modifier is present, the argument shall be a pointer to the initial
21171 element of a character array containing a multibyte character sequence
21172 beginning in the initial shift state. Characters from the array are converted as
21173 if by repeated calls to the mbrtowc function, with the conversion state
21174 described by an mbstate_t object initialized to zero before the first
21175 multibyte character is converted, and written up to (but not including) the
21176 <!--page 427 -->
21177 terminating null wide character. If the precision is specified, no more than
21178 that many wide characters are written. If the precision is not specified or is
21179 greater than the size of the converted array, the converted array shall contain a
21180 null wide character.
21181 If an l length modifier is present, the argument shall be a pointer to the initial
21182 element of an array of wchar_t type. Wide characters from the array are
21183 written up to (but not including) a terminating null wide character. If the
21184 precision is specified, no more than that many wide characters are written. If
21185 the precision is not specified or is greater than the size of the array, the array
21186 shall contain a null wide character.
21187 <dt> p <dd>The argument shall be a pointer to void. The value of the pointer is
21188 converted to a sequence of printing wide characters, in an implementation-
21189 defined manner.
21190 <dt> n <dd>The argument shall be a pointer to signed integer into which is written the
21191 number of wide characters written to the output stream so far by this call to
21192 fwprintf. No argument is converted, but one is consumed. If the
21193 conversion specification includes any flags, a field width, or a precision, the
21194 behavior is undefined.
21195 <dt> % <dd>A % wide character is written. No argument is converted. The complete
21196 conversion specification shall be %%.
21197 </dl>
21199 If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note335"><b>335)</b></a></sup> If any argument is
21200 not the correct type for the corresponding conversion specification, the behavior is
21201 undefined.
21203 In no case does a nonexistent or small field width cause truncation of a field; if the result
21204 of a conversion is wider than the field width, the field is expanded to contain the
21205 conversion result.
21207 For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
21208 to a hexadecimal floating number with the given precision.
21209 <p><b>Recommended practice</b>
21211 For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
21212 representable in the given precision, the result should be one of the two adjacent numbers
21213 in hexadecimal floating style with the given precision, with the extra stipulation that the
21214 error should have a correct sign for the current rounding direction.
21216 For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
21217 DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note336"><b>336)</b></a></sup> If the number of
21219 <!--page 428 -->
21220 significant decimal digits is more than DECIMAL_DIG but the source value is exactly
21221 representable with DECIMAL_DIG digits, then the result should be an exact
21222 representation with trailing zeros. Otherwise, the source value is bounded by two
21223 adjacent decimal strings L < U, both having DECIMAL_DIG significant digits; the value
21224 of the resultant decimal string D should satisfy L <= D <= U, with the extra stipulation that
21225 the error should have a correct sign for the current rounding direction.
21226 <p><b>Returns</b>
21228 The fwprintf function returns the number of wide characters transmitted, or a negative
21229 value if an output or encoding error occurred.
21230 <p><b>Environmental limits</b>
21232 The number of wide characters that can be produced by any single conversion shall be at
21233 least 4095.
21235 EXAMPLE To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
21236 places:
21237 <pre>
21241 /* ... */
21242 wchar_t *weekday, *month; // pointers to wide strings
21243 int day, hour, min;
21245 weekday, month, day, hour, min);
21247 </pre>
21249 <p><b> Forward references</b>: the btowc function (<a href="#7.29.6.1.1">7.29.6.1.1</a>), the mbrtowc function
21252 <p><b>Footnotes</b>
21253 <p><small><a name="note330" href="#note330">330)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
21254 </small>
21255 <p><small><a name="note331" href="#note331">331)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
21256 include a minus sign.
21257 </small>
21258 <p><small><a name="note332" href="#note332">332)</a> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
21259 meaning; the # and 0 flag wide characters have no effect.
21260 </small>
21261 <p><small><a name="note333" href="#note333">333)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
21262 character so that subsequent digits align to nibble (4-bit) boundaries.
21263 </small>
21264 <p><small><a name="note334" href="#note334">334)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 > b n where b is
21265 FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
21266 might suffice depending on the implementation's scheme for determining the digit to the left of the
21267 decimal-point wide character.
21268 </small>
21269 <p><small><a name="note335" href="#note335">335)</a> See ''future library directions'' (<a href="#7.31.16">7.31.16</a>).
21270 </small>
21271 <p><small><a name="note336" href="#note336">336)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
21272 given format specifier. The number of significant digits is determined by the format specifier, and in
21273 the case of fixed-point conversion by the source value as well.
21274 </small>
21278 <p><b>Synopsis</b>
21280 <pre>
21283 int fwscanf(FILE * restrict stream,
21284 const wchar_t * restrict format, ...);
21285 </pre>
21286 <p><b>Description</b>
21288 The fwscanf function reads input from the stream pointed to by stream, under
21289 control of the wide string pointed to by format that specifies the admissible input
21290 sequences and how they are to be converted for assignment, using subsequent arguments
21292 <!--page 429 -->
21293 as pointers to the objects to receive the converted input. If there are insufficient
21294 arguments for the format, the behavior is undefined. If the format is exhausted while
21295 arguments remain, the excess arguments are evaluated (as always) but are otherwise
21296 ignored.
21298 The format is composed of zero or more directives: one or more white-space wide
21299 characters, an ordinary wide character (neither % nor a white-space wide character), or a
21300 conversion specification. Each conversion specification is introduced by the wide
21301 character %. After the %, the following appear in sequence:
21302 <ul>
21303 <li> An optional assignment-suppressing wide character *.
21304 <li> An optional decimal integer greater than zero that specifies the maximum field width
21305 (in wide characters).
21306 <li> An optional length modifier that specifies the size of the receiving object.
21307 <li> A conversion specifier wide character that specifies the type of conversion to be
21308 applied.
21309 </ul>
21311 The fwscanf function executes each directive of the format in turn. When all directives
21312 have been executed, or if a directive fails (as detailed below), the function returns.
21313 Failures are described as input failures (due to the occurrence of an encoding error or the
21314 unavailability of input characters), or matching failures (due to inappropriate input).
21316 A directive composed of white-space wide character(s) is executed by reading input up to
21317 the first non-white-space wide character (which remains unread), or until no more wide
21318 characters can be read. The directive never fails.
21320 A directive that is an ordinary wide character is executed by reading the next wide
21321 character of the stream. If that wide character differs from the directive, the directive
21322 fails and the differing and subsequent wide characters remain unread. Similarly, if end-
21323 of-file, an encoding error, or a read error prevents a wide character from being read, the
21324 directive fails.
21326 A directive that is a conversion specification defines a set of matching input sequences, as
21327 described below for each specifier. A conversion specification is executed in the
21328 following steps:
21330 Input white-space wide characters (as specified by the iswspace function) are skipped,
21331 unless the specification includes a [, c, or n specifier.<sup><a href="#note337"><b>337)</b></a></sup>
21333 An input item is read from the stream, unless the specification includes an n specifier. An
21334 input item is defined as the longest sequence of input wide characters which does not
21335 exceed any specified field width and which is, or is a prefix of, a matching input
21338 <!--page 430 -->
21339 sequence.<sup><a href="#note338"><b>338)</b></a></sup> The first wide character, if any, after the input item remains unread. If the
21340 length of the input item is zero, the execution of the directive fails; this condition is a
21341 matching failure unless end-of-file, an encoding error, or a read error prevented input
21342 from the stream, in which case it is an input failure.
21344 Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
21345 count of input wide characters) is converted to a type appropriate to the conversion
21346 specifier. If the input item is not a matching sequence, the execution of the directive fails:
21347 this condition is a matching failure. Unless assignment suppression was indicated by a *,
21348 the result of the conversion is placed in the object pointed to by the first argument
21349 following the format argument that has not already received a conversion result. If this
21350 object does not have an appropriate type, or if the result of the conversion cannot be
21351 represented in the object, the behavior is undefined.
21353 The length modifiers and their meanings are:
21354 <dl>
21355 <dt> hh <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
21356 to an argument with type pointer to signed char or unsigned char.
21357 <dt> h <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
21358 to an argument with type pointer to short int or unsigned short
21359 int.
21360 <dt> l (ell) <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
21361 to an argument with type pointer to long int or unsigned long
21362 int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
21363 an argument with type pointer to double; or that a following c, s, or [
21364 conversion specifier applies to an argument with type pointer to wchar_t.
21365 <dt> ll (ell-ell) <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
21366 to an argument with type pointer to long long int or unsigned
21367 long long int.
21368 <dt> j <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
21369 to an argument with type pointer to intmax_t or uintmax_t.
21370 <dt> z <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
21371 to an argument with type pointer to size_t or the corresponding signed
21372 integer type.
21373 <dt> t <dd>Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
21374 to an argument with type pointer to ptrdiff_t or the corresponding
21375 unsigned integer type.
21376 <!--page 431 -->
21377 <dt> L <dd>Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
21378 applies to an argument with type pointer to long double.
21379 </dl>
21380 If a length modifier appears with any conversion specifier other than as specified above,
21381 the behavior is undefined.
21383 The conversion specifiers and their meanings are:
21384 <dt> d <dd>Matches an optionally signed decimal integer, whose format is the same as
21385 expected for the subject sequence of the wcstol function with the value 10
21386 for the base argument. The corresponding argument shall be a pointer to
21387 signed integer.
21388 <dt> i <dd>Matches an optionally signed integer, whose format is the same as expected
21389 for the subject sequence of the wcstol function with the value 0 for the
21390 base argument. The corresponding argument shall be a pointer to signed
21391 integer.
21392 <dt> o <dd>Matches an optionally signed octal integer, whose format is the same as
21393 expected for the subject sequence of the wcstoul function with the value 8
21394 for the base argument. The corresponding argument shall be a pointer to
21395 unsigned integer.
21396 <dt> u <dd>Matches an optionally signed decimal integer, whose format is the same as
21397 expected for the subject sequence of the wcstoul function with the value 10
21398 for the base argument. The corresponding argument shall be a pointer to
21399 unsigned integer.
21400 <dt> x <dd>Matches an optionally signed hexadecimal integer, whose format is the same
21401 as expected for the subject sequence of the wcstoul function with the value
21402 16 for the base argument. The corresponding argument shall be a pointer to
21403 unsigned integer.
21404 <dt> a,e,f,g <dd>Matches an optionally signed floating-point number, infinity, or NaN, whose
21405 format is the same as expected for the subject sequence of the wcstod
21406 function. The corresponding argument shall be a pointer to floating.
21407 <dt> c <dd>Matches a sequence of wide characters of exactly the number specified by the
21408 field width (1 if no field width is present in the directive).
21409 If no l length modifier is present, characters from the input field are
21410 converted as if by repeated calls to the wcrtomb function, with the
21411 conversion state described by an mbstate_t object initialized to zero
21412 before the first wide character is converted. The corresponding argument
21413 shall be a pointer to the initial element of a character array large enough to
21414 accept the sequence. No null character is added.
21415 If an l length modifier is present, the corresponding argument shall be a
21416 <!--page 432 -->
21417 pointer to the initial element of an array of wchar_t large enough to accept
21418 the sequence. No null wide character is added.
21419 <dt> s <dd>Matches a sequence of non-white-space wide characters.
21420 If no l length modifier is present, characters from the input field are
21421 converted as if by repeated calls to the wcrtomb function, with the
21422 conversion state described by an mbstate_t object initialized to zero
21423 before the first wide character is converted. The corresponding argument
21424 shall be a pointer to the initial element of a character array large enough to
21425 accept the sequence and a terminating null character, which will be added
21426 automatically.
21427 If an l length modifier is present, the corresponding argument shall be a
21428 pointer to the initial element of an array of wchar_t large enough to accept
21429 the sequence and the terminating null wide character, which will be added
21430 automatically.
21431 <dt> [ <dd>Matches a nonempty sequence of wide characters from a set of expected
21432 characters (the scanset).
21433 If no l length modifier is present, characters from the input field are
21434 converted as if by repeated calls to the wcrtomb function, with the
21435 conversion state described by an mbstate_t object initialized to zero
21436 before the first wide character is converted. The corresponding argument
21437 shall be a pointer to the initial element of a character array large enough to
21438 accept the sequence and a terminating null character, which will be added
21439 automatically.
21440 If an l length modifier is present, the corresponding argument shall be a
21441 pointer to the initial element of an array of wchar_t large enough to accept
21442 the sequence and the terminating null wide character, which will be added
21443 automatically.
21444 The conversion specifier includes all subsequent wide characters in the
21445 format string, up to and including the matching right bracket (]). The wide
21446 characters between the brackets (the scanlist) compose the scanset, unless the
21447 wide character after the left bracket is a circumflex (^), in which case the
21448 scanset contains all wide characters that do not appear in the scanlist between
21449 the circumflex and the right bracket. If the conversion specifier begins with
21450 [] or [^], the right bracket wide character is in the scanlist and the next
21451 following right bracket wide character is the matching right bracket that ends
21452 the specification; otherwise the first following right bracket wide character is
21453 the one that ends the specification. If a - wide character is in the scanlist and
21454 is not the first, nor the second where the first wide character is a ^, nor the
21455 <!--page 433 -->
21456 last character, the behavior is implementation-defined.
21457 <dt> p <dd>Matches an implementation-defined set of sequences, which should be the
21458 same as the set of sequences that may be produced by the %p conversion of
21459 the fwprintf function. The corresponding argument shall be a pointer to a
21460 pointer to void. The input item is converted to a pointer value in an
21461 implementation-defined manner. If the input item is a value converted earlier
21462 during the same program execution, the pointer that results shall compare
21463 equal to that value; otherwise the behavior of the %p conversion is undefined.
21464 <dt> n <dd>No input is consumed. The corresponding argument shall be a pointer to
21465 signed integer into which is to be written the number of wide characters read
21466 from the input stream so far by this call to the fwscanf function. Execution
21467 of a %n directive does not increment the assignment count returned at the
21468 completion of execution of the fwscanf function. No argument is
21469 converted, but one is consumed. If the conversion specification includes an
21470 assignment-suppressing wide character or a field width, the behavior is
21471 undefined.
21472 <dt> % <dd>Matches a single % wide character; no conversion or assignment occurs. The
21473 complete conversion specification shall be %%.
21474 </dl>
21476 If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note339"><b>339)</b></a></sup>
21478 The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
21479 respectively, a, e, f, g, and x.
21481 Trailing white space (including new-line wide characters) is left unread unless matched
21482 by a directive. The success of literal matches and suppressed assignments is not directly
21483 determinable other than via the %n directive.
21484 <p><b>Returns</b>
21486 The fwscanf function returns the value of the macro EOF if an input failure occurs
21487 before the first conversion (if any) has completed. Otherwise, the function returns the
21488 number of input items assigned, which can be fewer than provided for, or even zero, in
21489 the event of an early matching failure.
21491 EXAMPLE 1 The call:
21492 <pre>
21495 /* ... */
21496 int n, i; float x; wchar_t name[50];
21498 </pre>
21502 <!--page 434 -->
21503 with the input line:
21504 <pre>
21505 25 54.32E-1 thompson
21506 </pre>
21507 will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
21508 thompson\0.
21511 EXAMPLE 2 The call:
21512 <pre>
21515 /* ... */
21516 int i; float x; double y;
21518 </pre>
21519 with input:
21520 <pre>
21521 56789 0123 56a72
21522 </pre>
21523 will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
21524 56.0. The next wide character read from the input stream will be a.
21526 <p><b> Forward references</b>: the wcstod, wcstof, and wcstold functions (<a href="#7.29.4.1.1">7.29.4.1.1</a>), the
21527 wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.29.4.1.2">7.29.4.1.2</a>), the wcrtomb
21530 <p><b>Footnotes</b>
21531 <p><small><a name="note337" href="#note337">337)</a> These white-space wide characters are not counted against a specified field width.
21532 </small>
21533 <p><small><a name="note338" href="#note338">338)</a> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
21534 sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
21535 </small>
21536 <p><small><a name="note339" href="#note339">339)</a> See ''future library directions'' (<a href="#7.31.16">7.31.16</a>).
21537 </small>
21541 <p><b>Synopsis</b>
21543 <pre>
21545 int swprintf(wchar_t * restrict s,
21546 size_t n,
21547 const wchar_t * restrict format, ...);
21548 </pre>
21549 <p><b>Description</b>
21551 The swprintf function is equivalent to fwprintf, except that the argument s
21552 specifies an array of wide characters into which the generated output is to be written,
21553 rather than written to a stream. No more than n wide characters are written, including a
21554 terminating null wide character, which is always added (unless n is zero).
21555 <p><b>Returns</b>
21557 The swprintf function returns the number of wide characters written in the array, not
21558 counting the terminating null wide character, or a negative value if an encoding error
21559 occurred or if n or more wide characters were requested to be written.
21560 <!--page 435 -->
21564 <p><b>Synopsis</b>
21566 <pre>
21568 int swscanf(const wchar_t * restrict s,
21569 const wchar_t * restrict format, ...);
21570 </pre>
21571 <p><b>Description</b>
21573 The swscanf function is equivalent to fwscanf, except that the argument s specifies a
21574 wide string from which the input is to be obtained, rather than from a stream. Reaching
21575 the end of the wide string is equivalent to encountering end-of-file for the fwscanf
21576 function.
21577 <p><b>Returns</b>
21579 The swscanf function returns the value of the macro EOF if an input failure occurs
21580 before the first conversion (if any) has completed. Otherwise, the swscanf function
21581 returns the number of input items assigned, which can be fewer than provided for, or even
21582 zero, in the event of an early matching failure.
21586 <p><b>Synopsis</b>
21588 <pre>
21592 int vfwprintf(FILE * restrict stream,
21593 const wchar_t * restrict format,
21594 va_list arg);
21595 </pre>
21596 <p><b>Description</b>
21598 The vfwprintf function is equivalent to fwprintf, with the variable argument list
21599 replaced by arg, which shall have been initialized by the va_start macro (and
21600 possibly subsequent va_arg calls). The vfwprintf function does not invoke the
21602 <p><b>Returns</b>
21604 The vfwprintf function returns the number of wide characters transmitted, or a
21605 negative value if an output or encoding error occurred.
21610 <!--page 436 -->
21612 EXAMPLE The following shows the use of the vfwprintf function in a general error-reporting
21613 routine.
21614 <pre>
21618 void error(char *function_name, wchar_t *format, ...)
21619 {
21620 va_list args;
21621 va_start(args, format);
21622 // print out name of function causing error
21624 // print out remainder of message
21625 vfwprintf(stderr, format, args);
21626 va_end(args);
21627 }
21628 </pre>
21631 <p><b>Footnotes</b>
21632 <p><small><a name="note340" href="#note340">340)</a> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
21633 invoke the va_arg macro, the value of arg after the return is indeterminate.
21634 </small>
21638 <p><b>Synopsis</b>
21640 <pre>
21644 int vfwscanf(FILE * restrict stream,
21645 const wchar_t * restrict format,
21646 va_list arg);
21647 </pre>
21648 <p><b>Description</b>
21650 The vfwscanf function is equivalent to fwscanf, with the variable argument list
21651 replaced by arg, which shall have been initialized by the va_start macro (and
21652 possibly subsequent va_arg calls). The vfwscanf function does not invoke the
21654 <p><b>Returns</b>
21656 The vfwscanf function returns the value of the macro EOF if an input failure occurs
21657 before the first conversion (if any) has completed. Otherwise, the vfwscanf function
21658 returns the number of input items assigned, which can be fewer than provided for, or even
21659 zero, in the event of an early matching failure.
21660 <!--page 437 -->
21664 <p><b>Synopsis</b>
21666 <pre>
21669 int vswprintf(wchar_t * restrict s,
21670 size_t n,
21671 const wchar_t * restrict format,
21672 va_list arg);
21673 </pre>
21674 <p><b>Description</b>
21676 The vswprintf function is equivalent to swprintf, with the variable argument list
21677 replaced by arg, which shall have been initialized by the va_start macro (and
21678 possibly subsequent va_arg calls). The vswprintf function does not invoke the
21680 <p><b>Returns</b>
21682 The vswprintf function returns the number of wide characters written in the array, not
21683 counting the terminating null wide character, or a negative value if an encoding error
21684 occurred or if n or more wide characters were requested to be generated.
21688 <p><b>Synopsis</b>
21690 <pre>
21693 int vswscanf(const wchar_t * restrict s,
21694 const wchar_t * restrict format,
21695 va_list arg);
21696 </pre>
21697 <p><b>Description</b>
21699 The vswscanf function is equivalent to swscanf, with the variable argument list
21700 replaced by arg, which shall have been initialized by the va_start macro (and
21701 possibly subsequent va_arg calls). The vswscanf function does not invoke the
21703 <p><b>Returns</b>
21705 The vswscanf function returns the value of the macro EOF if an input failure occurs
21706 before the first conversion (if any) has completed. Otherwise, the vswscanf function
21707 returns the number of input items assigned, which can be fewer than provided for, or even
21708 zero, in the event of an early matching failure.
21709 <!--page 438 -->
21713 <p><b>Synopsis</b>
21715 <pre>
21718 int vwprintf(const wchar_t * restrict format,
21719 va_list arg);
21720 </pre>
21721 <p><b>Description</b>
21723 The vwprintf function is equivalent to wprintf, with the variable argument list
21724 replaced by arg, which shall have been initialized by the va_start macro (and
21725 possibly subsequent va_arg calls). The vwprintf function does not invoke the
21727 <p><b>Returns</b>
21729 The vwprintf function returns the number of wide characters transmitted, or a negative
21730 value if an output or encoding error occurred.
21734 <p><b>Synopsis</b>
21736 <pre>
21739 int vwscanf(const wchar_t * restrict format,
21740 va_list arg);
21741 </pre>
21742 <p><b>Description</b>
21744 The vwscanf function is equivalent to wscanf, with the variable argument list
21745 replaced by arg, which shall have been initialized by the va_start macro (and
21746 possibly subsequent va_arg calls). The vwscanf function does not invoke the
21748 <p><b>Returns</b>
21750 The vwscanf function returns the value of the macro EOF if an input failure occurs
21751 before the first conversion (if any) has completed. Otherwise, the vwscanf function
21752 returns the number of input items assigned, which can be fewer than provided for, or even
21753 zero, in the event of an early matching failure.
21754 <!--page 439 -->
21758 <p><b>Synopsis</b>
21760 <pre>
21762 int wprintf(const wchar_t * restrict format, ...);
21763 </pre>
21764 <p><b>Description</b>
21766 The wprintf function is equivalent to fwprintf with the argument stdout
21767 interposed before the arguments to wprintf.
21768 <p><b>Returns</b>
21770 The wprintf function returns the number of wide characters transmitted, or a negative
21771 value if an output or encoding error occurred.
21775 <p><b>Synopsis</b>
21777 <pre>
21779 int wscanf(const wchar_t * restrict format, ...);
21780 </pre>
21781 <p><b>Description</b>
21783 The wscanf function is equivalent to fwscanf with the argument stdin interposed
21784 before the arguments to wscanf.
21785 <p><b>Returns</b>
21787 The wscanf function returns the value of the macro EOF if an input failure occurs
21788 before the first conversion (if any) has completed. Otherwise, the wscanf function
21789 returns the number of input items assigned, which can be fewer than provided for, or even
21790 zero, in the event of an early matching failure.
21797 <p><b>Synopsis</b>
21799 <pre>
21802 wint_t fgetwc(FILE *stream);
21803 </pre>
21804 <p><b>Description</b>
21806 If the end-of-file indicator for the input stream pointed to by stream is not set and a
21807 next wide character is present, the fgetwc function obtains that wide character as a
21808 wchar_t converted to a wint_t and advances the associated file position indicator for
21809 the stream (if defined).
21810 <!--page 440 -->
21811 <p><b>Returns</b>
21813 If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
21814 of-file indicator for the stream is set and the fgetwc function returns WEOF. Otherwise,
21815 the fgetwc function returns the next wide character from the input stream pointed to by
21816 stream. If a read error occurs, the error indicator for the stream is set and the fgetwc
21817 function returns WEOF. If an encoding error occurs (including too few bytes), the value of
21818 the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note341"><b>341)</b></a></sup>
21820 <p><b>Footnotes</b>
21821 <p><small><a name="note341" href="#note341">341)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
21822 Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
21823 </small>
21827 <p><b>Synopsis</b>
21829 <pre>
21832 wchar_t *fgetws(wchar_t * restrict s,
21833 int n, FILE * restrict stream);
21834 </pre>
21835 <p><b>Description</b>
21837 The fgetws function reads at most one less than the number of wide characters
21838 specified by n from the stream pointed to by stream into the array pointed to by s. No
21839 additional wide characters are read after a new-line wide character (which is retained) or
21840 after end-of-file. A null wide character is written immediately after the last wide
21841 character read into the array.
21842 <p><b>Returns</b>
21844 The fgetws function returns s if successful. If end-of-file is encountered and no
21845 characters have been read into the array, the contents of the array remain unchanged and a
21846 null pointer is returned. If a read or encoding error occurs during the operation, the array
21847 contents are indeterminate and a null pointer is returned.
21851 <p><b>Synopsis</b>
21853 <pre>
21856 wint_t fputwc(wchar_t c, FILE *stream);
21857 </pre>
21858 <p><b>Description</b>
21860 The fputwc function writes the wide character specified by c to the output stream
21861 pointed to by stream, at the position indicated by the associated file position indicator
21862 for the stream (if defined), and advances the indicator appropriately. If the file cannot
21864 <!--page 441 -->
21865 support positioning requests, or if the stream was opened with append mode, the
21866 character is appended to the output stream.
21867 <p><b>Returns</b>
21869 The fputwc function returns the wide character written. If a write error occurs, the
21870 error indicator for the stream is set and fputwc returns WEOF. If an encoding error
21871 occurs, the value of the macro EILSEQ is stored in errno and fputwc returns WEOF.
21875 <p><b>Synopsis</b>
21877 <pre>
21880 int fputws(const wchar_t * restrict s,
21881 FILE * restrict stream);
21882 </pre>
21883 <p><b>Description</b>
21885 The fputws function writes the wide string pointed to by s to the stream pointed to by
21886 stream. The terminating null wide character is not written.
21887 <p><b>Returns</b>
21889 The fputws function returns EOF if a write or encoding error occurs; otherwise, it
21890 returns a nonnegative value.
21894 <p><b>Synopsis</b>
21896 <pre>
21899 int fwide(FILE *stream, int mode);
21900 </pre>
21901 <p><b>Description</b>
21903 The fwide function determines the orientation of the stream pointed to by stream. If
21904 mode is greater than zero, the function first attempts to make the stream wide oriented. If
21905 mode is less than zero, the function first attempts to make the stream byte oriented.<sup><a href="#note342"><b>342)</b></a></sup>
21906 Otherwise, mode is zero and the function does not alter the orientation of the stream.
21907 <p><b>Returns</b>
21909 The fwide function returns a value greater than zero if, after the call, the stream has
21910 wide orientation, a value less than zero if the stream has byte orientation, or zero if the
21911 stream has no orientation.
21914 <!--page 442 -->
21916 <p><b>Footnotes</b>
21917 <p><small><a name="note342" href="#note342">342)</a> If the orientation of the stream has already been determined, fwide does not change it.
21918 </small>
21922 <p><b>Synopsis</b>
21924 <pre>
21927 wint_t getwc(FILE *stream);
21928 </pre>
21929 <p><b>Description</b>
21931 The getwc function is equivalent to fgetwc, except that if it is implemented as a
21932 macro, it may evaluate stream more than once, so the argument should never be an
21933 expression with side effects.
21934 <p><b>Returns</b>
21936 The getwc function returns the next wide character from the input stream pointed to by
21937 stream, or WEOF.
21941 <p><b>Synopsis</b>
21943 <pre>
21945 wint_t getwchar(void);
21946 </pre>
21947 <p><b>Description</b>
21949 The getwchar function is equivalent to getwc with the argument stdin.
21950 <p><b>Returns</b>
21952 The getwchar function returns the next wide character from the input stream pointed to
21953 by stdin, or WEOF.
21957 <p><b>Synopsis</b>
21959 <pre>
21962 wint_t putwc(wchar_t c, FILE *stream);
21963 </pre>
21964 <p><b>Description</b>
21966 The putwc function is equivalent to fputwc, except that if it is implemented as a
21967 macro, it may evaluate stream more than once, so that argument should never be an
21968 expression with side effects.
21969 <p><b>Returns</b>
21971 The putwc function returns the wide character written, or WEOF.
21972 <!--page 443 -->
21976 <p><b>Synopsis</b>
21978 <pre>
21980 wint_t putwchar(wchar_t c);
21981 </pre>
21982 <p><b>Description</b>
21984 The putwchar function is equivalent to putwc with the second argument stdout.
21985 <p><b>Returns</b>
21987 The putwchar function returns the character written, or WEOF.
21991 <p><b>Synopsis</b>
21993 <pre>
21996 wint_t ungetwc(wint_t c, FILE *stream);
21997 </pre>
21998 <p><b>Description</b>
22000 The ungetwc function pushes the wide character specified by c back onto the input
22001 stream pointed to by stream. Pushed-back wide characters will be returned by
22002 subsequent reads on that stream in the reverse order of their pushing. A successful
22003 intervening call (with the stream pointed to by stream) to a file positioning function
22004 (fseek, fsetpos, or rewind) discards any pushed-back wide characters for the
22005 stream. The external storage corresponding to the stream is unchanged.
22007 One wide character of pushback is guaranteed, even if the call to the ungetwc function
22008 follows just after a call to a formatted wide character input function fwscanf,
22009 vfwscanf, vwscanf, or wscanf. If the ungetwc function is called too many times
22010 on the same stream without an intervening read or file positioning operation on that
22011 stream, the operation may fail.
22013 If the value of c equals that of the macro WEOF, the operation fails and the input stream is
22014 unchanged.
22016 A successful call to the ungetwc function clears the end-of-file indicator for the stream.
22017 The value of the file position indicator for the stream after reading or discarding all
22018 pushed-back wide characters is the same as it was before the wide characters were pushed
22019 back. For a text or binary stream, the value of its file position indicator after a successful
22020 call to the ungetwc function is unspecified until all pushed-back wide characters are
22021 read or discarded.
22022 <!--page 444 -->
22023 <p><b>Returns</b>
22025 The ungetwc function returns the wide character pushed back, or WEOF if the operation
22026 fails.
22031 The header <a href="#7.29"><wchar.h></a> declares a number of functions useful for wide string
22032 manipulation. Various methods are used for determining the lengths of the arrays, but in
22033 all cases a wchar_t * argument points to the initial (lowest addressed) element of the
22034 array. If an array is accessed beyond the end of an object, the behavior is undefined.
22036 Where an argument declared as size_t n determines the length of the array for a
22037 function, n can have the value zero on a call to that function. Unless explicitly stated
22038 otherwise in the description of a particular function in this subclause, pointer arguments
22039 on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
22040 function that locates a wide character finds no occurrence, a function that compares two
22041 wide character sequences returns zero, and a function that copies wide characters copies
22042 zero wide characters.
22045 <h5><a name="7.29.4.1" href="#7.29.4.1">7.29.4.1 Wide string numeric conversion functions</a></h5>
22048 <h5><a name="7.29.4.1.1" href="#7.29.4.1.1">7.29.4.1.1 The wcstod, wcstof, and wcstold functions</a></h5>
22049 <p><b>Synopsis</b>
22051 <pre>
22053 double wcstod(const wchar_t * restrict nptr,
22054 wchar_t ** restrict endptr);
22055 float wcstof(const wchar_t * restrict nptr,
22056 wchar_t ** restrict endptr);
22057 long double wcstold(const wchar_t * restrict nptr,
22058 wchar_t ** restrict endptr);
22059 </pre>
22060 <p><b>Description</b>
22062 The wcstod, wcstof, and wcstold functions convert the initial portion of the wide
22063 string pointed to by nptr to double, float, and long double representation,
22064 respectively. First, they decompose the input string into three parts: an initial, possibly
22065 empty, sequence of white-space wide characters (as specified by the iswspace
22066 function), a subject sequence resembling a floating-point constant or representing an
22067 infinity or NaN; and a final wide string of one or more unrecognized wide characters,
22068 including the terminating null wide character of the input wide string. Then, they attempt
22069 to convert the subject sequence to a floating-point number, and return the result.
22071 The expected form of the subject sequence is an optional plus or minus sign, then one of
22072 the following:
22073 <!--page 445 -->
22074 <ul>
22075 <li> a nonempty sequence of decimal digits optionally containing a decimal-point wide
22076 character, then an optional exponent part as defined for the corresponding single-byte
22078 <li> a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
22079 decimal-point wide character, then an optional binary exponent part as defined in
22081 <li> INF or INFINITY, or any other wide string equivalent except for case
22082 <li> NAN or NAN(n-wchar-sequence<sub>opt</sub>), or any other wide string equivalent except for
22083 case in the NAN part, where:
22084 <pre>
22085 n-wchar-sequence:
22086 digit
22087 nondigit
22088 n-wchar-sequence digit
22089 n-wchar-sequence nondigit
22090 </pre>
22091 </ul>
22092 The subject sequence is defined as the longest initial subsequence of the input wide
22093 string, starting with the first non-white-space wide character, that is of the expected form.
22094 The subject sequence contains no wide characters if the input wide string is not of the
22095 expected form.
22097 If the subject sequence has the expected form for a floating-point number, the sequence of
22098 wide characters starting with the first digit or the decimal-point wide character
22099 (whichever occurs first) is interpreted as a floating constant according to the rules of
22100 <a href="#6.4.4.2">6.4.4.2</a>, except that the decimal-point wide character is used in place of a period, and that
22101 if neither an exponent part nor a decimal-point wide character appears in a decimal
22102 floating point number, or if a binary exponent part does not appear in a hexadecimal
22103 floating point number, an exponent part of the appropriate type with value zero is
22104 assumed to follow the last digit in the string. If the subject sequence begins with a minus
22105 sign, the sequence is interpreted as negated.<sup><a href="#note343"><b>343)</b></a></sup> A wide character sequence INF or
22106 INFINITY is interpreted as an infinity, if representable in the return type, else like a
22107 floating constant that is too large for the range of the return type. A wide character
22108 sequence NAN or NAN(n-wchar-sequence<sub>opt</sub>) is interpreted as a quiet NaN, if supported
22109 in the return type, else like a subject sequence part that does not have the expected form;
22110 the meaning of the n-wchar sequence is implementation-defined.<sup><a href="#note344"><b>344)</b></a></sup> A pointer to the
22112 <!--page 446 -->
22113 final wide string is stored in the object pointed to by endptr, provided that endptr is
22114 not a null pointer.
22116 If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
22117 value resulting from the conversion is correctly rounded.
22120 accepted.
22122 If the subject sequence is empty or does not have the expected form, no conversion is
22123 performed; the value of nptr is stored in the object pointed to by endptr, provided
22124 that endptr is not a null pointer.
22125 <p><b>Recommended practice</b>
22127 If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
22128 the result is not exactly representable, the result should be one of the two numbers in the
22129 appropriate internal format that are adjacent to the hexadecimal floating source value,
22130 with the extra stipulation that the error should have a correct sign for the current rounding
22131 direction.
22133 If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
22134 <a href="#7.7"><float.h></a>) significant digits, the result should be correctly rounded. If the subject
22135 sequence D has the decimal form and more than DECIMAL_DIG significant digits,
22136 consider the two bounding, adjacent decimal strings L and U, both having
22137 DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L <= D <= U.
22138 The result should be one of the (equal or adjacent) values that would be obtained by
22139 correctly rounding L and U according to the current rounding direction, with the extra
22140 stipulation that the error with respect to D should have a correct sign for the current
22142 <p><b>Returns</b>
22144 The functions return the converted value, if any. If no conversion could be performed,
22145 zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
22146 plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
22147 return type and sign of the value), and the value of the macro ERANGE is stored in
22148 errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
22149 no greater than the smallest normalized positive number in the return type; whether
22150 errno acquires the value ERANGE is implementation-defined.
22155 <!--page 447 -->
22157 <p><b>Footnotes</b>
22158 <p><small><a name="note343" href="#note343">343)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
22159 negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
22160 methods may yield different results if rounding is toward positive or negative infinity. In either case,
22161 the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
22162 </small>
22163 <p><small><a name="note344" href="#note344">344)</a> An implementation may use the n-wchar sequence to determine extra information to be represented in
22164 the NaN's significand.
22165 </small>
22166 <p><small><a name="note345" href="#note345">345)</a> DECIMAL_DIG, defined in <a href="#7.7"><float.h></a>, should be sufficiently large that L and U will usually round
22167 to the same internal floating value, but if not will round to adjacent values.
22168 </small>
22171 <h5><a name="7.29.4.1.2" href="#7.29.4.1.2">7.29.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</a></h5>
22172 <p><b>Synopsis</b>
22174 <pre>
22176 long int wcstol(
22177 const wchar_t * restrict nptr,
22178 wchar_t ** restrict endptr,
22179 int base);
22180 long long int wcstoll(
22181 const wchar_t * restrict nptr,
22182 wchar_t ** restrict endptr,
22183 int base);
22184 unsigned long int wcstoul(
22185 const wchar_t * restrict nptr,
22186 wchar_t ** restrict endptr,
22187 int base);
22188 unsigned long long int wcstoull(
22189 const wchar_t * restrict nptr,
22190 wchar_t ** restrict endptr,
22191 int base);
22192 </pre>
22193 <p><b>Description</b>
22195 The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
22196 portion of the wide string pointed to by nptr to long int, long long int,
22197 unsigned long int, and unsigned long long int representation,
22198 respectively. First, they decompose the input string into three parts: an initial, possibly
22199 empty, sequence of white-space wide characters (as specified by the iswspace
22200 function), a subject sequence resembling an integer represented in some radix determined
22201 by the value of base, and a final wide string of one or more unrecognized wide
22202 characters, including the terminating null wide character of the input wide string. Then,
22203 they attempt to convert the subject sequence to an integer, and return the result.
22205 If the value of base is zero, the expected form of the subject sequence is that of an
22206 integer constant as described for the corresponding single-byte characters in <a href="#6.4.4.1">6.4.4.1</a>,
22207 optionally preceded by a plus or minus sign, but not including an integer suffix. If the
22208 value of base is between 2 and 36 (inclusive), the expected form of the subject sequence
22209 is a sequence of letters and digits representing an integer with the radix specified by
22210 base, optionally preceded by a plus or minus sign, but not including an integer suffix.
22211 The letters from a (or A) through z (or Z) are ascribed the values 10 through 35; only
22212 letters and digits whose ascribed values are less than that of base are permitted. If the
22213 value of base is 16, the wide characters 0x or 0X may optionally precede the sequence
22214 of letters and digits, following the sign if present.
22215 <!--page 448 -->
22217 The subject sequence is defined as the longest initial subsequence of the input wide
22218 string, starting with the first non-white-space wide character, that is of the expected form.
22219 The subject sequence contains no wide characters if the input wide string is empty or
22220 consists entirely of white space, or if the first non-white-space wide character is other
22221 than a sign or a permissible letter or digit.
22223 If the subject sequence has the expected form and the value of base is zero, the sequence
22224 of wide characters starting with the first digit is interpreted as an integer constant
22225 according to the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the
22226 value of base is between 2 and 36, it is used as the base for conversion, ascribing to each
22227 letter its value as given above. If the subject sequence begins with a minus sign, the value
22228 resulting from the conversion is negated (in the return type). A pointer to the final wide
22229 string is stored in the object pointed to by endptr, provided that endptr is not a null
22230 pointer.
22233 accepted.
22235 If the subject sequence is empty or does not have the expected form, no conversion is
22236 performed; the value of nptr is stored in the object pointed to by endptr, provided
22237 that endptr is not a null pointer.
22238 <p><b>Returns</b>
22240 The wcstol, wcstoll, wcstoul, and wcstoull functions return the converted
22241 value, if any. If no conversion could be performed, zero is returned. If the correct value
22242 is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
22243 LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
22244 sign of the value, if any), and the value of the macro ERANGE is stored in errno.
22251 <p><b>Synopsis</b>
22253 <pre>
22255 wchar_t *wcscpy(wchar_t * restrict s1,
22256 const wchar_t * restrict s2);
22257 </pre>
22258 <p><b>Description</b>
22260 The wcscpy function copies the wide string pointed to by s2 (including the terminating
22261 null wide character) into the array pointed to by s1.
22262 <p><b>Returns</b>
22264 The wcscpy function returns the value of s1.
22265 <!--page 449 -->
22269 <p><b>Synopsis</b>
22271 <pre>
22273 wchar_t *wcsncpy(wchar_t * restrict s1,
22274 const wchar_t * restrict s2,
22275 size_t n);
22276 </pre>
22277 <p><b>Description</b>
22279 The wcsncpy function copies not more than n wide characters (those that follow a null
22280 wide character are not copied) from the array pointed to by s2 to the array pointed to by
22283 If the array pointed to by s2 is a wide string that is shorter than n wide characters, null
22284 wide characters are appended to the copy in the array pointed to by s1, until n wide
22285 characters in all have been written.
22286 <p><b>Returns</b>
22288 The wcsncpy function returns the value of s1.
22290 <p><b>Footnotes</b>
22291 <p><small><a name="note346" href="#note346">346)</a> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
22292 result will not be null-terminated.
22293 </small>
22297 <p><b>Synopsis</b>
22299 <pre>
22301 wchar_t *wmemcpy(wchar_t * restrict s1,
22302 const wchar_t * restrict s2,
22303 size_t n);
22304 </pre>
22305 <p><b>Description</b>
22307 The wmemcpy function copies n wide characters from the object pointed to by s2 to the
22308 object pointed to by s1.
22309 <p><b>Returns</b>
22311 The wmemcpy function returns the value of s1.
22316 <!--page 450 -->
22320 <p><b>Synopsis</b>
22322 <pre>
22324 wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
22325 size_t n);
22326 </pre>
22327 <p><b>Description</b>
22329 The wmemmove function copies n wide characters from the object pointed to by s2 to
22330 the object pointed to by s1. Copying takes place as if the n wide characters from the
22331 object pointed to by s2 are first copied into a temporary array of n wide characters that
22332 does not overlap the objects pointed to by s1 or s2, and then the n wide characters from
22333 the temporary array are copied into the object pointed to by s1.
22334 <p><b>Returns</b>
22336 The wmemmove function returns the value of s1.
22343 <p><b>Synopsis</b>
22345 <pre>
22347 wchar_t *wcscat(wchar_t * restrict s1,
22348 const wchar_t * restrict s2);
22349 </pre>
22350 <p><b>Description</b>
22352 The wcscat function appends a copy of the wide string pointed to by s2 (including the
22353 terminating null wide character) to the end of the wide string pointed to by s1. The initial
22354 wide character of s2 overwrites the null wide character at the end of s1.
22355 <p><b>Returns</b>
22357 The wcscat function returns the value of s1.
22361 <p><b>Synopsis</b>
22363 <pre>
22365 wchar_t *wcsncat(wchar_t * restrict s1,
22366 const wchar_t * restrict s2,
22367 size_t n);
22368 </pre>
22369 <p><b>Description</b>
22371 The wcsncat function appends not more than n wide characters (a null wide character
22372 and those that follow it are not appended) from the array pointed to by s2 to the end of
22373 <!--page 451 -->
22374 the wide string pointed to by s1. The initial wide character of s2 overwrites the null
22375 wide character at the end of s1. A terminating null wide character is always appended to
22377 <p><b>Returns</b>
22379 The wcsncat function returns the value of s1.
22381 <p><b>Footnotes</b>
22382 <p><small><a name="note347" href="#note347">347)</a> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
22383 wcslen(s1)+n+1.
22384 </small>
22389 Unless explicitly stated otherwise, the functions described in this subclause order two
22390 wide characters the same way as two integers of the underlying integer type designated
22391 by wchar_t.
22395 <p><b>Synopsis</b>
22397 <pre>
22399 int wcscmp(const wchar_t *s1, const wchar_t *s2);
22400 </pre>
22401 <p><b>Description</b>
22403 The wcscmp function compares the wide string pointed to by s1 to the wide string
22404 pointed to by s2.
22405 <p><b>Returns</b>
22407 The wcscmp function returns an integer greater than, equal to, or less than zero,
22408 accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
22409 wide string pointed to by s2.
22413 <p><b>Synopsis</b>
22415 <pre>
22417 int wcscoll(const wchar_t *s1, const wchar_t *s2);
22418 </pre>
22419 <p><b>Description</b>
22421 The wcscoll function compares the wide string pointed to by s1 to the wide string
22422 pointed to by s2, both interpreted as appropriate to the LC_COLLATE category of the
22423 current locale.
22424 <p><b>Returns</b>
22426 The wcscoll function returns an integer greater than, equal to, or less than zero,
22427 accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
22430 <!--page 452 -->
22431 wide string pointed to by s2 when both are interpreted as appropriate to the current
22432 locale.
22436 <p><b>Synopsis</b>
22438 <pre>
22440 int wcsncmp(const wchar_t *s1, const wchar_t *s2,
22441 size_t n);
22442 </pre>
22443 <p><b>Description</b>
22445 The wcsncmp function compares not more than n wide characters (those that follow a
22446 null wide character are not compared) from the array pointed to by s1 to the array
22447 pointed to by s2.
22448 <p><b>Returns</b>
22450 The wcsncmp function returns an integer greater than, equal to, or less than zero,
22451 accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
22452 to, or less than the possibly null-terminated array pointed to by s2.
22456 <p><b>Synopsis</b>
22458 <pre>
22460 size_t wcsxfrm(wchar_t * restrict s1,
22461 const wchar_t * restrict s2,
22462 size_t n);
22463 </pre>
22464 <p><b>Description</b>
22466 The wcsxfrm function transforms the wide string pointed to by s2 and places the
22467 resulting wide string into the array pointed to by s1. The transformation is such that if
22468 the wcscmp function is applied to two transformed wide strings, it returns a value greater
22469 than, equal to, or less than zero, corresponding to the result of the wcscoll function
22470 applied to the same two original wide strings. No more than n wide characters are placed
22471 into the resulting array pointed to by s1, including the terminating null wide character. If
22472 n is zero, s1 is permitted to be a null pointer.
22473 <p><b>Returns</b>
22475 The wcsxfrm function returns the length of the transformed wide string (not including
22476 the terminating null wide character). If the value returned is n or greater, the contents of
22477 the array pointed to by s1 are indeterminate.
22479 EXAMPLE The value of the following expression is the length of the array needed to hold the
22480 transformation of the wide string pointed to by s:
22481 <!--page 453 -->
22482 <pre>
22483 1 + wcsxfrm(NULL, s, 0)
22484 </pre>
22489 <p><b>Synopsis</b>
22491 <pre>
22493 int wmemcmp(const wchar_t *s1, const wchar_t *s2,
22494 size_t n);
22495 </pre>
22496 <p><b>Description</b>
22498 The wmemcmp function compares the first n wide characters of the object pointed to by
22499 s1 to the first n wide characters of the object pointed to by s2.
22500 <p><b>Returns</b>
22502 The wmemcmp function returns an integer greater than, equal to, or less than zero,
22503 accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
22504 pointed to by s2.
22511 <p><b>Synopsis</b>
22513 <pre>
22515 wchar_t *wcschr(const wchar_t *s, wchar_t c);
22516 </pre>
22517 <p><b>Description</b>
22519 The wcschr function locates the first occurrence of c in the wide string pointed to by s.
22520 The terminating null wide character is considered to be part of the wide string.
22521 <p><b>Returns</b>
22523 The wcschr function returns a pointer to the located wide character, or a null pointer if
22524 the wide character does not occur in the wide string.
22528 <p><b>Synopsis</b>
22530 <pre>
22532 size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
22533 </pre>
22534 <p><b>Description</b>
22536 The wcscspn function computes the length of the maximum initial segment of the wide
22537 string pointed to by s1 which consists entirely of wide characters not from the wide
22538 string pointed to by s2.
22539 <!--page 454 -->
22540 <p><b>Returns</b>
22542 The wcscspn function returns the length of the segment.
22546 <p><b>Synopsis</b>
22548 <pre>
22550 wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
22551 </pre>
22552 <p><b>Description</b>
22554 The wcspbrk function locates the first occurrence in the wide string pointed to by s1 of
22555 any wide character from the wide string pointed to by s2.
22556 <p><b>Returns</b>
22558 The wcspbrk function returns a pointer to the wide character in s1, or a null pointer if
22559 no wide character from s2 occurs in s1.
22563 <p><b>Synopsis</b>
22565 <pre>
22567 wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
22568 </pre>
22569 <p><b>Description</b>
22571 The wcsrchr function locates the last occurrence of c in the wide string pointed to by
22572 s. The terminating null wide character is considered to be part of the wide string.
22573 <p><b>Returns</b>
22575 The wcsrchr function returns a pointer to the wide character, or a null pointer if c does
22576 not occur in the wide string.
22580 <p><b>Synopsis</b>
22582 <pre>
22584 size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
22585 </pre>
22586 <p><b>Description</b>
22588 The wcsspn function computes the length of the maximum initial segment of the wide
22589 string pointed to by s1 which consists entirely of wide characters from the wide string
22590 pointed to by s2.
22591 <p><b>Returns</b>
22593 The wcsspn function returns the length of the segment.
22594 <!--page 455 -->
22598 <p><b>Synopsis</b>
22600 <pre>
22602 wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
22603 </pre>
22604 <p><b>Description</b>
22606 The wcsstr function locates the first occurrence in the wide string pointed to by s1 of
22607 the sequence of wide characters (excluding the terminating null wide character) in the
22608 wide string pointed to by s2.
22609 <p><b>Returns</b>
22611 The wcsstr function returns a pointer to the located wide string, or a null pointer if the
22612 wide string is not found. If s2 points to a wide string with zero length, the function
22613 returns s1.
22617 <p><b>Synopsis</b>
22619 <pre>
22621 wchar_t *wcstok(wchar_t * restrict s1,
22622 const wchar_t * restrict s2,
22623 wchar_t ** restrict ptr);
22624 </pre>
22625 <p><b>Description</b>
22627 A sequence of calls to the wcstok function breaks the wide string pointed to by s1 into
22628 a sequence of tokens, each of which is delimited by a wide character from the wide string
22629 pointed to by s2. The third argument points to a caller-provided wchar_t pointer into
22630 which the wcstok function stores information necessary for it to continue scanning the
22631 same wide string.
22633 The first call in a sequence has a non-null first argument and stores an initial value in the
22634 object pointed to by ptr. Subsequent calls in the sequence have a null first argument and
22635 the object pointed to by ptr is required to have the value stored by the previous call in
22636 the sequence, which is then updated. The separator wide string pointed to by s2 may be
22637 different from call to call.
22639 The first call in the sequence searches the wide string pointed to by s1 for the first wide
22640 character that is not contained in the current separator wide string pointed to by s2. If no
22641 such wide character is found, then there are no tokens in the wide string pointed to by s1
22642 and the wcstok function returns a null pointer. If such a wide character is found, it is
22643 the start of the first token.
22645 The wcstok function then searches from there for a wide character that is contained in
22646 the current separator wide string. If no such wide character is found, the current token
22647 <!--page 456 -->
22648 extends to the end of the wide string pointed to by s1, and subsequent searches in the
22649 same wide string for a token return a null pointer. If such a wide character is found, it is
22650 overwritten by a null wide character, which terminates the current token.
22652 In all cases, the wcstok function stores sufficient information in the pointer pointed to
22653 by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
22654 value for ptr, shall start searching just past the element overwritten by a null wide
22655 character (if any).
22656 <p><b>Returns</b>
22658 The wcstok function returns a pointer to the first wide character of a token, or a null
22659 pointer if there is no token.
22661 EXAMPLE
22662 <pre>
22666 wchar_t *t, *ptr1, *ptr2;
22672 </pre>
22677 <p><b>Synopsis</b>
22679 <pre>
22681 wchar_t *wmemchr(const wchar_t *s, wchar_t c,
22682 size_t n);
22683 </pre>
22684 <p><b>Description</b>
22686 The wmemchr function locates the first occurrence of c in the initial n wide characters of
22687 the object pointed to by s.
22688 <p><b>Returns</b>
22690 The wmemchr function returns a pointer to the located wide character, or a null pointer if
22691 the wide character does not occur in the object.
22692 <!--page 457 -->
22699 <p><b>Synopsis</b>
22701 <pre>
22703 size_t wcslen(const wchar_t *s);
22704 </pre>
22705 <p><b>Description</b>
22707 The wcslen function computes the length of the wide string pointed to by s.
22708 <p><b>Returns</b>
22710 The wcslen function returns the number of wide characters that precede the terminating
22711 null wide character.
22715 <p><b>Synopsis</b>
22717 <pre>
22719 wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
22720 </pre>
22721 <p><b>Description</b>
22723 The wmemset function copies the value of c into each of the first n wide characters of
22724 the object pointed to by s.
22725 <p><b>Returns</b>
22727 The wmemset function returns the value of s.
22734 <p><b>Synopsis</b>
22736 <pre>
22739 size_t wcsftime(wchar_t * restrict s,
22740 size_t maxsize,
22741 const wchar_t * restrict format,
22742 const struct tm * restrict timeptr);
22743 </pre>
22744 <p><b>Description</b>
22746 The wcsftime function is equivalent to the strftime function, except that:
22747 <ul>
22748 <li> The argument s points to the initial element of an array of wide characters into which
22749 the generated output is to be placed.
22750 <!--page 458 -->
22751 <li> The argument maxsize indicates the limiting number of wide characters.
22752 <li> The argument format is a wide string and the conversion specifiers are replaced by
22753 corresponding sequences of wide characters.
22754 <li> The return value indicates the number of wide characters.
22755 </ul>
22756 <p><b>Returns</b>
22758 If the total number of resulting wide characters including the terminating null wide
22759 character is not more than maxsize, the wcsftime function returns the number of
22760 wide characters placed into the array pointed to by s not including the terminating null
22761 wide character. Otherwise, zero is returned and the contents of the array are
22762 indeterminate.
22765 <h4><a name="7.29.6" href="#7.29.6">7.29.6 Extended multibyte/wide character conversion utilities</a></h4>
22767 The header <a href="#7.29"><wchar.h></a> declares an extended set of functions useful for conversion
22768 between multibyte characters and wide characters.
22770 Most of the following functions -- those that are listed as ''restartable'', <a href="#7.29.6.3">7.29.6.3</a> and
22771 <a href="#7.29.6.4">7.29.6.4</a> -- take as a last argument a pointer to an object of type mbstate_t that is used
22772 to describe the current conversion state from a particular multibyte character sequence to
22773 a wide character sequence (or the reverse) under the rules of a particular setting for the
22774 LC_CTYPE category of the current locale.
22776 The initial conversion state corresponds, for a conversion in either direction, to the
22777 beginning of a new multibyte character in the initial shift state. A zero-valued
22778 mbstate_t object is (at least) one way to describe an initial conversion state. A zero-
22779 valued mbstate_t object can be used to initiate conversion involving any multibyte
22780 character sequence, in any LC_CTYPE category setting. If an mbstate_t object has
22781 been altered by any of the functions described in this subclause, and is then used with a
22782 different multibyte character sequence, or in the other conversion direction, or with a
22783 different LC_CTYPE category setting than on earlier function calls, the behavior is
22786 On entry, each function takes the described conversion state (either internal or pointed to
22787 by an argument) as current. The conversion state described by the referenced object is
22788 altered as needed to track the shift state, and the position within a multibyte character, for
22789 the associated multibyte character sequence.
22794 <!--page 459 -->
22796 <p><b>Footnotes</b>
22797 <p><small><a name="note348" href="#note348">348)</a> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
22798 mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
22799 character string.
22800 </small>
22803 <h5><a name="7.29.6.1" href="#7.29.6.1">7.29.6.1 Single-byte/wide character conversion functions</a></h5>
22807 <p><b>Synopsis</b>
22809 <pre>
22811 wint_t btowc(int c);
22812 </pre>
22813 <p><b>Description</b>
22815 The btowc function determines whether c constitutes a valid single-byte character in the
22816 initial shift state.
22817 <p><b>Returns</b>
22819 The btowc function returns WEOF if c has the value EOF or if (unsigned char)c
22820 does not constitute a valid single-byte character in the initial shift state. Otherwise, it
22821 returns the wide character representation of that character.
22825 <p><b>Synopsis</b>
22827 <pre>
22829 int wctob(wint_t c);
22830 </pre>
22831 <p><b>Description</b>
22833 The wctob function determines whether c corresponds to a member of the extended
22834 character set whose multibyte character representation is a single byte when in the initial
22835 shift state.
22836 <p><b>Returns</b>
22838 The wctob function returns EOF if c does not correspond to a multibyte character with
22839 length one in the initial shift state. Otherwise, it returns the single-byte representation of
22840 that character as an unsigned char converted to an int.
22847 <p><b>Synopsis</b>
22849 <pre>
22851 int mbsinit(const mbstate_t *ps);
22852 </pre>
22853 <p><b>Description</b>
22855 If ps is not a null pointer, the mbsinit function determines whether the referenced
22856 mbstate_t object describes an initial conversion state.
22857 <!--page 460 -->
22858 <p><b>Returns</b>
22860 The mbsinit function returns nonzero if ps is a null pointer or if the referenced object
22861 describes an initial conversion state; otherwise, it returns zero.
22864 <h5><a name="7.29.6.3" href="#7.29.6.3">7.29.6.3 Restartable multibyte/wide character conversion functions</a></h5>
22866 These functions differ from the corresponding multibyte character functions of <a href="#7.22.7">7.22.7</a>
22867 (mblen, mbtowc, and wctomb) in that they have an extra parameter, ps, of type
22868 pointer to mbstate_t that points to an object that can completely describe the current
22869 conversion state of the associated multibyte character sequence. If ps is a null pointer,
22870 each function uses its own internal mbstate_t object instead, which is initialized at
22871 program startup to the initial conversion state; the functions are not required to avoid data
22872 races with other calls to the same function in this case. The implementation behaves as if
22873 no library function calls these functions with a null pointer for ps.
22875 Also unlike their corresponding functions, the return value does not represent whether the
22876 encoding is state-dependent.
22880 <p><b>Synopsis</b>
22882 <pre>
22884 size_t mbrlen(const char * restrict s,
22885 size_t n,
22886 mbstate_t * restrict ps);
22887 </pre>
22888 <p><b>Description</b>
22890 The mbrlen function is equivalent to the call:
22891 <pre>
22892 mbrtowc(NULL, s, n, ps != NULL ? ps : &internal)
22893 </pre>
22894 where internal is the mbstate_t object for the mbrlen function, except that the
22895 expression designated by ps is evaluated only once.
22896 <p><b>Returns</b>
22898 The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
22899 or (size_t)(-1).
22901 <!--page 461 -->
22905 <p><b>Synopsis</b>
22907 <pre>
22909 size_t mbrtowc(wchar_t * restrict pwc,
22910 const char * restrict s,
22911 size_t n,
22912 mbstate_t * restrict ps);
22913 </pre>
22914 <p><b>Description</b>
22916 If s is a null pointer, the mbrtowc function is equivalent to the call:
22917 <pre>
22919 </pre>
22920 In this case, the values of the parameters pwc and n are ignored.
22922 If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
22923 the byte pointed to by s to determine the number of bytes needed to complete the next
22924 multibyte character (including any shift sequences). If the function determines that the
22925 next multibyte character is complete and valid, it determines the value of the
22926 corresponding wide character and then, if pwc is not a null pointer, stores that value in
22927 the object pointed to by pwc. If the corresponding wide character is the null wide
22928 character, the resulting state described is the initial conversion state.
22929 <p><b>Returns</b>
22931 The mbrtowc function returns the first of the following that applies (given the current
22932 conversion state):
22933 <dl>
22934 <dt> 0 <dd>if the next n or fewer bytes complete the multibyte character that
22935 corresponds to the null wide character (which is the value stored).
22936 <dt> between 1 and n inclusive <dd>if the next n or fewer bytes complete a valid multibyte
22937 character (which is the value stored); the value returned is the number
22938 of bytes that complete the multibyte character.
22939 <dt> (size_t)(-2) <dd>if the next n bytes contribute to an incomplete (but potentially valid)
22940 multibyte character, and all n bytes have been processed (no value is
22942 <dt> (size_t)(-1) <dd>if an encoding error occurs, in which case the next n or fewer bytes
22943 do not contribute to a complete and valid multibyte character (no
22944 value is stored); the value of the macro EILSEQ is stored in errno,
22945 and the conversion state is unspecified.
22946 </dl>
22948 <!--page 462 -->
22950 <p><b>Footnotes</b>
22951 <p><small><a name="note349" href="#note349">349)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
22952 sequence of redundant shift sequences (for implementations with state-dependent encodings).
22953 </small>
22957 <p><b>Synopsis</b>
22959 <pre>
22961 size_t wcrtomb(char * restrict s,
22962 wchar_t wc,
22963 mbstate_t * restrict ps);
22964 </pre>
22965 <p><b>Description</b>
22967 If s is a null pointer, the wcrtomb function is equivalent to the call
22968 <pre>
22969 wcrtomb(buf, L'\0', ps)
22970 </pre>
22971 where buf is an internal buffer.
22973 If s is not a null pointer, the wcrtomb function determines the number of bytes needed
22974 to represent the multibyte character that corresponds to the wide character given by wc
22975 (including any shift sequences), and stores the multibyte character representation in the
22976 array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
22977 wc is a null wide character, a null byte is stored, preceded by any shift sequence needed
22978 to restore the initial shift state; the resulting state described is the initial conversion state.
22979 <p><b>Returns</b>
22981 The wcrtomb function returns the number of bytes stored in the array object (including
22982 any shift sequences). When wc is not a valid wide character, an encoding error occurs:
22983 the function stores the value of the macro EILSEQ in errno and returns
22984 (size_t)(-1); the conversion state is unspecified.
22987 <h5><a name="7.29.6.4" href="#7.29.6.4">7.29.6.4 Restartable multibyte/wide string conversion functions</a></h5>
22989 These functions differ from the corresponding multibyte string functions of <a href="#7.22.8">7.22.8</a>
22990 (mbstowcs and wcstombs) in that they have an extra parameter, ps, of type pointer to
22991 mbstate_t that points to an object that can completely describe the current conversion
22992 state of the associated multibyte character sequence. If ps is a null pointer, each function
22993 uses its own internal mbstate_t object instead, which is initialized at program startup
22994 to the initial conversion state; the functions are not required to avoid data races with other
22995 calls to the same function in this case. The implementation behaves as if no library
22996 function calls these functions with a null pointer for ps.
22998 Also unlike their corresponding functions, the conversion source parameter, src, has a
22999 pointer-to-pointer type. When the function is storing the results of conversions (that is,
23000 when dst is not a null pointer), the pointer object pointed to by this parameter is updated
23001 to reflect the amount of the source processed by that invocation.
23002 <!--page 463 -->
23006 <p><b>Synopsis</b>
23008 <pre>
23010 size_t mbsrtowcs(wchar_t * restrict dst,
23011 const char ** restrict src,
23012 size_t len,
23013 mbstate_t * restrict ps);
23014 </pre>
23015 <p><b>Description</b>
23017 The mbsrtowcs function converts a sequence of multibyte characters that begins in the
23018 conversion state described by the object pointed to by ps, from the array indirectly
23019 pointed to by src into a sequence of corresponding wide characters. If dst is not a null
23020 pointer, the converted characters are stored into the array pointed to by dst. Conversion
23021 continues up to and including a terminating null character, which is also stored.
23022 Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
23023 not form a valid multibyte character, or (if dst is not a null pointer) when len wide
23024 characters have been stored into the array pointed to by dst.<sup><a href="#note350"><b>350)</b></a></sup> Each conversion takes
23025 place as if by a call to the mbrtowc function.
23027 If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
23028 pointer (if conversion stopped due to reaching a terminating null character) or the address
23029 just past the last multibyte character converted (if any). If conversion stopped due to
23030 reaching a terminating null character and if dst is not a null pointer, the resulting state
23031 described is the initial conversion state.
23032 <p><b>Returns</b>
23034 If the input conversion encounters a sequence of bytes that do not form a valid multibyte
23035 character, an encoding error occurs: the mbsrtowcs function stores the value of the
23036 macro EILSEQ in errno and returns (size_t)(-1); the conversion state is
23037 unspecified. Otherwise, it returns the number of multibyte characters successfully
23038 converted, not including the terminating null character (if any).
23043 <!--page 464 -->
23045 <p><b>Footnotes</b>
23046 <p><small><a name="note350" href="#note350">350)</a> Thus, the value of len is ignored if dst is a null pointer.
23047 </small>
23051 <p><b>Synopsis</b>
23053 <pre>
23055 size_t wcsrtombs(char * restrict dst,
23056 const wchar_t ** restrict src,
23057 size_t len,
23058 mbstate_t * restrict ps);
23059 </pre>
23060 <p><b>Description</b>
23062 The wcsrtombs function converts a sequence of wide characters from the array
23063 indirectly pointed to by src into a sequence of corresponding multibyte characters that
23064 begins in the conversion state described by the object pointed to by ps. If dst is not a
23065 null pointer, the converted characters are then stored into the array pointed to by dst.
23066 Conversion continues up to and including a terminating null wide character, which is also
23067 stored. Conversion stops earlier in two cases: when a wide character is reached that does
23068 not correspond to a valid multibyte character, or (if dst is not a null pointer) when the
23069 next multibyte character would exceed the limit of len total bytes to be stored into the
23070 array pointed to by dst. Each conversion takes place as if by a call to the wcrtomb
23073 If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
23074 pointer (if conversion stopped due to reaching a terminating null wide character) or the
23075 address just past the last wide character converted (if any). If conversion stopped due to
23076 reaching a terminating null wide character, the resulting state described is the initial
23077 conversion state.
23078 <p><b>Returns</b>
23080 If conversion stops because a wide character is reached that does not correspond to a
23081 valid multibyte character, an encoding error occurs: the wcsrtombs function stores the
23082 value of the macro EILSEQ in errno and returns (size_t)(-1); the conversion
23083 state is unspecified. Otherwise, it returns the number of bytes in the resulting multibyte
23084 character sequence, not including the terminating null character (if any).
23089 <!--page 465 -->
23091 <p><b>Footnotes</b>
23092 <p><small><a name="note351" href="#note351">351)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
23093 include those necessary to reach the initial shift state immediately before the null byte.
23094 </small>
23097 <h3><a name="7.30" href="#7.30">7.30 Wide character classification and mapping utilities <wctype.h></a></h3>
23102 The header <a href="#7.30"><wctype.h></a> defines one macro, and declares three data types and many
23105 The types declared are
23106 <pre>
23107 wint_t
23108 </pre>
23110 <pre>
23111 wctrans_t
23112 </pre>
23113 which is a scalar type that can hold values which represent locale-specific character
23114 mappings; and
23115 <pre>
23116 wctype_t
23117 </pre>
23118 which is a scalar type that can hold values which represent locale-specific character
23119 classifications.
23123 The functions declared are grouped as follows:
23124 <ul>
23125 <li> Functions that provide wide character classification;
23126 <li> Extensible functions that provide wide character classification;
23127 <li> Functions that provide wide character case mapping;
23128 <li> Extensible functions that provide wide character mapping.
23129 </ul>
23131 For all functions described in this subclause that accept an argument of type wint_t, the
23132 value shall be representable as a wchar_t or shall equal the value of the macro WEOF. If
23133 this argument has any other value, the behavior is undefined.
23135 The behavior of these functions is affected by the LC_CTYPE category of the current
23136 locale.
23141 <!--page 466 -->
23143 <p><b>Footnotes</b>
23144 <p><small><a name="note352" href="#note352">352)</a> See ''future library directions'' (<a href="#7.31.17">7.31.17</a>).
23145 </small>
23150 The header <a href="#7.30"><wctype.h></a> declares several functions useful for classifying wide
23151 characters.
23153 The term printing wide character refers to a member of a locale-specific set of wide
23154 characters, each of which occupies at least one printing position on a display device. The
23155 term control wide character refers to a member of a locale-specific set of wide characters
23156 that are not printing wide characters.
23159 <h5><a name="7.30.2.1" href="#7.30.2.1">7.30.2.1 Wide character classification functions</a></h5>
23161 The functions in this subclause return nonzero (true) if and only if the value of the
23162 argument wc conforms to that in the description of the function.
23164 Each of the following functions returns true for each wide character that corresponds (as
23165 if by a call to the wctob function) to a single-byte character for which the corresponding
23166 character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
23167 iswpunct functions may differ with respect to wide characters other than L' ' that are
23171 <p><b>Footnotes</b>
23172 <p><small><a name="note353" href="#note353">353)</a> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
23173 iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
23174 (which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
23175 && iswspace(wc) is true, but not both.
23176 </small>
23180 <p><b>Synopsis</b>
23182 <pre>
23184 int iswalnum(wint_t wc);
23185 </pre>
23186 <p><b>Description</b>
23188 The iswalnum function tests for any wide character for which iswalpha or
23189 iswdigit is true.
23193 <p><b>Synopsis</b>
23195 <pre>
23197 int iswalpha(wint_t wc);
23198 </pre>
23199 <p><b>Description</b>
23201 The iswalpha function tests for any wide character for which iswupper or
23202 iswlower is true, or any wide character that is one of a locale-specific set of alphabetic
23204 <!--page 467 -->
23205 wide characters for which none of iswcntrl, iswdigit, iswpunct, or iswspace
23208 <p><b>Footnotes</b>
23209 <p><small><a name="note354" href="#note354">354)</a> The functions iswlower and iswupper test true or false separately for each of these additional
23210 wide characters; all four combinations are possible.
23211 </small>
23215 <p><b>Synopsis</b>
23217 <pre>
23219 int iswblank(wint_t wc);
23220 </pre>
23221 <p><b>Description</b>
23223 The iswblank function tests for any wide character that is a standard blank wide
23224 character or is one of a locale-specific set of wide characters for which iswspace is true
23225 and that is used to separate words within a line of text. The standard blank wide
23227 locale, iswblank returns true only for the standard blank characters.
23231 <p><b>Synopsis</b>
23233 <pre>
23235 int iswcntrl(wint_t wc);
23236 </pre>
23237 <p><b>Description</b>
23239 The iswcntrl function tests for any control wide character.
23243 <p><b>Synopsis</b>
23245 <pre>
23247 int iswdigit(wint_t wc);
23248 </pre>
23249 <p><b>Description</b>
23251 The iswdigit function tests for any wide character that corresponds to a decimal-digit
23256 <p><b>Synopsis</b>
23258 <pre>
23260 int iswgraph(wint_t wc);
23261 </pre>
23266 <!--page 468 -->
23267 <p><b>Description</b>
23269 The iswgraph function tests for any wide character for which iswprint is true and
23272 <p><b>Footnotes</b>
23273 <p><small><a name="note355" href="#note355">355)</a> Note that the behavior of the iswgraph and iswpunct functions may differ from their
23274 corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
23275 characters other than ' '.
23276 </small>
23280 <p><b>Synopsis</b>
23282 <pre>
23284 int iswlower(wint_t wc);
23285 </pre>
23286 <p><b>Description</b>
23288 The iswlower function tests for any wide character that corresponds to a lowercase
23289 letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
23290 iswdigit, iswpunct, or iswspace is true.
23294 <p><b>Synopsis</b>
23296 <pre>
23298 int iswprint(wint_t wc);
23299 </pre>
23300 <p><b>Description</b>
23302 The iswprint function tests for any printing wide character.
23306 <p><b>Synopsis</b>
23308 <pre>
23310 int iswpunct(wint_t wc);
23311 </pre>
23312 <p><b>Description</b>
23314 The iswpunct function tests for any printing wide character that is one of a locale-
23315 specific set of punctuation wide characters for which neither iswspace nor iswalnum
23320 <p><b>Synopsis</b>
23322 <pre>
23324 int iswspace(wint_t wc);
23325 </pre>
23329 <!--page 469 -->
23330 <p><b>Description</b>
23332 The iswspace function tests for any wide character that corresponds to a locale-specific
23333 set of white-space wide characters for which none of iswalnum, iswgraph, or
23334 iswpunct is true.
23338 <p><b>Synopsis</b>
23340 <pre>
23342 int iswupper(wint_t wc);
23343 </pre>
23344 <p><b>Description</b>
23346 The iswupper function tests for any wide character that corresponds to an uppercase
23347 letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
23348 iswdigit, iswpunct, or iswspace is true.
23352 <p><b>Synopsis</b>
23354 <pre>
23356 int iswxdigit(wint_t wc);
23357 </pre>
23358 <p><b>Description</b>
23360 The iswxdigit function tests for any wide character that corresponds to a
23364 <h5><a name="7.30.2.2" href="#7.30.2.2">7.30.2.2 Extensible wide character classification functions</a></h5>
23366 The functions wctype and iswctype provide extensible wide character classification
23367 as well as testing equivalent to that performed by the functions described in the previous
23372 <p><b>Synopsis</b>
23374 <pre>
23376 int iswctype(wint_t wc, wctype_t desc);
23377 </pre>
23378 <p><b>Description</b>
23380 The iswctype function determines whether the wide character wc has the property
23381 described by desc. The current setting of the LC_CTYPE category shall be the same as
23382 during the call to wctype that returned the value desc.
23384 Each of the following expressions has a truth-value equivalent to the call to the wide
23385 character classification function (<a href="#7.30.2.1">7.30.2.1</a>) in the comment that follows the expression:
23386 <!--page 470 -->
23387 <pre>
23400 </pre>
23401 <p><b>Returns</b>
23403 The iswctype function returns nonzero (true) if and only if the value of the wide
23404 character wc has the property described by desc. If desc is zero, the iswctype
23405 function returns zero (false).
23410 <p><b>Synopsis</b>
23412 <pre>
23414 wctype_t wctype(const char *property);
23415 </pre>
23416 <p><b>Description</b>
23418 The wctype function constructs a value with type wctype_t that describes a class of
23419 wide characters identified by the string argument property.
23421 The strings listed in the description of the iswctype function shall be valid in all
23422 locales as property arguments to the wctype function.
23423 <p><b>Returns</b>
23425 If property identifies a valid class of wide characters according to the LC_CTYPE
23426 category of the current locale, the wctype function returns a nonzero value that is valid
23427 as the second argument to the iswctype function; otherwise, it returns zero.
23428 <!--page 471 -->
23433 The header <a href="#7.30"><wctype.h></a> declares several functions useful for mapping wide characters.
23436 <h5><a name="7.30.3.1" href="#7.30.3.1">7.30.3.1 Wide character case mapping functions</a></h5>
23440 <p><b>Synopsis</b>
23442 <pre>
23444 wint_t towlower(wint_t wc);
23445 </pre>
23446 <p><b>Description</b>
23448 The towlower function converts an uppercase letter to a corresponding lowercase letter.
23449 <p><b>Returns</b>
23451 If the argument is a wide character for which iswupper is true and there are one or
23452 more corresponding wide characters, as specified by the current locale, for which
23453 iswlower is true, the towlower function returns one of the corresponding wide
23454 characters (always the same one for any given locale); otherwise, the argument is
23455 returned unchanged.
23459 <p><b>Synopsis</b>
23461 <pre>
23463 wint_t towupper(wint_t wc);
23464 </pre>
23465 <p><b>Description</b>
23467 The towupper function converts a lowercase letter to a corresponding uppercase letter.
23468 <p><b>Returns</b>
23470 If the argument is a wide character for which iswlower is true and there are one or
23471 more corresponding wide characters, as specified by the current locale, for which
23472 iswupper is true, the towupper function returns one of the corresponding wide
23473 characters (always the same one for any given locale); otherwise, the argument is
23474 returned unchanged.
23477 <h5><a name="7.30.3.2" href="#7.30.3.2">7.30.3.2 Extensible wide character case mapping functions</a></h5>
23479 The functions wctrans and towctrans provide extensible wide character mapping as
23480 well as case mapping equivalent to that performed by the functions described in the
23482 <!--page 472 -->
23486 <p><b>Synopsis</b>
23488 <pre>
23490 wint_t towctrans(wint_t wc, wctrans_t desc);
23491 </pre>
23492 <p><b>Description</b>
23494 The towctrans function maps the wide character wc using the mapping described by
23495 desc. The current setting of the LC_CTYPE category shall be the same as during the call
23496 to wctrans that returned the value desc.
23498 Each of the following expressions behaves the same as the call to the wide character case
23499 mapping function (<a href="#7.30.3.1">7.30.3.1</a>) in the comment that follows the expression:
23500 <pre>
23503 </pre>
23504 <p><b>Returns</b>
23506 The towctrans function returns the mapped value of wc using the mapping described
23507 by desc. If desc is zero, the towctrans function returns the value of wc.
23511 <p><b>Synopsis</b>
23513 <pre>
23515 wctrans_t wctrans(const char *property);
23516 </pre>
23517 <p><b>Description</b>
23519 The wctrans function constructs a value with type wctrans_t that describes a
23520 mapping between wide characters identified by the string argument property.
23522 The strings listed in the description of the towctrans function shall be valid in all
23523 locales as property arguments to the wctrans function.
23524 <p><b>Returns</b>
23526 If property identifies a valid mapping of wide characters according to the LC_CTYPE
23527 category of the current locale, the wctrans function returns a nonzero value that is valid
23528 as the second argument to the towctrans function; otherwise, it returns zero.
23529 <!--page 473 -->
23534 The following names are grouped under individual headers for convenience. All external
23535 names described below are reserved no matter what headers are included by the program.
23540 The function names
23541 <pre>
23542 cerf cexpm1 clog2
23543 cerfc clog10 clgamma
23544 cexp2 clog1p ctgamma
23545 </pre>
23546 and the same names suffixed with f or l may be added to the declarations in the
23552 Function names that begin with either is or to, and a lowercase letter may be added to
23558 Macros that begin with E and a digit or E and an uppercase letter may be added to the
23564 Macros that begin with FE_ and an uppercase letter may be added to the macros defined
23568 <h4><a name="7.31.5" href="#7.31.5">7.31.5 Format conversion of integer types <inttypes.h></a></h4>
23570 Macros that begin with either PRI or SCN, and either a lowercase letter or X may be
23576 Macros that begin with LC_ and an uppercase letter may be added to the macros defined
23582 Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
23588 Macros that begin with ATOMIC_ and an uppercase letter may be added to the macros
23589 defined in the <a href="#7.17"><stdatomic.h></a> header. Typedef names that begin with either
23590 atomic_ or memory_, and a lowercase letter may be added to the declarations in the
23591 <a href="#7.17"><stdatomic.h></a> header. Enumeration constants that begin with memory_order_
23592 <!--page 474 -->
23593 and a lowercase letter may be added to the definition of the memory_order type in the
23594 <a href="#7.17"><stdatomic.h></a> header. Function names that begin with atomic_ and a lowercase
23595 letter may be added to the declarations in the <a href="#7.17"><stdatomic.h></a> header.
23600 The ability to undefine and perhaps then redefine the macros bool, true, and false is
23601 an obsolescent feature.
23606 Typedef names beginning with int or uint and ending with _t may be added to the
23607 types defined in the <a href="#7.20"><stdint.h></a> header. Macro names beginning with INT or UINT
23608 and ending with _MAX, _MIN, or _C may be added to the macros defined in the
23614 Lowercase letters may be added to the conversion specifiers and length modifiers in
23615 fprintf and fscanf. Other characters may be used in extensions.
23617 The use of ungetc on a binary stream where the file position indicator is zero prior to
23618 the call is an obsolescent feature.
23623 Function names that begin with str and a lowercase letter may be added to the
23629 Function names that begin with str, mem, or wcs and a lowercase letter may be added
23634 Macros beginning with TIME_ and an uppercase letter may be added to the macros in the
23640 Function names, type names, and enumeration constants that begin with either cnd_,
23641 mtx_, thrd_, or tss_, and a lowercase letter may be added to the declarations in the
23645 <h4><a name="7.31.16" href="#7.31.16">7.31.16 Extended multibyte and wide character utilities <wchar.h></a></h4>
23647 Function names that begin with wcs and a lowercase letter may be added to the
23650 Lowercase letters may be added to the conversion specifiers and length modifiers in
23651 fwprintf and fwscanf. Other characters may be used in extensions.
23652 <!--page 475 -->
23655 <h4><a name="7.31.17" href="#7.31.17">7.31.17 Wide character classification and mapping utilities</a></h4>
23658 Function names that begin with is or to and a lowercase letter may be added to the
23660 <!--page 476 -->
23664 <pre>
23665 (informative)
23666 Language syntax summary
23667 </pre>
23678 <pre>
23679 keyword
23680 identifier
23681 constant
23682 string-literal
23683 punctuator
23684 </pre>
23686 <!--page 477 -->
23687 <pre>
23688 header-name
23689 identifier
23690 pp-number
23691 character-constant
23692 string-literal
23693 punctuator
23694 each non-white-space character that cannot be one of the above
23695 </pre>
23700 <pre>
23701 auto if unsigned
23702 break inline void
23703 case int volatile
23704 char long while
23705 const register _Alignas
23706 continue restrict _Alignof
23707 default return _Atomic
23708 do short _Bool
23709 double signed _Complex
23710 else sizeof _Generic
23711 enum static _Imaginary
23712 extern struct _Noreturn
23713 float switch _Static_assert
23714 for typedef _Thread_local
23715 goto union
23716 </pre>
23721 <pre>
23722 identifier-nondigit
23723 identifier identifier-nondigit
23724 identifier digit
23725 </pre>
23727 <pre>
23728 nondigit
23729 universal-character-name
23730 other implementation-defined characters
23731 </pre>
23733 <pre>
23734 _ a b c d e f g h i j k l m
23735 n o p q r s t u v w x y z
23736 A B C D E F G H I J K L M
23737 N O P Q R S T U V W X Y Z
23738 </pre>
23740 <!--page 478 -->
23741 <pre>
23742 0 1 2 3 4 5 6 7 8 9
23743 </pre>
23748 <pre>
23749 \u hex-quad
23750 \U hex-quad hex-quad
23751 </pre>
23753 <pre>
23754 hexadecimal-digit hexadecimal-digit
23755 hexadecimal-digit hexadecimal-digit
23756 </pre>
23761 <pre>
23762 integer-constant
23763 floating-constant
23764 enumeration-constant
23765 character-constant
23766 </pre>
23768 <pre>
23769 decimal-constant integer-suffix<sub>opt</sub>
23770 octal-constant integer-suffix<sub>opt</sub>
23771 hexadecimal-constant integer-suffix<sub>opt</sub>
23772 </pre>
23774 <pre>
23775 nonzero-digit
23776 decimal-constant digit
23777 </pre>
23779 <pre>
23780 0
23781 octal-constant octal-digit
23782 </pre>
23784 <pre>
23785 hexadecimal-prefix hexadecimal-digit
23786 hexadecimal-constant hexadecimal-digit
23787 </pre>
23789 <pre>
23790 0x 0X
23791 </pre>
23793 <pre>
23794 1 2 3 4 5 6 7 8 9
23795 </pre>
23797 <!--page 479 -->
23798 <pre>
23799 0 1 2 3 4 5 6 7
23800 </pre>
23802 <pre>
23803 0 1 2 3 4 5 6 7 8 9
23804 a b c d e f
23805 A B C D E F
23806 </pre>
23808 <pre>
23809 unsigned-suffix long-suffix<sub>opt</sub>
23810 unsigned-suffix long-long-suffix
23811 long-suffix unsigned-suffix<sub>opt</sub>
23812 long-long-suffix unsigned-suffix<sub>opt</sub>
23813 </pre>
23815 <pre>
23816 u U
23817 </pre>
23819 <pre>
23820 l L
23821 </pre>
23823 <pre>
23824 ll LL
23825 </pre>
23827 <pre>
23828 decimal-floating-constant
23829 hexadecimal-floating-constant
23830 </pre>
23832 <pre>
23833 fractional-constant exponent-part<sub>opt</sub> floating-suffix<sub>opt</sub>
23834 digit-sequence exponent-part floating-suffix<sub>opt</sub>
23835 </pre>
23837 <pre>
23838 hexadecimal-prefix hexadecimal-fractional-constant
23839 binary-exponent-part floating-suffix<sub>opt</sub>
23840 hexadecimal-prefix hexadecimal-digit-sequence
23841 binary-exponent-part floating-suffix<sub>opt</sub>
23842 </pre>
23844 <pre>
23845 digit-sequence<sub>opt</sub> . digit-sequence
23846 digit-sequence .
23847 </pre>
23849 <pre>
23850 e sign<sub>opt</sub> digit-sequence
23851 E sign<sub>opt</sub> digit-sequence
23852 </pre>
23854 <!--page 480 -->
23855 <pre>
23856 + -
23857 </pre>
23859 <pre>
23860 digit
23861 digit-sequence digit
23862 </pre>
23864 <pre>
23865 hexadecimal-digit-sequence<sub>opt</sub> .
23866 hexadecimal-digit-sequence
23867 hexadecimal-digit-sequence .
23868 </pre>
23870 <pre>
23871 p sign<sub>opt</sub> digit-sequence
23872 P sign<sub>opt</sub> digit-sequence
23873 </pre>
23875 <pre>
23876 hexadecimal-digit
23877 hexadecimal-digit-sequence hexadecimal-digit
23878 </pre>
23880 <pre>
23881 f l F L
23882 </pre>
23884 <pre>
23885 identifier
23886 </pre>
23888 <pre>
23889 ' c-char-sequence '
23890 L' c-char-sequence '
23891 u' c-char-sequence '
23892 U' c-char-sequence '
23893 </pre>
23895 <pre>
23896 c-char
23897 c-char-sequence c-char
23898 </pre>
23900 <pre>
23901 any member of the source character set except
23902 the single-quote ', backslash \, or new-line character
23903 escape-sequence
23904 </pre>
23906 <!--page 481 -->
23907 <pre>
23908 simple-escape-sequence
23909 octal-escape-sequence
23910 hexadecimal-escape-sequence
23911 universal-character-name
23912 </pre>
23914 <pre>
23915 \' \" \? \\
23916 \a \b \f \n \r \t \v
23917 </pre>
23919 <pre>
23920 \ octal-digit
23921 \ octal-digit octal-digit
23922 \ octal-digit octal-digit octal-digit
23923 </pre>
23925 <pre>
23926 \x hexadecimal-digit
23927 hexadecimal-escape-sequence hexadecimal-digit
23928 </pre>
23933 <pre>
23935 </pre>
23937 <pre>
23938 u8
23939 u
23940 U
23941 L
23942 </pre>
23944 <pre>
23945 s-char
23946 s-char-sequence s-char
23947 </pre>
23949 <pre>
23950 any member of the source character set except
23951 the double-quote ", backslash \, or new-line character
23952 escape-sequence
23953 </pre>
23958 <!--page 482 -->
23959 <pre>
23960 [ ] ( ) { } . ->
23961 ++ -- & * + - ~ !
23962 / % << >> < > <= >= == != ^ | && ||
23963 ? : ; ...
23964 = *= /= %= += -= <<= >>= &= ^= |=
23965 , # ##
23966 <: :> <% %> %: %:%:
23967 </pre>
23972 <pre>
23973 < h-char-sequence >
23975 </pre>
23977 <pre>
23978 h-char
23979 h-char-sequence h-char
23980 </pre>
23982 <pre>
23983 any member of the source character set except
23984 the new-line character and >
23985 </pre>
23987 <pre>
23988 q-char
23989 q-char-sequence q-char
23990 </pre>
23992 <pre>
23993 any member of the source character set except
23994 the new-line character and "
23995 </pre>
24000 <!--page 483 -->
24001 <pre>
24002 digit
24003 . digit
24004 pp-number digit
24005 pp-number identifier-nondigit
24006 pp-number e sign
24007 pp-number E sign
24008 pp-number p sign
24009 pp-number P sign
24010 pp-number .
24011 </pre>
24019 <pre>
24020 identifier
24021 constant
24022 string-literal
24023 ( expression )
24024 generic-selection
24025 </pre>
24027 <pre>
24028 _Generic ( assignment-expression , generic-assoc-list )
24029 </pre>
24031 <pre>
24032 generic-association
24033 generic-assoc-list , generic-association
24034 </pre>
24036 <pre>
24037 type-name : assignment-expression
24038 default : assignment-expression
24039 </pre>
24041 <pre>
24042 primary-expression
24043 postfix-expression [ expression ]
24045 postfix-expression . identifier
24046 postfix-expression -> identifier
24047 postfix-expression ++
24048 postfix-expression --
24049 ( type-name ) { initializer-list }
24050 ( type-name ) { initializer-list , }
24051 </pre>
24053 <pre>
24054 assignment-expression
24055 argument-expression-list , assignment-expression
24056 </pre>
24058 <!--page 484 -->
24059 <pre>
24060 postfix-expression
24061 ++ unary-expression
24062 -- unary-expression
24063 unary-operator cast-expression
24064 sizeof unary-expression
24065 sizeof ( type-name )
24066 _Alignof ( type-name )
24067 </pre>
24069 <pre>
24070 & * + - ~ !
24071 </pre>
24073 <pre>
24074 unary-expression
24075 ( type-name ) cast-expression
24076 </pre>
24078 <pre>
24079 cast-expression
24080 multiplicative-expression * cast-expression
24081 multiplicative-expression / cast-expression
24082 multiplicative-expression % cast-expression
24083 </pre>
24085 <pre>
24086 multiplicative-expression
24087 additive-expression + multiplicative-expression
24088 additive-expression - multiplicative-expression
24089 </pre>
24091 <pre>
24092 additive-expression
24093 shift-expression << additive-expression
24094 shift-expression >> additive-expression
24095 </pre>
24097 <pre>
24098 shift-expression
24099 relational-expression < shift-expression
24100 relational-expression > shift-expression
24101 relational-expression <= shift-expression
24102 relational-expression >= shift-expression
24103 </pre>
24105 <pre>
24106 relational-expression
24107 equality-expression == relational-expression
24108 equality-expression != relational-expression
24109 </pre>
24111 <pre>
24112 equality-expression
24113 AND-expression & equality-expression
24114 </pre>
24116 <!--page 485 -->
24117 <pre>
24118 AND-expression
24119 exclusive-OR-expression ^ AND-expression
24120 </pre>
24122 <pre>
24123 exclusive-OR-expression
24124 inclusive-OR-expression | exclusive-OR-expression
24125 </pre>
24127 <pre>
24128 inclusive-OR-expression
24129 logical-AND-expression && inclusive-OR-expression
24130 </pre>
24132 <pre>
24133 logical-AND-expression
24134 logical-OR-expression || logical-AND-expression
24135 </pre>
24137 <pre>
24138 logical-OR-expression
24139 logical-OR-expression ? expression : conditional-expression
24140 </pre>
24142 <pre>
24143 conditional-expression
24144 unary-expression assignment-operator assignment-expression
24145 </pre>
24147 <pre>
24149 </pre>
24151 <pre>
24152 assignment-expression
24153 expression , assignment-expression
24154 </pre>
24156 <pre>
24157 conditional-expression
24158 </pre>
24163 <pre>
24165 static_assert-declaration
24166 </pre>
24168 <pre>
24174 </pre>
24176 <!--page 486 -->
24177 <pre>
24178 init-declarator
24179 init-declarator-list , init-declarator
24180 </pre>
24182 <pre>
24183 declarator
24184 declarator = initializer
24185 </pre>
24187 <pre>
24188 typedef
24189 extern
24190 static
24191 _Thread_local
24192 auto
24193 register
24194 </pre>
24196 <pre>
24197 void
24198 char
24199 short
24200 int
24201 long
24202 float
24203 double
24204 signed
24205 unsigned
24206 _Bool
24207 _Complex
24208 atomic-type-specifier
24209 struct-or-union-specifier
24210 enum-specifier
24211 typedef-name
24212 </pre>
24214 <pre>
24216 struct-or-union identifier
24217 </pre>
24219 <pre>
24220 struct
24221 union
24222 </pre>
24224 <pre>
24225 struct-declaration
24226 struct-declaration-list struct-declaration
24227 </pre>
24229 <!--page 487 -->
24230 <pre>
24232 static_assert-declaration
24233 </pre>
24235 <pre>
24238 </pre>
24240 <pre>
24241 struct-declarator
24242 struct-declarator-list , struct-declarator
24243 </pre>
24245 <pre>
24246 declarator
24248 </pre>
24250 <pre>
24253 enum identifier
24254 </pre>
24256 <pre>
24257 enumerator
24258 enumerator-list , enumerator
24259 </pre>
24261 <pre>
24262 enumeration-constant
24263 enumeration-constant = constant-expression
24264 </pre>
24266 <pre>
24267 _Atomic ( type-name )
24268 </pre>
24270 <pre>
24271 const
24272 restrict
24273 volatile
24274 _Atomic
24275 </pre>
24277 <pre>
24278 inline
24279 _Noreturn
24280 </pre>
24282 <pre>
24283 _Alignas ( type-name )
24284 _Alignas ( constant-expression )
24285 </pre>
24287 <!--page 488 -->
24288 <pre>
24290 </pre>
24292 <pre>
24293 identifier
24294 ( declarator )
24297 direct-declarator [ type-qualifier-list static assignment-expression ]
24299 direct-declarator ( parameter-type-list )
24301 </pre>
24303 <pre>
24306 </pre>
24308 <pre>
24309 type-qualifier
24310 type-qualifier-list type-qualifier
24311 </pre>
24313 <pre>
24314 parameter-list
24315 parameter-list , ...
24316 </pre>
24318 <pre>
24319 parameter-declaration
24320 parameter-list , parameter-declaration
24321 </pre>
24323 <pre>
24324 declaration-specifiers declarator
24326 </pre>
24328 <pre>
24329 identifier
24330 identifier-list , identifier
24331 </pre>
24333 <pre>
24335 </pre>
24337 <!--page 489 -->
24338 <pre>
24339 pointer
24341 </pre>
24343 <pre>
24344 ( abstract-declarator )
24348 assignment-expression ]
24350 assignment-expression ]
24353 </pre>
24355 <pre>
24356 identifier
24357 </pre>
24359 <pre>
24360 assignment-expression
24361 { initializer-list }
24362 { initializer-list , }
24363 </pre>
24365 <pre>
24368 </pre>
24370 <pre>
24371 designator-list =
24372 </pre>
24374 <pre>
24375 designator
24376 designator-list designator
24377 </pre>
24379 <pre>
24380 [ constant-expression ]
24381 . identifier
24382 </pre>
24384 <!--page 490 -->
24385 <pre>
24386 _Static_assert ( constant-expression , string-literal ) ;
24387 </pre>
24392 <pre>
24393 labeled-statement
24394 compound-statement
24395 expression-statement
24396 selection-statement
24397 iteration-statement
24398 jump-statement
24399 </pre>
24401 <pre>
24402 identifier : statement
24403 case constant-expression : statement
24404 default : statement
24405 </pre>
24407 <pre>
24409 </pre>
24411 <pre>
24412 block-item
24413 block-item-list block-item
24414 </pre>
24416 <pre>
24417 declaration
24418 statement
24419 </pre>
24421 <pre>
24423 </pre>
24425 <pre>
24426 if ( expression ) statement
24427 if ( expression ) statement else statement
24428 switch ( expression ) statement
24429 </pre>
24431 <pre>
24432 while ( expression ) statement
24433 do statement while ( expression ) ;
24434 for ( expression<sub>opt</sub> ; expression<sub>opt</sub> ; expression<sub>opt</sub> ) statement
24436 </pre>
24438 <!--page 491 -->
24439 <pre>
24440 goto identifier ;
24441 continue ;
24442 break ;
24444 </pre>
24449 <pre>
24450 external-declaration
24451 translation-unit external-declaration
24452 </pre>
24454 <pre>
24455 function-definition
24456 declaration
24457 </pre>
24459 <pre>
24461 </pre>
24463 <pre>
24464 declaration
24465 declaration-list declaration
24466 </pre>
24471 <pre>
24473 </pre>
24475 <pre>
24476 group-part
24477 group group-part
24478 </pre>
24480 <pre>
24481 if-section
24482 control-line
24483 text-line
24484 # non-directive
24485 </pre>
24487 <pre>
24489 </pre>
24491 <pre>
24495 </pre>
24497 <pre>
24498 elif-group
24499 elif-groups elif-group
24500 </pre>
24502 <!--page 492 -->
24503 <pre>
24505 </pre>
24507 <pre>
24509 </pre>
24511 <pre>
24512 # endif new-line
24513 </pre>
24515 <pre>
24516 # include pp-tokens new-line
24517 # define identifier replacement-list new-line
24519 replacement-list new-line
24520 # define identifier lparen ... ) replacement-list new-line
24521 # define identifier lparen identifier-list , ... )
24522 replacement-list new-line
24523 # undef identifier new-line
24524 # line pp-tokens new-line
24527 # new-line
24528 </pre>
24530 <pre>
24532 </pre>
24534 <pre>
24535 pp-tokens new-line
24536 </pre>
24538 <pre>
24539 a ( character not immediately preceded by white-space
24540 </pre>
24542 <pre>
24544 </pre>
24546 <pre>
24547 preprocessing-token
24548 pp-tokens preprocessing-token
24549 </pre>
24551 <!--page 493 -->
24552 <pre>
24553 the new-line character
24554 </pre>
24558 <pre>
24559 (informative)
24560 Library summary
24561 </pre>
24565 <pre>
24566 NDEBUG
24567 static_assert
24568 void assert(scalar expression);
24569 </pre>
24573 <!--page 494 -->
24574 <!--page 495 -->
24575 <pre>
24576 __STDC_NO_COMPLEX__ imaginary
24577 complex _Imaginary_I
24578 _Complex_I I
24579 #pragma STDC CX_LIMITED_RANGE on-off-switch
24580 double complex cacos(double complex z);
24581 float complex cacosf(float complex z);
24582 long double complex cacosl(long double complex z);
24583 double complex casin(double complex z);
24584 float complex casinf(float complex z);
24585 long double complex casinl(long double complex z);
24586 double complex catan(double complex z);
24587 float complex catanf(float complex z);
24588 long double complex catanl(long double complex z);
24589 double complex ccos(double complex z);
24590 float complex ccosf(float complex z);
24591 long double complex ccosl(long double complex z);
24592 double complex csin(double complex z);
24593 float complex csinf(float complex z);
24594 long double complex csinl(long double complex z);
24595 double complex ctan(double complex z);
24596 float complex ctanf(float complex z);
24597 long double complex ctanl(long double complex z);
24598 double complex cacosh(double complex z);
24599 float complex cacoshf(float complex z);
24600 long double complex cacoshl(long double complex z);
24601 double complex casinh(double complex z);
24602 float complex casinhf(float complex z);
24603 long double complex casinhl(long double complex z);
24604 double complex catanh(double complex z);
24605 float complex catanhf(float complex z);
24606 long double complex catanhl(long double complex z);
24607 double complex ccosh(double complex z);
24608 float complex ccoshf(float complex z);
24609 long double complex ccoshl(long double complex z);
24610 double complex csinh(double complex z);
24611 float complex csinhf(float complex z);
24612 long double complex csinhl(long double complex z);
24613 double complex ctanh(double complex z);
24614 float complex ctanhf(float complex z);
24615 long double complex ctanhl(long double complex z);
24616 double complex cexp(double complex z);
24617 float complex cexpf(float complex z);
24618 long double complex cexpl(long double complex z);
24619 double complex clog(double complex z);
24620 float complex clogf(float complex z);
24621 long double complex clogl(long double complex z);
24622 double cabs(double complex z);
24623 float cabsf(float complex z);
24624 long double cabsl(long double complex z);
24625 double complex cpow(double complex x, double complex y);
24626 float complex cpowf(float complex x, float complex y);
24627 long double complex cpowl(long double complex x,
24628 long double complex y);
24629 double complex csqrt(double complex z);
24630 float complex csqrtf(float complex z);
24631 long double complex csqrtl(long double complex z);
24632 double carg(double complex z);
24633 float cargf(float complex z);
24634 long double cargl(long double complex z);
24635 double cimag(double complex z);
24636 float cimagf(float complex z);
24637 long double cimagl(long double complex z);
24638 double complex CMPLX(double x, double y);
24639 float complex CMPLXF(float x, float y);
24640 long double complex CMPLXL(long double x, long double y);
24641 double complex conj(double complex z);
24642 float complex conjf(float complex z);
24643 long double complex conjl(long double complex z);
24644 double complex cproj(double complex z);
24645 float complex cprojf(float complex z);
24646 long double complex cprojl(long double complex z);
24647 double creal(double complex z);
24648 float crealf(float complex z);
24649 long double creall(long double complex z);
24650 </pre>
24654 <pre>
24655 int isalnum(int c);
24656 int isalpha(int c);
24657 int isblank(int c);
24658 int iscntrl(int c);
24659 int isdigit(int c);
24660 int isgraph(int c);
24661 int islower(int c);
24662 int isprint(int c);
24663 int ispunct(int c);
24664 int isspace(int c);
24665 int isupper(int c);
24666 int isxdigit(int c);
24667 int tolower(int c);
24668 int toupper(int c);
24669 </pre>
24673 <pre>
24674 EDOM EILSEQ ERANGE errno
24675 __STDC_WANT_LIB_EXT1__
24676 errno_t
24677 </pre>
24681 <!--page 496 -->
24682 <pre>
24683 fenv_t FE_OVERFLOW FE_TOWARDZERO
24684 fexcept_t FE_UNDERFLOW FE_UPWARD
24685 FE_DIVBYZERO FE_ALL_EXCEPT FE_DFL_ENV
24686 FE_INEXACT FE_DOWNWARD
24687 FE_INVALID FE_TONEAREST
24688 #pragma STDC FENV_ACCESS on-off-switch
24689 int feclearexcept(int excepts);
24690 int fegetexceptflag(fexcept_t *flagp, int excepts);
24691 int feraiseexcept(int excepts);
24692 int fesetexceptflag(const fexcept_t *flagp,
24693 int excepts);
24694 int fetestexcept(int excepts);
24695 int fegetround(void);
24696 int fesetround(int round);
24697 int fegetenv(fenv_t *envp);
24698 int feholdexcept(fenv_t *envp);
24699 int fesetenv(const fenv_t *envp);
24700 int feupdateenv(const fenv_t *envp);
24701 </pre>
24705 <pre>
24706 FLT_ROUNDS DBL_DIG FLT_MAX
24707 FLT_EVAL_METHOD LDBL_DIG DBL_MAX
24708 FLT_HAS_SUBNORM FLT_MIN_EXP LDBL_MAX
24709 DBL_HAS_SUBNORM DBL_MIN_EXP FLT_EPSILON
24710 LDBL_HAS_SUBNORM LDBL_MIN_EXP DBL_EPSILON
24711 FLT_RADIX FLT_MIN_10_EXP LDBL_EPSILON
24712 FLT_MANT_DIG DBL_MIN_10_EXP FLT_MIN
24713 DBL_MANT_DIG LDBL_MIN_10_EXP DBL_MIN
24714 LDBL_MANT_DIG FLT_MAX_EXP LDBL_MIN
24715 FLT_DECIMAL_DIG DBL_MAX_EXP FLT_TRUE_MIN
24716 DBL_DECIMAL_DIG LDBL_MAX_EXP DBL_TRUE_MIN
24717 LDBL_DECIMAL_DIG FLT_MAX_10_EXP LDBL_TRUE_MIN
24718 DECIMAL_DIG DBL_MAX_10_EXP
24719 FLT_DIG LDBL_MAX_10_EXP
24720 </pre>
24723 <h3><a name="B.7" href="#B.7">B.7 Format conversion of integer types <inttypes.h></a></h3>
24724 <!--page 497 -->
24725 <pre>
24726 imaxdiv_t
24727 PRIdN PRIdLEASTN PRIdFASTN PRIdMAX PRIdPTR
24728 PRIiN PRIiLEASTN PRIiFASTN PRIiMAX PRIiPTR
24729 PRIoN PRIoLEASTN PRIoFASTN PRIoMAX PRIoPTR
24730 PRIuN PRIuLEASTN PRIuFASTN PRIuMAX PRIuPTR
24731 PRIxN PRIxLEASTN PRIxFASTN PRIxMAX PRIxPTR
24732 PRIXN PRIXLEASTN PRIXFASTN PRIXMAX PRIXPTR
24733 SCNdN SCNdLEASTN SCNdFASTN SCNdMAX SCNdPTR
24734 SCNiN SCNiLEASTN SCNiFASTN SCNiMAX SCNiPTR
24735 SCNoN SCNoLEASTN SCNoFASTN SCNoMAX SCNoPTR
24736 SCNuN SCNuLEASTN SCNuFASTN SCNuMAX SCNuPTR
24737 SCNxN SCNxLEASTN SCNxFASTN SCNxMAX SCNxPTR
24738 intmax_t imaxabs(intmax_t j);
24739 imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
24740 intmax_t strtoimax(const char * restrict nptr,
24741 char ** restrict endptr, int base);
24742 uintmax_t strtoumax(const char * restrict nptr,
24743 char ** restrict endptr, int base);
24744 intmax_t wcstoimax(const wchar_t * restrict nptr,
24745 wchar_t ** restrict endptr, int base);
24746 uintmax_t wcstoumax(const wchar_t * restrict nptr,
24747 wchar_t ** restrict endptr, int base);
24748 </pre>
24752 <pre>
24753 and bitor not_eq xor
24754 and_eq compl or xor_eq
24755 bitand not or_eq
24756 </pre>
24760 <pre>
24761 CHAR_BIT CHAR_MAX INT_MIN ULONG_MAX
24762 SCHAR_MIN MB_LEN_MAX INT_MAX LLONG_MIN
24763 SCHAR_MAX SHRT_MIN UINT_MAX LLONG_MAX
24764 UCHAR_MAX SHRT_MAX LONG_MIN ULLONG_MAX
24765 CHAR_MIN USHRT_MAX LONG_MAX
24766 </pre>
24770 <pre>
24771 struct lconv LC_ALL LC_CTYPE LC_NUMERIC
24772 NULL LC_COLLATE LC_MONETARY LC_TIME
24773 char *setlocale(int category, const char *locale);
24774 struct lconv *localeconv(void);
24775 </pre>
24779 <!--page 498 -->
24780 <!--page 499 -->
24781 <!--page 500 -->
24782 <!--page 501 -->
24783 <!--page 502 -->
24784 <pre>
24785 float_t FP_INFINITE FP_FAST_FMAL
24786 double_t FP_NAN FP_ILOGB0
24787 HUGE_VAL FP_NORMAL FP_ILOGBNAN
24788 HUGE_VALF FP_SUBNORMAL MATH_ERRNO
24789 HUGE_VALL FP_ZERO MATH_ERREXCEPT
24790 INFINITY FP_FAST_FMA math_errhandling
24791 NAN FP_FAST_FMAF
24792 #pragma STDC FP_CONTRACT on-off-switch
24793 int fpclassify(real-floating x);
24794 int isfinite(real-floating x);
24795 int isinf(real-floating x);
24796 int isnan(real-floating x);
24797 int isnormal(real-floating x);
24798 int signbit(real-floating x);
24799 double acos(double x);
24800 float acosf(float x);
24801 long double acosl(long double x);
24802 double asin(double x);
24803 float asinf(float x);
24804 long double asinl(long double x);
24805 double atan(double x);
24806 float atanf(float x);
24807 long double atanl(long double x);
24808 double atan2(double y, double x);
24809 float atan2f(float y, float x);
24810 long double atan2l(long double y, long double x);
24811 double cos(double x);
24812 float cosf(float x);
24813 long double cosl(long double x);
24814 double sin(double x);
24815 float sinf(float x);
24816 long double sinl(long double x);
24817 double tan(double x);
24818 float tanf(float x);
24819 long double tanl(long double x);
24820 double acosh(double x);
24821 float acoshf(float x);
24822 long double acoshl(long double x);
24823 double asinh(double x);
24824 float asinhf(float x);
24825 long double asinhl(long double x);
24826 double atanh(double x);
24827 float atanhf(float x);
24828 long double atanhl(long double x);
24829 double cosh(double x);
24830 float coshf(float x);
24831 long double coshl(long double x);
24832 double sinh(double x);
24833 float sinhf(float x);
24834 long double sinhl(long double x);
24835 double tanh(double x);
24836 float tanhf(float x);
24837 long double tanhl(long double x);
24838 double exp(double x);
24839 float expf(float x);
24840 long double expl(long double x);
24841 double exp2(double x);
24842 float exp2f(float x);
24843 long double exp2l(long double x);
24844 double expm1(double x);
24845 float expm1f(float x);
24846 long double expm1l(long double x);
24847 double frexp(double value, int *exp);
24848 float frexpf(float value, int *exp);
24849 long double frexpl(long double value, int *exp);
24850 int ilogb(double x);
24851 int ilogbf(float x);
24852 int ilogbl(long double x);
24853 double ldexp(double x, int exp);
24854 float ldexpf(float x, int exp);
24855 long double ldexpl(long double x, int exp);
24856 double log(double x);
24857 float logf(float x);
24858 long double logl(long double x);
24859 double log10(double x);
24860 float log10f(float x);
24861 long double log10l(long double x);
24862 double log1p(double x);
24863 float log1pf(float x);
24864 long double log1pl(long double x);
24865 double log2(double x);
24866 float log2f(float x);
24867 long double log2l(long double x);
24868 double logb(double x);
24869 float logbf(float x);
24870 long double logbl(long double x);
24871 double modf(double value, double *iptr);
24872 float modff(float value, float *iptr);
24873 long double modfl(long double value, long double *iptr);
24874 double scalbn(double x, int n);
24875 float scalbnf(float x, int n);
24876 long double scalbnl(long double x, int n);
24877 double scalbln(double x, long int n);
24878 float scalblnf(float x, long int n);
24879 long double scalblnl(long double x, long int n);
24880 double cbrt(double x);
24881 float cbrtf(float x);
24882 long double cbrtl(long double x);
24883 double fabs(double x);
24884 float fabsf(float x);
24885 long double fabsl(long double x);
24886 double hypot(double x, double y);
24887 float hypotf(float x, float y);
24888 long double hypotl(long double x, long double y);
24889 double pow(double x, double y);
24890 float powf(float x, float y);
24891 long double powl(long double x, long double y);
24892 double sqrt(double x);
24893 float sqrtf(float x);
24894 long double sqrtl(long double x);
24895 double erf(double x);
24896 float erff(float x);
24897 long double erfl(long double x);
24898 double erfc(double x);
24899 float erfcf(float x);
24900 long double erfcl(long double x);
24901 double lgamma(double x);
24902 float lgammaf(float x);
24903 long double lgammal(long double x);
24904 double tgamma(double x);
24905 float tgammaf(float x);
24906 long double tgammal(long double x);
24907 double ceil(double x);
24908 float ceilf(float x);
24909 long double ceill(long double x);
24910 double floor(double x);
24911 float floorf(float x);
24912 long double floorl(long double x);
24913 double nearbyint(double x);
24914 float nearbyintf(float x);
24915 long double nearbyintl(long double x);
24916 double rint(double x);
24917 float rintf(float x);
24918 long double rintl(long double x);
24919 long int lrint(double x);
24920 long int lrintf(float x);
24921 long int lrintl(long double x);
24922 long long int llrint(double x);
24923 long long int llrintf(float x);
24924 long long int llrintl(long double x);
24925 double round(double x);
24926 float roundf(float x);
24927 long double roundl(long double x);
24928 long int lround(double x);
24929 long int lroundf(float x);
24930 long int lroundl(long double x);
24931 long long int llround(double x);
24932 long long int llroundf(float x);
24933 long long int llroundl(long double x);
24934 double trunc(double x);
24935 float truncf(float x);
24936 long double truncl(long double x);
24937 double fmod(double x, double y);
24938 float fmodf(float x, float y);
24939 long double fmodl(long double x, long double y);
24940 double remainder(double x, double y);
24941 float remainderf(float x, float y);
24942 long double remainderl(long double x, long double y);
24943 double remquo(double x, double y, int *quo);
24944 float remquof(float x, float y, int *quo);
24945 long double remquol(long double x, long double y,
24946 int *quo);
24947 double copysign(double x, double y);
24948 float copysignf(float x, float y);
24949 long double copysignl(long double x, long double y);
24950 double nan(const char *tagp);
24951 float nanf(const char *tagp);
24952 long double nanl(const char *tagp);
24953 double nextafter(double x, double y);
24954 float nextafterf(float x, float y);
24955 long double nextafterl(long double x, long double y);
24956 double nexttoward(double x, long double y);
24957 float nexttowardf(float x, long double y);
24958 long double nexttowardl(long double x, long double y);
24959 double fdim(double x, double y);
24960 float fdimf(float x, float y);
24961 long double fdiml(long double x, long double y);
24962 double fmax(double x, double y);
24963 float fmaxf(float x, float y);
24964 long double fmaxl(long double x, long double y);
24965 double fmin(double x, double y);
24966 float fminf(float x, float y);
24967 long double fminl(long double x, long double y);
24968 double fma(double x, double y, double z);
24969 float fmaf(float x, float y, float z);
24970 long double fmal(long double x, long double y,
24971 long double z);
24972 int isgreater(real-floating x, real-floating y);
24973 int isgreaterequal(real-floating x, real-floating y);
24974 int isless(real-floating x, real-floating y);
24975 int islessequal(real-floating x, real-floating y);
24976 int islessgreater(real-floating x, real-floating y);
24977 int isunordered(real-floating x, real-floating y);
24978 </pre>
24982 <pre>
24983 jmp_buf
24984 int setjmp(jmp_buf env);
24985 _Noreturn void longjmp(jmp_buf env, int val);
24986 </pre>
24990 <!--page 503 -->
24991 <pre>
24992 sig_atomic_t SIG_IGN SIGILL SIGTERM
24993 SIG_DFL SIGABRT SIGINT
24994 SIG_ERR SIGFPE SIGSEGV
24995 void (*signal(int sig, void (*func)(int)))(int);
24996 int raise(int sig);
24997 </pre>
25001 <pre>
25002 alignas
25003 __alignas_is_defined
25004 </pre>
25008 <pre>
25009 va_list
25010 type va_arg(va_list ap, type);
25011 void va_copy(va_list dest, va_list src);
25012 void va_end(va_list ap);
25013 void va_start(va_list ap, parmN);
25014 </pre>
25018 <!--page 504 -->
25019 <!--page 505 -->
25020 <pre>
25021 ATOMIC_BOOL_LOCK_FREE atomic_uint
25022 ATOMIC_CHAR_LOCK_FREE atomic_long
25023 ATOMIC_CHAR16_T_LOCK_FREE atomic_ulong
25024 ATOMIC_CHAR32_T_LOCK_FREE atomic_llong
25025 ATOMIC_WCHAR_T_LOCK_FREE atomic_ullong
25026 ATOMIC_SHORT_LOCK_FREE atomic_char16_t
25027 ATOMIC_INT_LOCK_FREE atomic_char32_t
25028 ATOMIC_LONG_LOCK_FREE atomic_wchar_t
25029 ATOMIC_LLONG_LOCK_FREE atomic_int_least8_t
25030 ATOMIC_POINTER_LOCK_FREE atomic_uint_least8_t
25031 ATOMIC_FLAG_INIT atomic_int_least16_t
25032 memory_order atomic_uint_least16_t
25033 atomic_flag atomic_int_least32_t
25034 memory_order_relaxed atomic_uint_least32_t
25035 memory_order_consume atomic_int_least64_t
25036 memory_order_acquire atomic_uint_least64_t
25037 memory_order_release atomic_int_fast8_t
25038 memory_order_acq_rel atomic_uint_fast8_t
25039 memory_order_seq_cst atomic_int_fast16_t
25040 atomic_bool atomic_uint_fast16_t
25041 atomic_char atomic_int_fast32_t
25042 atomic_schar atomic_uint_fast32_t
25043 atomic_uchar atomic_int_fast64_t
25044 atomic_short atomic_uint_fast64_t
25045 atomic_ushort atomic_intptr_t
25046 atomic_int atomic_uintptr_t
25047 atomic_size_t atomic_intmax_t
25048 atomic_ptrdiff_t atomic_uintmax_t
25049 #define ATOMIC_VAR_INIT(C value)
25050 void atomic_init(volatile A *obj, C value);
25051 type kill_dependency(type y);
25052 void atomic_thread_fence(memory_order order);
25053 void atomic_signal_fence(memory_order order);
25054 _Bool atomic_is_lock_free(const volatile A *obj);
25055 void atomic_store(volatile A *object, C desired);
25056 void atomic_store_explicit(volatile A *object,
25057 C desired, memory_order order);
25058 C atomic_load(volatile A *object);
25059 C atomic_load_explicit(volatile A *object,
25060 memory_order order);
25061 C atomic_exchange(volatile A *object, C desired);
25062 C atomic_exchange_explicit(volatile A *object,
25063 C desired, memory_order order);
25064 _Bool atomic_compare_exchange_strong(volatile A *object,
25065 C *expected, C desired);
25066 _Bool atomic_compare_exchange_strong_explicit(
25067 volatile A *object, C *expected, C desired,
25068 memory_order success, memory_order failure);
25069 _Bool atomic_compare_exchange_weak(volatile A *object,
25070 C *expected, C desired);
25071 _Bool atomic_compare_exchange_weak_explicit(
25072 volatile A *object, C *expected, C desired,
25073 memory_order success, memory_order failure);
25074 C atomic_fetch_key(volatile A *object, M operand);
25075 C atomic_fetch_key_explicit(volatile A *object,
25076 M operand, memory_order order);
25077 _Bool atomic_flag_test_and_set(
25078 volatile atomic_flag *object);
25079 _Bool atomic_flag_test_and_set_explicit(
25080 volatile atomic_flag *object, memory_order order);
25081 void atomic_flag_clear(volatile atomic_flag *object);
25082 void atomic_flag_clear_explicit(
25083 volatile atomic_flag *object, memory_order order);
25084 </pre>
25088 <pre>
25089 bool
25090 true
25091 false
25092 __bool_true_false_are_defined
25093 </pre>
25097 <pre>
25098 ptrdiff_t max_align_t NULL
25099 size_t wchar_t
25100 offsetof(type, member-designator)
25101 __STDC_WANT_LIB_EXT1__
25102 rsize_t
25103 </pre>
25107 <!--page 506 -->
25108 <pre>
25109 intN_t INT_LEASTN_MIN PTRDIFF_MAX
25110 uintN_t INT_LEASTN_MAX SIG_ATOMIC_MIN
25111 int_leastN_t UINT_LEASTN_MAX SIG_ATOMIC_MAX
25112 uint_leastN_t INT_FASTN_MIN SIZE_MAX
25113 int_fastN_t INT_FASTN_MAX WCHAR_MIN
25114 uint_fastN_t UINT_FASTN_MAX WCHAR_MAX
25115 intptr_t INTPTR_MIN WINT_MIN
25116 uintptr_t INTPTR_MAX WINT_MAX
25117 intmax_t UINTPTR_MAX INTN_C(value)
25118 uintmax_t INTMAX_MIN UINTN_C(value)
25119 INTN_MIN INTMAX_MAX INTMAX_C(value)
25120 INTN_MAX UINTMAX_MAX UINTMAX_C(value)
25121 UINTN_MAX PTRDIFF_MIN
25122 __STDC_WANT_LIB_EXT1__
25123 RSIZE_MAX
25124 </pre>
25128 <!--page 507 -->
25129 <!--page 508 -->
25130 <!--page 509 -->
25131 <pre>
25132 size_t _IOLBF FILENAME_MAX TMP_MAX
25133 FILE _IONBF L_tmpnam stderr
25134 fpos_t BUFSIZ SEEK_CUR stdin
25135 NULL EOF SEEK_END stdout
25136 _IOFBF FOPEN_MAX SEEK_SET
25137 int remove(const char *filename);
25138 int rename(const char *old, const char *new);
25139 FILE *tmpfile(void);
25140 char *tmpnam(char *s);
25141 int fclose(FILE *stream);
25142 int fflush(FILE *stream);
25143 FILE *fopen(const char * restrict filename,
25144 const char * restrict mode);
25145 FILE *freopen(const char * restrict filename,
25146 const char * restrict mode,
25147 FILE * restrict stream);
25148 void setbuf(FILE * restrict stream,
25149 char * restrict buf);
25150 int setvbuf(FILE * restrict stream,
25151 char * restrict buf,
25152 int mode, size_t size);
25153 int fprintf(FILE * restrict stream,
25154 const char * restrict format, ...);
25155 int fscanf(FILE * restrict stream,
25156 const char * restrict format, ...);
25157 int printf(const char * restrict format, ...);
25158 int scanf(const char * restrict format, ...);
25159 int snprintf(char * restrict s, size_t n,
25160 const char * restrict format, ...);
25161 int sprintf(char * restrict s,
25162 const char * restrict format, ...);
25163 int sscanf(const char * restrict s,
25164 const char * restrict format, ...);
25165 int vfprintf(FILE * restrict stream,
25166 const char * restrict format, va_list arg);
25167 int vfscanf(FILE * restrict stream,
25168 const char * restrict format, va_list arg);
25169 int vprintf(const char * restrict format, va_list arg);
25170 int vscanf(const char * restrict format, va_list arg);
25171 int vsnprintf(char * restrict s, size_t n,
25172 const char * restrict format, va_list arg);
25173 int vsprintf(char * restrict s,
25174 const char * restrict format, va_list arg);
25175 int vsscanf(const char * restrict s,
25176 const char * restrict format, va_list arg);
25177 int fgetc(FILE *stream);
25178 char *fgets(char * restrict s, int n,
25179 FILE * restrict stream);
25180 int fputc(int c, FILE *stream);
25181 int fputs(const char * restrict s,
25182 FILE * restrict stream);
25183 int getc(FILE *stream);
25184 int getchar(void);
25185 int putc(int c, FILE *stream);
25186 int putchar(int c);
25187 int puts(const char *s);
25188 int ungetc(int c, FILE *stream);
25189 size_t fread(void * restrict ptr,
25190 size_t size, size_t nmemb,
25191 FILE * restrict stream);
25192 size_t fwrite(const void * restrict ptr,
25193 size_t size, size_t nmemb,
25194 FILE * restrict stream);
25195 int fgetpos(FILE * restrict stream,
25196 fpos_t * restrict pos);
25197 int fseek(FILE *stream, long int offset, int whence);
25198 int fsetpos(FILE *stream, const fpos_t *pos);
25199 long int ftell(FILE *stream);
25200 void rewind(FILE *stream);
25201 void clearerr(FILE *stream);
25202 int feof(FILE *stream);
25203 int ferror(FILE *stream);
25204 void perror(const char *s);
25205 __STDC_WANT_LIB_EXT1__
25206 L_tmpnam_s TMP_MAX_S errno_t rsize_t
25207 errno_t tmpfile_s(FILE * restrict * restrict streamptr);
25208 errno_t tmpnam_s(char *s, rsize_t maxsize);
25209 errno_t fopen_s(FILE * restrict * restrict streamptr,
25210 const char * restrict filename,
25211 const char * restrict mode);
25212 errno_t freopen_s(FILE * restrict * restrict newstreamptr,
25213 const char * restrict filename,
25214 const char * restrict mode,
25215 FILE * restrict stream);
25216 int fprintf_s(FILE * restrict stream,
25217 const char * restrict format, ...);
25218 int fscanf_s(FILE * restrict stream,
25219 const char * restrict format, ...);
25220 int printf_s(const char * restrict format, ...);
25221 int scanf_s(const char * restrict format, ...);
25222 int snprintf_s(char * restrict s, rsize_t n,
25223 const char * restrict format, ...);
25224 int sprintf_s(char * restrict s, rsize_t n,
25225 const char * restrict format, ...);
25226 int sscanf_s(const char * restrict s,
25227 const char * restrict format, ...);
25228 int vfprintf_s(FILE * restrict stream,
25229 const char * restrict format,
25230 va_list arg);
25231 int vfscanf_s(FILE * restrict stream,
25232 const char * restrict format,
25233 va_list arg);
25234 int vprintf_s(const char * restrict format,
25235 va_list arg);
25236 int vscanf_s(const char * restrict format,
25237 va_list arg);
25238 int vsnprintf_s(char * restrict s, rsize_t n,
25239 const char * restrict format,
25240 va_list arg);
25241 int vsprintf_s(char * restrict s, rsize_t n,
25242 const char * restrict format,
25243 va_list arg);
25244 int vsscanf_s(const char * restrict s,
25245 const char * restrict format,
25246 va_list arg);
25247 char *gets_s(char *s, rsize_t n);
25248 </pre>
25252 <!--page 510 -->
25253 <!--page 511 -->
25254 <pre>
25255 size_t ldiv_t EXIT_FAILURE MB_CUR_MAX
25256 wchar_t lldiv_t EXIT_SUCCESS
25257 div_t NULL RAND_MAX
25258 double atof(const char *nptr);
25259 int atoi(const char *nptr);
25260 long int atol(const char *nptr);
25261 long long int atoll(const char *nptr);
25262 double strtod(const char * restrict nptr,
25263 char ** restrict endptr);
25264 float strtof(const char * restrict nptr,
25265 char ** restrict endptr);
25266 long double strtold(const char * restrict nptr,
25267 char ** restrict endptr);
25268 long int strtol(const char * restrict nptr,
25269 char ** restrict endptr, int base);
25270 long long int strtoll(const char * restrict nptr,
25271 char ** restrict endptr, int base);
25272 unsigned long int strtoul(
25273 const char * restrict nptr,
25274 char ** restrict endptr, int base);
25275 unsigned long long int strtoull(
25276 const char * restrict nptr,
25277 char ** restrict endptr, int base);
25278 int rand(void);
25279 void srand(unsigned int seed);
25280 void *aligned_alloc(size_t alignment, size_t size);
25281 void *calloc(size_t nmemb, size_t size);
25282 void free(void *ptr);
25283 void *malloc(size_t size);
25284 void *realloc(void *ptr, size_t size);
25285 _Noreturn void abort(void);
25286 int atexit(void (*func)(void));
25287 int at_quick_exit(void (*func)(void));
25288 _Noreturn void exit(int status);
25289 _Noreturn void _Exit(int status);
25290 char *getenv(const char *name);
25291 _Noreturn void quick_exit(int status);
25292 int system(const char *string);
25293 void *bsearch(const void *key, const void *base,
25294 size_t nmemb, size_t size,
25295 int (*compar)(const void *, const void *));
25296 void qsort(void *base, size_t nmemb, size_t size,
25297 int (*compar)(const void *, const void *));
25298 int abs(int j);
25299 long int labs(long int j);
25300 long long int llabs(long long int j);
25301 div_t div(int numer, int denom);
25302 ldiv_t ldiv(long int numer, long int denom);
25303 lldiv_t lldiv(long long int numer,
25304 long long int denom);
25305 int mblen(const char *s, size_t n);
25306 int mbtowc(wchar_t * restrict pwc,
25307 const char * restrict s, size_t n);
25308 int wctomb(char *s, wchar_t wchar);
25309 size_t mbstowcs(wchar_t * restrict pwcs,
25310 const char * restrict s, size_t n);
25311 size_t wcstombs(char * restrict s,
25312 const wchar_t * restrict pwcs, size_t n);
25313 __STDC_WANT_LIB_EXT1__
25314 errno_t
25315 rsize_t
25316 constraint_handler_t
25317 constraint_handler_t set_constraint_handler_s(
25318 constraint_handler_t handler);
25319 void abort_handler_s(
25320 const char * restrict msg,
25321 void * restrict ptr,
25322 errno_t error);
25323 void ignore_handler_s(
25324 const char * restrict msg,
25325 void * restrict ptr,
25326 errno_t error);
25327 errno_t getenv_s(size_t * restrict len,
25328 char * restrict value, rsize_t maxsize,
25329 const char * restrict name);
25330 void *bsearch_s(const void *key, const void *base,
25331 rsize_t nmemb, rsize_t size,
25332 int (*compar)(const void *k, const void *y,
25333 void *context),
25334 void *context);
25335 errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
25336 int (*compar)(const void *x, const void *y,
25337 void *context),
25338 void *context);
25339 errno_t wctomb_s(int * restrict status,
25340 char * restrict s,
25341 rsize_t smax,
25342 wchar_t wc);
25343 errno_t mbstowcs_s(size_t * restrict retval,
25344 wchar_t * restrict dst, rsize_t dstmax,
25345 const char * restrict src, rsize_t len);
25346 errno_t wcstombs_s(size_t * restrict retval,
25347 char * restrict dst, rsize_t dstmax,
25348 const wchar_t * restrict src, rsize_t len);
25349 </pre>
25353 <pre>
25354 noreturn
25355 </pre>
25359 <!--page 512 -->
25360 <!--page 513 -->
25361 <pre>
25362 size_t
25363 NULL
25364 void *memcpy(void * restrict s1,
25365 const void * restrict s2, size_t n);
25366 void *memmove(void *s1, const void *s2, size_t n);
25367 char *strcpy(char * restrict s1,
25368 const char * restrict s2);
25369 char *strncpy(char * restrict s1,
25370 const char * restrict s2, size_t n);
25371 char *strcat(char * restrict s1,
25372 const char * restrict s2);
25373 char *strncat(char * restrict s1,
25374 const char * restrict s2, size_t n);
25375 int memcmp(const void *s1, const void *s2, size_t n);
25376 int strcmp(const char *s1, const char *s2);
25377 int strcoll(const char *s1, const char *s2);
25378 int strncmp(const char *s1, const char *s2, size_t n);
25379 size_t strxfrm(char * restrict s1,
25380 const char * restrict s2, size_t n);
25381 void *memchr(const void *s, int c, size_t n);
25382 char *strchr(const char *s, int c);
25383 size_t strcspn(const char *s1, const char *s2);
25384 char *strpbrk(const char *s1, const char *s2);
25385 char *strrchr(const char *s, int c);
25386 size_t strspn(const char *s1, const char *s2);
25387 char *strstr(const char *s1, const char *s2);
25388 char *strtok(char * restrict s1,
25389 const char * restrict s2);
25390 void *memset(void *s, int c, size_t n);
25391 char *strerror(int errnum);
25392 size_t strlen(const char *s);
25393 __STDC_WANT_LIB_EXT1__
25394 errno_t
25395 rsize_t
25396 errno_t memcpy_s(void * restrict s1, rsize_t s1max,
25397 const void * restrict s2, rsize_t n);
25398 errno_t memmove_s(void *s1, rsize_t s1max,
25399 const void *s2, rsize_t n);
25400 errno_t strcpy_s(char * restrict s1,
25401 rsize_t s1max,
25402 const char * restrict s2);
25403 errno_t strncpy_s(char * restrict s1,
25404 rsize_t s1max,
25405 const char * restrict s2,
25406 rsize_t n);
25407 errno_t strcat_s(char * restrict s1,
25408 rsize_t s1max,
25409 const char * restrict s2);
25410 errno_t strncat_s(char * restrict s1,
25411 rsize_t s1max,
25412 const char * restrict s2,
25413 rsize_t n);
25414 char *strtok_s(char * restrict s1,
25415 rsize_t * restrict s1max,
25416 const char * restrict s2,
25417 char ** restrict ptr);
25418 errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)
25419 errno_t strerror_s(char *s, rsize_t maxsize,
25420 errno_t errnum);
25421 size_t strerrorlen_s(errno_t errnum);
25422 size_t strnlen_s(const char *s, size_t maxsize);
25423 </pre>
25427 <pre>
25428 acos sqrt fmod nextafter
25429 asin fabs frexp nexttoward
25430 atan atan2 hypot remainder
25431 acosh cbrt ilogb remquo
25432 asinh ceil ldexp rint
25433 atanh copysign lgamma round
25434 cos erf llrint scalbn
25435 sin erfc llround scalbln
25436 tan exp2 log10 tgamma
25437 cosh expm1 log1p trunc
25438 sinh fdim log2 carg
25439 tanh floor logb cimag
25440 exp fma lrint conj
25441 log fmax lround cproj
25442 pow fmin nearbyint creal
25443 </pre>
25447 <!--page 514 -->
25448 <pre>
25449 thread_local once_flag
25450 ONCE_FLAG_INIT mtx_plain
25451 TSS_DTOR_ITERATIONS mtx_recursive
25452 cnd_t mtx_timed
25453 thrd_t thrd_timedout
25454 tss_t thrd_success
25455 mtx_t thrd_busy
25456 tss_dtor_t thrd_error
25457 thrd_start_t thrd_nomem
25458 void call_once(once_flag *flag, void (*func)(void));
25459 int cnd_broadcast(cnd_t *cond);
25460 void cnd_destroy(cnd_t *cond);
25461 int cnd_init(cnd_t *cond);
25462 int cnd_signal(cnd_t *cond);
25463 int cnd_timedwait(cnd_t *restrict cond,
25464 mtx_t *restrict mtx,
25465 const struct timespec *restrict ts);
25466 int cnd_wait(cnd_t *cond, mtx_t *mtx);
25467 void mtx_destroy(mtx_t *mtx);
25468 int mtx_init(mtx_t *mtx, int type);
25469 int mtx_lock(mtx_t *mtx);
25470 int mtx_timedlock(mtx_t *restrict mtx,
25471 const struct timespec *restrict ts);
25472 int mtx_trylock(mtx_t *mtx);
25473 int mtx_unlock(mtx_t *mtx);
25474 int thrd_create(thrd_t *thr, thrd_start_t func,
25475 void *arg);
25476 thrd_t thrd_current(void);
25477 int thrd_detach(thrd_t thr);
25478 int thrd_equal(thrd_t thr0, thrd_t thr1);
25479 _Noreturn void thrd_exit(int res);
25480 int thrd_join(thrd_t thr, int *res);
25481 int thrd_sleep(const struct timespec *duration,
25482 struct timespec *remaining);
25483 void thrd_yield(void);
25484 int tss_create(tss_t *key, tss_dtor_t dtor);
25485 void tss_delete(tss_t key);
25486 void *tss_get(tss_t key);
25487 int tss_set(tss_t key, void *val);
25488 </pre>
25492 <!--page 515 -->
25493 <pre>
25494 NULL size_t struct timespec
25495 CLOCKS_PER_SEC clock_t struct tm
25496 TIME_UTC time_t
25497 clock_t clock(void);
25498 double difftime(time_t time1, time_t time0);
25499 time_t mktime(struct tm *timeptr);
25500 time_t time(time_t *timer);
25501 int timespec_get(timespec *ts, int base);
25502 char *asctime(const struct tm *timeptr);
25503 char *ctime(const time_t *timer);
25504 struct tm *gmtime(const time_t *timer);
25505 struct tm *localtime(const time_t *timer);
25506 size_t strftime(char * restrict s,
25507 size_t maxsize,
25508 const char * restrict format,
25509 const struct tm * restrict timeptr);
25510 __STDC_WANT_LIB_EXT1__
25511 errno_t
25512 rsize_t
25513 errno_t asctime_s(char *s, rsize_t maxsize,
25514 const struct tm *timeptr);
25515 errno_t ctime_s(char *s, rsize_t maxsize,
25516 const time_t *timer);
25517 struct tm *gmtime_s(const time_t * restrict timer,
25518 struct tm * restrict result);
25519 struct tm *localtime_s(const time_t * restrict timer,
25520 struct tm * restrict result);
25521 </pre>
25525 <pre>
25526 mbstate_t size_t char16_t char32_t
25527 size_t mbrtoc16(char16_t * restrict pc16,
25528 const char * restrict s, size_t n,
25529 mbstate_t * restrict ps);
25530 size_t c16rtomb(char * restrict s, char16_t c16,
25531 mbstate_t * restrict ps);
25532 size_t mbrtoc32(char32_t * restrict pc32,
25533 const char * restrict s, size_t n,
25534 mbstate_t * restrict ps);
25535 size_t c32rtomb(char * restrict s, char32_t c32,
25536 mbstate_t * restrict ps);
25537 </pre>
25540 <h3><a name="B.28" href="#B.28">B.28 Extended multibyte/wide character utilities <wchar.h></a></h3>
25541 <!--page 516 -->
25542 <!--page 517 -->
25543 <!--page 518 -->
25544 <!--page 519 -->
25545 <!--page 520 -->
25546 <pre>
25547 wchar_t wint_t WCHAR_MAX
25548 size_t struct tm WCHAR_MIN
25549 mbstate_t NULL WEOF
25550 int fwprintf(FILE * restrict stream,
25551 const wchar_t * restrict format, ...);
25552 int fwscanf(FILE * restrict stream,
25553 const wchar_t * restrict format, ...);
25554 int swprintf(wchar_t * restrict s, size_t n,
25555 const wchar_t * restrict format, ...);
25556 int swscanf(const wchar_t * restrict s,
25557 const wchar_t * restrict format, ...);
25558 int vfwprintf(FILE * restrict stream,
25559 const wchar_t * restrict format, va_list arg);
25560 int vfwscanf(FILE * restrict stream,
25561 const wchar_t * restrict format, va_list arg);
25562 int vswprintf(wchar_t * restrict s, size_t n,
25563 const wchar_t * restrict format, va_list arg);
25564 int vswscanf(const wchar_t * restrict s,
25565 const wchar_t * restrict format, va_list arg);
25566 int vwprintf(const wchar_t * restrict format,
25567 va_list arg);
25568 int vwscanf(const wchar_t * restrict format,
25569 va_list arg);
25570 int wprintf(const wchar_t * restrict format, ...);
25571 int wscanf(const wchar_t * restrict format, ...);
25572 wint_t fgetwc(FILE *stream);
25573 wchar_t *fgetws(wchar_t * restrict s, int n,
25574 FILE * restrict stream);
25575 wint_t fputwc(wchar_t c, FILE *stream);
25576 int fputws(const wchar_t * restrict s,
25577 FILE * restrict stream);
25578 int fwide(FILE *stream, int mode);
25579 wint_t getwc(FILE *stream);
25580 wint_t getwchar(void);
25581 wint_t putwc(wchar_t c, FILE *stream);
25582 wint_t putwchar(wchar_t c);
25583 wint_t ungetwc(wint_t c, FILE *stream);
25584 double wcstod(const wchar_t * restrict nptr,
25585 wchar_t ** restrict endptr);
25586 float wcstof(const wchar_t * restrict nptr,
25587 wchar_t ** restrict endptr);
25588 long double wcstold(const wchar_t * restrict nptr,
25589 wchar_t ** restrict endptr);
25590 long int wcstol(const wchar_t * restrict nptr,
25591 wchar_t ** restrict endptr, int base);
25592 long long int wcstoll(const wchar_t * restrict nptr,
25593 wchar_t ** restrict endptr, int base);
25594 unsigned long int wcstoul(const wchar_t * restrict nptr,
25595 wchar_t ** restrict endptr, int base);
25596 unsigned long long int wcstoull(
25597 const wchar_t * restrict nptr,
25598 wchar_t ** restrict endptr, int base);
25599 wchar_t *wcscpy(wchar_t * restrict s1,
25600 const wchar_t * restrict s2);
25601 wchar_t *wcsncpy(wchar_t * restrict s1,
25602 const wchar_t * restrict s2, size_t n);
25603 wchar_t *wmemcpy(wchar_t * restrict s1,
25604 const wchar_t * restrict s2, size_t n);
25605 wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
25606 size_t n);
25607 wchar_t *wcscat(wchar_t * restrict s1,
25608 const wchar_t * restrict s2);
25609 wchar_t *wcsncat(wchar_t * restrict s1,
25610 const wchar_t * restrict s2, size_t n);
25611 int wcscmp(const wchar_t *s1, const wchar_t *s2);
25612 int wcscoll(const wchar_t *s1, const wchar_t *s2);
25613 int wcsncmp(const wchar_t *s1, const wchar_t *s2,
25614 size_t n);
25615 size_t wcsxfrm(wchar_t * restrict s1,
25616 const wchar_t * restrict s2, size_t n);
25617 int wmemcmp(const wchar_t *s1, const wchar_t *s2,
25618 size_t n);
25619 wchar_t *wcschr(const wchar_t *s, wchar_t c);
25620 size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
25621 wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
25622 wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
25623 size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
25624 wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
25625 wchar_t *wcstok(wchar_t * restrict s1,
25626 const wchar_t * restrict s2,
25627 wchar_t ** restrict ptr);
25628 wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
25629 size_t wcslen(const wchar_t *s);
25630 wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
25631 size_t wcsftime(wchar_t * restrict s, size_t maxsize,
25632 const wchar_t * restrict format,
25633 const struct tm * restrict timeptr);
25634 wint_t btowc(int c);
25635 int wctob(wint_t c);
25636 int mbsinit(const mbstate_t *ps);
25637 size_t mbrlen(const char * restrict s, size_t n,
25638 mbstate_t * restrict ps);
25639 size_t mbrtowc(wchar_t * restrict pwc,
25640 const char * restrict s, size_t n,
25641 mbstate_t * restrict ps);
25642 size_t wcrtomb(char * restrict s, wchar_t wc,
25643 mbstate_t * restrict ps);
25644 size_t mbsrtowcs(wchar_t * restrict dst,
25645 const char ** restrict src, size_t len,
25646 mbstate_t * restrict ps);
25647 size_t wcsrtombs(char * restrict dst,
25648 const wchar_t ** restrict src, size_t len,
25649 mbstate_t * restrict ps);
25650 __STDC_WANT_LIB_EXT1__
25651 errno_t
25652 rsize_t
25653 int fwprintf_s(FILE * restrict stream,
25654 const wchar_t * restrict format, ...);
25655 int fwscanf_s(FILE * restrict stream,
25656 const wchar_t * restrict format, ...);
25657 int snwprintf_s(wchar_t * restrict s,
25658 rsize_t n,
25659 const wchar_t * restrict format, ...);
25660 int swprintf_s(wchar_t * restrict s, rsize_t n,
25661 const wchar_t * restrict format, ...);
25662 int swscanf_s(const wchar_t * restrict s,
25663 const wchar_t * restrict format, ...);
25664 int vfwprintf_s(FILE * restrict stream,
25665 const wchar_t * restrict format,
25666 va_list arg);
25667 int vfwscanf_s(FILE * restrict stream,
25668 const wchar_t * restrict format, va_list arg);
25669 int vsnwprintf_s(wchar_t * restrict s,
25670 rsize_t n,
25671 const wchar_t * restrict format,
25672 va_list arg);
25673 int vswprintf_s(wchar_t * restrict s,
25674 rsize_t n,
25675 const wchar_t * restrict format,
25676 va_list arg);
25677 int vswscanf_s(const wchar_t * restrict s,
25678 const wchar_t * restrict format,
25679 va_list arg);
25680 int vwprintf_s(const wchar_t * restrict format,
25681 va_list arg);
25682 int vwscanf_s(const wchar_t * restrict format,
25683 va_list arg);
25684 int wprintf_s(const wchar_t * restrict format, ...);
25685 int wscanf_s(const wchar_t * restrict format, ...);
25686 errno_t wcscpy_s(wchar_t * restrict s1,
25687 rsize_t s1max,
25688 const wchar_t * restrict s2);
25689 errno_t wcsncpy_s(wchar_t * restrict s1,
25690 rsize_t s1max,
25691 const wchar_t * restrict s2,
25692 rsize_t n);
25693 errno_t wmemcpy_s(wchar_t * restrict s1,
25694 rsize_t s1max,
25695 const wchar_t * restrict s2,
25696 rsize_t n);
25697 errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
25698 const wchar_t *s2, rsize_t n);
25699 errno_t wcscat_s(wchar_t * restrict s1,
25700 rsize_t s1max,
25701 const wchar_t * restrict s2);
25702 errno_t wcsncat_s(wchar_t * restrict s1,
25703 rsize_t s1max,
25704 const wchar_t * restrict s2,
25705 rsize_t n);
25706 wchar_t *wcstok_s(wchar_t * restrict s1,
25707 rsize_t * restrict s1max,
25708 const wchar_t * restrict s2,
25709 wchar_t ** restrict ptr);
25710 size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
25711 errno_t wcrtomb_s(size_t * restrict retval,
25712 char * restrict s, rsize_t smax,
25713 wchar_t wc, mbstate_t * restrict ps);
25714 errno_t mbsrtowcs_s(size_t * restrict retval,
25715 wchar_t * restrict dst, rsize_t dstmax,
25716 const char ** restrict src, rsize_t len,
25717 mbstate_t * restrict ps);
25718 errno_t wcsrtombs_s(size_t * restrict retval,
25719 char * restrict dst, rsize_t dstmax,
25720 const wchar_t ** restrict src, rsize_t len,
25721 mbstate_t * restrict ps);
25722 </pre>
25725 <h3><a name="B.29" href="#B.29">B.29 Wide character classification and mapping utilities <wctype.h></a></h3>
25726 <!--page 521 -->
25727 <pre>
25728 wint_t wctrans_t wctype_t WEOF
25729 int iswalnum(wint_t wc);
25730 int iswalpha(wint_t wc);
25731 int iswblank(wint_t wc);
25732 int iswcntrl(wint_t wc);
25733 int iswdigit(wint_t wc);
25734 int iswgraph(wint_t wc);
25735 int iswlower(wint_t wc);
25736 int iswprint(wint_t wc);
25737 int iswpunct(wint_t wc);
25738 int iswspace(wint_t wc);
25739 int iswupper(wint_t wc);
25740 int iswxdigit(wint_t wc);
25741 int iswctype(wint_t wc, wctype_t desc);
25742 wctype_t wctype(const char *property);
25743 wint_t towlower(wint_t wc);
25744 wint_t towupper(wint_t wc);
25745 wint_t towctrans(wint_t wc, wctrans_t desc);
25746 wctrans_t wctrans(const char *property);
25747 </pre>
25751 <pre>
25752 (informative)
25753 Sequence points
25754 </pre>
25757 <ul>
25758 <li> Between the evaluations of the function designator and actual arguments in a function
25760 <li> Between the evaluations of the first and second operands of the following operators:
25761 logical AND && (<a href="#6.5.13">6.5.13</a>); logical OR || (<a href="#6.5.14">6.5.14</a>); comma , (<a href="#6.5.17">6.5.17</a>).
25762 <li> Between the evaluations of the first operand of the conditional ? : operator and
25765 <li> Between the evaluation of a full expression and the next full expression to be
25766 evaluated. The following are full expressions: an initializer that is not part of a
25767 compound literal (<a href="#6.7.9">6.7.9</a>); the expression in an expression statement (<a href="#6.8.3">6.8.3</a>); the
25768 controlling expression of a selection statement (if or switch) (<a href="#6.8.4">6.8.4</a>); the
25769 controlling expression of a while or do statement (<a href="#6.8.5">6.8.5</a>); each of the (optional)
25770 expressions of a for statement (<a href="#6.8.5.3">6.8.5.3</a>); the (optional) expression in a return
25773 <li> After the actions associated with each formatted input/output function conversion
25775 <li> Immediately before and immediately after each call to a comparison function, and
25776 also between any call to a comparison function and any movement of the objects
25778 <!--page 522 -->
25779 </ul>
25783 <pre>
25784 (normative)
25785 Universal character names for identifiers
25786 </pre>
25788 This clause lists the hexadecimal code values that are valid in universal character names
25789 in identifiers.
25805 3040-D7FF
25807 F900-FD3D, FD40-FDCF, FDF0-FE44, FE47-FFFD
25811 B0000-BFFFD, C0000-CFFFD, D0000-DFFFD, E0000-EFFFD
25817 <!--page 523 -->
25821 <pre>
25822 (informative)
25823 Implementation limits
25824 </pre>
25826 The contents of the header <a href="#7.10"><limits.h></a> are given below, in alphabetical order. The
25827 minimum magnitudes shown shall be replaced by implementation-defined magnitudes
25828 with the same sign. The values shall all be constant expressions suitable for use in #if
25829 preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
25830 <pre>
25831 #define CHAR_BIT 8
25832 #define CHAR_MAX UCHAR_MAX or SCHAR_MAX
25833 #define CHAR_MIN 0 or SCHAR_MIN
25834 #define INT_MAX +32767
25835 #define INT_MIN -32767
25836 #define LONG_MAX +2147483647
25837 #define LONG_MIN -2147483647
25838 #define LLONG_MAX +9223372036854775807
25839 #define LLONG_MIN -9223372036854775807
25840 #define MB_LEN_MAX 1
25841 #define SCHAR_MAX +127
25842 #define SCHAR_MIN -127
25843 #define SHRT_MAX +32767
25844 #define SHRT_MIN -32767
25845 #define UCHAR_MAX 255
25846 #define USHRT_MAX 65535
25847 #define UINT_MAX 65535
25848 #define ULONG_MAX 4294967295
25849 #define ULLONG_MAX 18446744073709551615
25850 </pre>
25852 The contents of the header <a href="#7.7"><float.h></a> are given below. All integer values, except
25853 FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
25854 directives; all floating values shall be constant expressions. The components are
25857 The values given in the following list shall be replaced by implementation-defined
25858 expressions:
25859 <pre>
25860 #define FLT_EVAL_METHOD
25861 #define FLT_ROUNDS
25862 </pre>
25864 The values given in the following list shall be replaced by implementation-defined
25865 constant expressions that are greater or equal in magnitude (absolute value) to those
25866 shown, with the same sign:
25867 <!--page 524 -->
25868 <pre>
25869 #define DLB_DECIMAL_DIG 10
25870 #define DBL_DIG 10
25871 #define DBL_MANT_DIG
25872 #define DBL_MAX_10_EXP +37
25873 #define DBL_MAX_EXP
25874 #define DBL_MIN_10_EXP -37
25875 #define DBL_MIN_EXP
25876 #define DECIMAL_DIG 10
25877 #define FLT_DECIMAL_DIG 6
25878 #define FLT_DIG 6
25879 #define FLT_MANT_DIG
25880 #define FLT_MAX_10_EXP +37
25881 #define FLT_MAX_EXP
25882 #define FLT_MIN_10_EXP -37
25883 #define FLT_MIN_EXP
25884 #define FLT_RADIX 2
25885 #define LDLB_DECIMAL_DIG 10
25886 #define LDBL_DIG 10
25887 #define LDBL_MANT_DIG
25888 #define LDBL_MAX_10_EXP +37
25889 #define LDBL_MAX_EXP
25890 #define LDBL_MIN_10_EXP -37
25891 #define LDBL_MIN_EXP
25892 </pre>
25894 The values given in the following list shall be replaced by implementation-defined
25895 constant expressions with values that are greater than or equal to those shown:
25896 <pre>
25897 #define DBL_MAX 1E+37
25898 #define FLT_MAX 1E+37
25899 #define LDBL_MAX 1E+37
25900 </pre>
25902 The values given in the following list shall be replaced by implementation-defined
25903 constant expressions with (positive) values that are less than or equal to those shown:
25904 <!--page 525 -->
25905 <pre>
25906 #define DBL_EPSILON 1E-9
25907 #define DBL_MIN 1E-37
25908 #define FLT_EPSILON 1E-5
25909 #define FLT_MIN 1E-37
25910 #define LDBL_EPSILON 1E-9
25911 #define LDBL_MIN 1E-37
25912 </pre>
25916 <pre>
25917 (normative)
25918 IEC 60559 floating-point arithmetic
25919 </pre>
25924 This annex specifies C language support for the IEC 60559 floating-point standard. The
25925 IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for
25930 dependencies on radix and word length. IEC 60559 generally refers to the floating-point
25932 defines __STDC_IEC_559__ shall conform to the specifications in this annex.<sup><a href="#note356"><b>356)</b></a></sup>
25933 Where a binding between the C language and IEC 60559 is indicated, the
25934 IEC 60559-specified behavior is adopted by reference, unless stated otherwise. Since
25935 negative and positive infinity are representable in IEC 60559 formats, all real numbers lie
25936 within the range of representable values.
25939 <p><small><a name="note356" href="#note356">356)</a> Implementations that do not define __STDC_IEC_559__ are not required to conform to these
25940 specifications.
25941 </small>
25946 The C floating types match the IEC 60559 formats as follows:
25947 <ul>
25950 <li> The long double type matches an IEC 60559 extended format,<sup><a href="#note357"><b>357)</b></a></sup> else a
25952 </ul>
25953 Any non-IEC 60559 extended format used for the long double type shall have more
25954 precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note358"><b>358)</b></a></sup>
25959 <!--page 526 -->
25962 The long double type should match an IEC 60559 extended format.
25965 <p><small><a name="note357" href="#note357">357)</a> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
25967 </small>
25968 <p><small><a name="note358" href="#note358">358)</a> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
25969 all double values.
25970 </small>
25975 This specification does not define the behavior of signaling NaNs.<sup><a href="#note359"><b>359)</b></a></sup> It generally uses
25976 the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
25977 functions in <a href="#7.12"><math.h></a> provide designations for IEC 60559 NaNs and infinities.
25980 <p><small><a name="note359" href="#note359">359)</a> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
25981 sufficient for closure of the arithmetic.
25982 </small>
25987 C operators and functions provide IEC 60559 required and recommended facilities as
25988 listed below.
25989 <ul>
25991 divide operations.
25992 <li> The sqrt functions in <a href="#7.12"><math.h></a> provide the IEC 60559 square root operation.
25993 <li> The remainder functions in <a href="#7.12"><math.h></a> provide the IEC 60559 remainder
25994 operation. The remquo functions in <a href="#7.12"><math.h></a> provide the same operation but
25995 with additional information.
25996 <li> The rint functions in <a href="#7.12"><math.h></a> provide the IEC 60559 operation that rounds a
25997 floating-point number to an integer value (in the same precision). The nearbyint
25998 functions in <a href="#7.12"><math.h></a> provide the nearbyinteger function recommended in the
25999 Appendix to ANSI/IEEE 854.
26001 floating-point precisions.
26003 from integer to floating point.
26005 but always round toward zero.
26006 <li> The lrint and llrint functions in <a href="#7.12"><math.h></a> provide the IEC 60559
26007 conversions, which honor the directed rounding mode, from floating point to the
26008 long int and long long int integer formats. The lrint and llrint
26009 functions can be used to implement IEC 60559 conversions from floating to other
26010 integer formats.
26011 <li> The translation time conversion of floating constants and the strtod, strtof,
26012 strtold, fprintf, fscanf, and related library functions in <a href="#7.22"><stdlib.h></a>,
26015 <!--page 527 -->
26016 <a href="#7.21"><stdio.h></a>, and <a href="#7.29"><wchar.h></a> provide IEC 60559 binary-decimal conversions. The
26017 strtold function in <a href="#7.22"><stdlib.h></a> provides the conv function recommended in the
26018 Appendix to ANSI/IEEE 854.
26020 identifies a need for additional comparison predicates to facilitate writing code that
26021 accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
26023 supplement the language operators to address this need. The islessgreater and
26024 isunordered macros provide respectively a quiet version of the <> predicate and
26025 the unordered predicate recommended in the Appendix to IEC 60559.
26026 <li> The feclearexcept, feraiseexcept, and fetestexcept functions in
26027 <a href="#7.6"><fenv.h></a> provide the facility to test and alter the IEC 60559 floating-point
26028 exception status flags. The fegetexceptflag and fesetexceptflag
26029 functions in <a href="#7.6"><fenv.h></a> provide the facility to save and restore all five status flags at
26030 one time. These functions are used in conjunction with the type fexcept_t and the
26031 floating-point exception macros (FE_INEXACT, FE_DIVBYZERO,
26033 <li> The fegetround and fesetround functions in <a href="#7.6"><fenv.h></a> provide the facility
26034 to select among the IEC 60559 directed rounding modes represented by the rounding
26037 IEC 60559 directed rounding modes.
26038 <li> The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
26039 <a href="#7.6"><fenv.h></a> provide a facility to manage the floating-point environment, comprising
26040 the IEC 60559 status flags and control modes.
26041 <li> The copysign functions in <a href="#7.12"><math.h></a> provide the copysign function
26042 recommended in the Appendix to IEC 60559.
26043 <li> The fabs functions in <a href="#7.12"><math.h></a> provide the abs function recommended in the
26044 Appendix to IEC 60559.
26045 <li> The unary minus (-) operator provides the unary minus (-) operation recommended
26046 in the Appendix to IEC 60559.
26047 <li> The scalbn and scalbln functions in <a href="#7.12"><math.h></a> provide the scalb function
26048 recommended in the Appendix to IEC 60559.
26049 <li> The logb functions in <a href="#7.12"><math.h></a> provide the logb function recommended in the
26051 <li> The nextafter and nexttoward functions in <a href="#7.12"><math.h></a> provide the nextafter
26052 function recommended in the Appendix to IEC 60559 (but with a minor change to
26053 <!--page 528 -->
26054 better handle signed zeros).
26055 <li> The isfinite macro in <a href="#7.12"><math.h></a> provides the finite function recommended in
26056 the Appendix to IEC 60559.
26057 <li> The isnan macro in <a href="#7.12"><math.h></a> provides the isnan function recommended in the
26058 Appendix to IEC 60559.
26059 <li> The signbit macro and the fpclassify macro in <a href="#7.12"><math.h></a>, used in
26060 conjunction with the number classification macros (FP_NAN, FP_INFINITE,
26061 FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
26062 function recommended in the Appendix to IEC 60559 (except that the classification
26064 </ul>
26069 If the integer type is _Bool, <a href="#6.3.1.2">6.3.1.2</a> applies and no floating-point exceptions are raised
26070 (even for NaN). Otherwise, if the floating value is infinite or NaN or if the integral part
26071 of the floating value exceeds the range of the integer type, then the ''invalid'' floating-
26072 point exception is raised and the resulting value is unspecified. Otherwise, the resulting
26073 value is determined by <a href="#6.3.1.4">6.3.1.4</a>. Conversion of an integral floating value that does not
26074 exceed the range of the integer type raises no floating-point exceptions; whether
26075 conversion of a non-integral floating value raises the ''inexact'' floating-point exception is
26079 <p><small><a name="note360" href="#note360">360)</a> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
26080 conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
26081 cases where it matters, library functions can be used to effect such conversions with or without raising
26082 the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
26084 </small>
26089 Conversion from the widest supported IEC 60559 format to decimal with
26090 DECIMAL_DIG digits and back is the identity function.<sup><a href="#note361"><b>361)</b></a></sup>
26092 Conversions involving IEC 60559 formats follow all pertinent recommended practice. In
26093 particular, conversion between any supported IEC 60559 format and decimal with
26094 DECIMAL_DIG or fewer significant digits is correctly rounded (honoring the current
26095 rounding mode), which assures that conversion from the widest supported IEC 60559
26096 format to decimal with DECIMAL_DIG digits and back is the identity function.
26100 <!--page 529 -->
26102 Functions such as strtod that convert character sequences to floating types honor the
26103 rounding direction. Hence, if the rounding direction might be upward or downward, the
26104 implementation cannot convert a minus-signed sequence by negating the converted
26105 unsigned sequence.
26108 <p><small><a name="note361" href="#note361">361)</a> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
26112 </small>
26116 If the return expression is evaluated in a floating-point format different from the return
26117 type, the expression is converted as if by assignment<sup><a href="#note362"><b>362)</b></a></sup> to the return type of the function
26118 and the resulting value is returned to the caller.
26121 <p><small><a name="note362" href="#note362">362)</a> Assignment removes any extra range and precision.
26122 </small>
26127 A contracted expression is correctly rounded (once) and treats infinities, NaNs, signed
26128 zeros, subnormals, and the rounding directions in a manner consistent with the basic
26129 arithmetic operations covered by IEC 60559.
26132 A contracted expression should raise floating-point exceptions in a manner generally
26133 consistent with the basic arithmetic operations.
26138 The floating-point environment defined in <a href="#7.6"><fenv.h></a> includes the IEC 60559 floating-
26139 point exception status flags and directed-rounding control modes. It includes also
26140 IEC 60559 dynamic rounding precision and trap enablement modes, if the
26144 <p><small><a name="note363" href="#note363">363)</a> This specification does not require dynamic rounding precision nor trap enablement modes.
26145 </small>
26150 IEC 60559 requires that floating-point operations implicitly raise floating-point exception
26151 status flags, and that rounding control modes can be set explicitly to affect result values of
26152 floating-point operations. When the state for the FENV_ACCESS pragma (defined in
26153 <a href="#7.6"><fenv.h></a>) is ''on'', these changes to the floating-point state are treated as side effects
26159 <!--page 530 -->
26162 <p><small><a name="note364" href="#note364">364)</a> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
26163 point control modes will be the default ones and the floating-point status flags will not be tested,
26165 </small>
26170 During translation the IEC 60559 default modes are in effect:
26171 <ul>
26172 <li> The rounding direction mode is rounding to nearest.
26173 <li> The rounding precision mode (if supported) is set so that results are not shortened.
26174 <li> Trapping or stopping (if supported) is disabled on all floating-point exceptions.
26175 </ul>
26178 The implementation should produce a diagnostic message for each translation-time
26179 floating-point exception, other than ''inexact'';<sup><a href="#note365"><b>365)</b></a></sup> the implementation should then
26180 proceed with the translation of the program.
26183 <p><small><a name="note365" href="#note365">365)</a> As floating constants are converted to appropriate internal representations at translation time, their
26184 conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
26185 (even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
26186 strtod, provide execution-time conversion of numeric strings.
26187 </small>
26192 At program startup the floating-point environment is initialized as prescribed by
26193 IEC 60559:
26194 <ul>
26195 <li> All floating-point exception status flags are cleared.
26196 <li> The rounding direction mode is rounding to nearest.
26197 <li> The dynamic rounding precision mode (if supported) is set so that results are not
26198 shortened.
26199 <li> Trapping or stopping (if supported) is disabled on all floating-point exceptions.
26200 </ul>
26205 An arithmetic constant expression of floating type, other than one in an initializer for an
26206 object that has static or thread storage duration, is evaluated (as if) during execution; thus,
26207 it is affected by any operative floating-point control modes and raises floating-point
26208 exceptions as required by IEC 60559 (provided the state for the FENV_ACCESS pragma
26211 EXAMPLE
26215 <!--page 531 -->
26216 <pre>
26218 #pragma STDC FENV_ACCESS ON
26219 void f(void)
26220 {
26225 /* ... */
26226 }
26227 </pre>
26229 For the static initialization, the division is done at translation time, raising no (execution-time) floating-
26230 point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
26231 execution time.
26235 <p><small><a name="note366" href="#note366">366)</a> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
26238 efficiency of translation-time evaluation through static initialization, such as
26240 <pre>
26242 </pre>
26243 </small>
26248 All computation for automatic initialization is done (as if) at execution time; thus, it is
26249 affected by any operative modes and raises floating-point exceptions as required by
26250 IEC 60559 (provided the state for the FENV_ACCESS pragma is ''on''). All computation
26251 for initialization of objects that have static or thread storage duration is done (as if) at
26252 translation time.
26254 EXAMPLE
26255 <pre>
26257 #pragma STDC FENV_ACCESS ON
26258 void f(void)
26259 {
26260 float u[] = { 1.1e75 }; // raises exceptions
26261 static float v = 1.1e75; // does not raise exceptions
26262 float w = 1.1e75; // raises exceptions
26263 double x = 1.1e75; // may raise exceptions
26264 float y = 1.1e75f; // may raise exceptions
26265 long double z = 1.1e75; // does not raise exceptions
26266 /* ... */
26267 }
26268 </pre>
26270 The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
26271 done at translation time. The automatic initialization of u and w require an execution-time conversion to
26272 float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
26273 of x and y entail execution-time conversion; however, in some expression evaluation methods, the
26274 conversions is not to a narrower format, in which case no floating-point exception is raised.<sup><a href="#note367"><b>367)</b></a></sup> The
26275 automatic initialization of z entails execution-time conversion, but not to a narrower format, so no floating-
26276 point exception is raised. Note that the conversions of the floating constants 1.1e75 and 1.1e75f to
26280 <!--page 532 -->
26281 their internal representations occur at translation time in all cases.
26285 <p><small><a name="note367" href="#note367">367)</a> Use of float_t and double_t variables increases the likelihood of translation-time computation.
26286 For example, the automatic initialization
26288 <pre>
26289 double_t x = 1.1e75;
26290 </pre>
26291 could be done at translation time, regardless of the expression evaluation method.
26292 </small>
26297 Operations defined in <a href="#6.5">6.5</a> and functions and macros defined for the standard libraries
26298 change floating-point status flags and control modes just as indicated by their
26299 specifications (including conformance to IEC 60559). They do not change flags or modes
26300 (so as to be detectable by the user) in any other cases.
26302 If the argument to the feraiseexcept function in <a href="#7.6"><fenv.h></a> represents IEC 60559
26303 valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
26304 ''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
26305 before ''inexact''.
26310 This section identifies code transformations that might subvert IEC 60559-specified
26311 behavior, and others that do not.
26316 Floating-point arithmetic operations and external function calls may entail side effects
26317 which optimization shall honor, at least where the state of the FENV_ACCESS pragma is
26318 ''on''. The flags and modes in the floating-point environment may be regarded as global
26319 variables; floating-point operations (+, *, etc.) implicitly read the modes and write the
26320 flags.
26322 Concern about side effects may inhibit code motion and removal of seemingly useless
26323 code. For example, in
26324 <pre>
26326 #pragma STDC FENV_ACCESS ON
26327 void f(double x)
26328 {
26329 /* ... */
26331 /* ... */
26332 }
26333 </pre>
26334 x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
26336 course these optimizations are valid if the implementation can rule out the nettlesome
26337 cases.)
26339 This specification does not require support for trap handlers that maintain information
26340 about the order or count of floating-point exceptions. Therefore, between function calls,
26341 floating-point exceptions need not be precise: the actual order and number of occurrences
26343 <!--page 533 -->
26344 the preceding loop could be treated as
26345 <pre>
26347 </pre>
26353 <tr><td><pre> x/2 <-> x * 0.5 </pre><td>Although similar transformations involving inexact constants
26354 generally do not yield numerically equivalent expressions, if the
26355 constants are exact then such transformations can be made on
26356 IEC 60559 machines and others that round perfectly.
26357 <tr><td><pre> 1 * x and x/1 -> x </pre><td>The expressions 1*x, x/1, and x are equivalent (on IEC 60559
26359 <tr><td><pre> x/x -> 1.0 </pre><td>The expressions x/x and 1.0 are not equivalent if x can be zero,
26360 infinite, or NaN.
26361 <tr><td><pre> x - y <-> x + (-y) </pre><td>The expressions x - y, x + (-y), and (-y) + x are equivalent (on
26362 IEC 60559 machines, among others).
26363 <tr><td><pre> x - y <-> -(y - x) </pre><td>The expressions x - y and -(y - x) are not equivalent because 1 - 1
26364 is +0 but -(1 - 1) is -0 (in the default rounding direction).<sup><a href="#note369"><b>369)</b></a></sup>
26365 <tr><td><pre> x - x -> 0.0 </pre><td>The expressions x - x and 0.0 are not equivalent if x is a NaN or
26366 infinite.
26367 <tr><td><pre> 0 * x -> 0.0 </pre><td>The expressions 0*x and 0.0 are not equivalent if x is a NaN,
26368 infinite, or -0.
26369 <tr><td><pre> x + 0 -> x </pre><td>The expressions x + 0 and x are not equivalent if x is -0, because
26371 <tr><td><pre> x - 0 -> x </pre><td>(+0) - (+0) yields -0 when rounding is downward (toward -(inf)), but
26373 FENV_ACCESS pragma is ''off'', promising default rounding, then
26374 the implementation can replace x - 0 by x, even if x might be zero.
26375 <tr><td><pre> -x <-> 0 - x </pre><td>The expressions -x and 0 - x are not equivalent if x is +0, because
26377 downward).
26378 </table>
26380 <!--page 534 -->
26383 <p><small><a name="note368" href="#note368">368)</a> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
26384 other transformations that remove arithmetic operators.
26385 </small>
26386 <p><small><a name="note369" href="#note369">369)</a> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
26387 Examples include:
26389 <pre>
26391 </pre>
26392 and
26394 <pre>
26395 conj(csqrt(z)) is csqrt(conj(z)),
26396 </pre>
26397 for complex z.
26398 </small>
26406 <tr><td><pre> x < y -> isless(x,y)</pre> (and similarly for <=, >, >=) <td>Though numerically equal, these
26407 expressions are not equivalent because of side effects when x or y is a
26408 NaN and the state of the FENV_ACCESS pragma is ''on''. This
26409 transformation, which would be desirable if extra code were required
26410 to cause the ''invalid'' floating-point exception for unordered cases,
26411 could be performed provided the state of the FENV_ACCESS pragma
26412 is ''off''.
26413 </table>
26414 The sense of relational operators shall be maintained. This includes handling unordered
26415 cases as expressed by the source code.
26417 EXAMPLE
26418 <pre>
26419 // calls g and raises ''invalid'' if a and b are unordered
26420 if (a < b)
26421 f();
26422 else
26423 g();
26424 </pre>
26425 is not equivalent to
26426 <pre>
26427 // calls f and raises ''invalid'' if a and b are unordered
26428 if (a >= b)
26429 g();
26430 else
26431 f();
26432 </pre>
26433 nor to
26434 <pre>
26435 // calls f without raising ''invalid'' if a and b are unordered
26436 if (isgreaterequal(a,b))
26437 g();
26438 else
26439 f();
26440 </pre>
26441 nor, unless the state of the FENV_ACCESS pragma is ''off'', to
26442 <pre>
26443 // calls g without raising ''invalid'' if a and b are unordered
26444 if (isless(a,b))
26445 f();
26446 else
26447 g();
26448 </pre>
26449 but is equivalent to
26450 <!--page 535 -->
26451 <pre>
26452 if (!(a < b))
26453 g();
26454 else
26455 f();
26456 </pre>
26462 The implementation shall honor floating-point exceptions raised by execution-time
26463 constant arithmetic wherever the state of the FENV_ACCESS pragma is ''on''. (See <a href="#F.8.4">F.8.4</a>
26464 and <a href="#F.8.5">F.8.5</a>.) An operation on constants that raises no floating-point exception can be
26465 folded during translation, except, if the state of the FENV_ACCESS pragma is ''on'', a
26466 further check is required to assure that changing the rounding direction to downward does
26467 not alter the sign of the result,<sup><a href="#note370"><b>370)</b></a></sup> and implementations that support dynamic rounding
26468 precision modes shall assure further that the result of the operation raises no floating-
26469 point exception when converted to the semantic type of the operation.
26472 <p><small><a name="note370" href="#note370">370)</a> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
26473 </small>
26478 This subclause contains specifications of <a href="#7.12"><math.h></a> facilities that are particularly suited
26479 for IEC 60559 implementations.
26481 The Standard C macro HUGE_VAL and its float and long double analogs,
26482 HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
26483 infinities.
26485 Special cases for functions in <a href="#7.12"><math.h></a> are covered directly or indirectly by
26486 IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
26487 other functions in <a href="#7.12"><math.h></a> treat infinities, NaNs, signed zeros, subnormals, and
26488 (provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
26489 in a manner consistent with the basic arithmetic operations covered by IEC 60559.
26491 The expression math_errhandling & MATH_ERREXCEPT shall evaluate to a
26492 nonzero value.
26494 The ''invalid'' and ''divide-by-zero'' floating-point exceptions are raised as specified in
26495 subsequent subclauses of this annex.
26497 The ''overflow'' floating-point exception is raised whenever an infinity -- or, because of
26498 rounding direction, a maximal-magnitude finite number -- is returned in lieu of a value
26499 whose magnitude is too large.
26501 The ''underflow'' floating-point exception is raised whenever a result is tiny (essentially
26505 <!--page 536 -->
26507 Whether or when library functions raise the ''inexact'' floating-point exception is
26508 unspecified, unless explicitly specified otherwise.
26510 Whether or when library functions raise an undeserved ''underflow'' floating-point
26511 exception is unspecified.<sup><a href="#note372"><b>372)</b></a></sup> Otherwise, as implied by <a href="#F.8.6">F.8.6</a>, the <a href="#7.12"><math.h></a> functions do
26512 not raise spurious floating-point exceptions (detectable by the user), other than the
26513 ''inexact'' floating-point exception.
26515 Whether the functions honor the rounding direction mode is implementation-defined,
26516 unless explicitly specified otherwise.
26518 Functions with a NaN argument return a NaN result and raise no floating-point exception,
26519 except where stated otherwise.
26521 The specifications in the following subclauses append to the definitions in <a href="#7.12"><math.h></a>.
26522 For families of functions, the specifications apply to all of the functions even though only
26523 the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
26524 occurs in both an argument and the result, the result has the same sign as the argument.
26527 If a function with one or more NaN arguments returns a NaN result, the result should be
26528 the same as one of the NaN arguments (after possible type conversion), except perhaps
26529 for the sign.
26532 <p><small><a name="note371" href="#note371">371)</a> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
26533 when the floating-point exception is raised.
26534 </small>
26535 <p><small><a name="note372" href="#note372">372)</a> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
26536 avoiding them would be too costly.
26537 </small>
26545 <ul>
26547 <li> acos(x) returns a NaN and raises the ''invalid'' floating-point exception for
26549 </ul>
26554 <ul>
26556 <li> asin(x) returns a NaN and raises the ''invalid'' floating-point exception for
26562 <!--page 537 -->
26563 </ul>
26568 <ul>
26571 </ul>
26576 <ul>
26588 </ul>
26591 <p><small><a name="note373" href="#note373">373)</a> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y , 0) raise
26592 the ''divide-by-zero'' floating-point exception.
26593 </small>
26598 <ul>
26600 <li> cos((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
26601 </ul>
26606 <ul>
26608 <li> sin((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
26609 </ul>
26614 <ul>
26616 <li> tan((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
26621 <!--page 538 -->
26622 </ul>
26630 <ul>
26633 <li> acosh(+(inf)) returns +(inf).
26634 </ul>
26639 <ul>
26641 <li> asinh((+-)(inf)) returns (+-)(inf).
26642 </ul>
26647 <ul>
26649 <li> atanh((+-)1) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
26650 <li> atanh(x) returns a NaN and raises the ''invalid'' floating-point exception for
26652 </ul>
26657 <ul>
26659 <li> cosh((+-)(inf)) returns +(inf).
26660 </ul>
26665 <ul>
26667 <li> sinh((+-)(inf)) returns (+-)(inf).
26668 </ul>
26673 <ul>
26676 </ul>
26684 <ul>
26687 <li> exp(+(inf)) returns +(inf).
26688 <!--page 539 -->
26689 </ul>
26694 <ul>
26697 <li> exp2(+(inf)) returns +(inf).
26698 </ul>
26703 <ul>
26706 <li> expm1(+(inf)) returns +(inf).
26707 </ul>
26712 <ul>
26714 <li> frexp((+-)(inf), exp) returns (+-)(inf), and stores an unspecified value in the object
26715 pointed to by exp.
26716 <li> frexp(NaN, exp) stores an unspecified value in the object pointed to by exp
26717 (and returns a NaN).
26718 </ul>
26720 frexp raises no floating-point exceptions.
26722 When the radix of the argument is a power of 2, the returned value is exact and is
26723 independent of the current rounding direction mode.
26725 On a binary system, the body of the frexp function might be
26726 <pre>
26727 {
26729 return scalbn(value, -(*exp));
26730 }
26731 </pre>
26736 When the correct result is representable in the range of the return type, the returned value
26737 is exact and is independent of the current rounding direction mode.
26739 If the correct result is outside the range of the return type, the numeric result is
26740 unspecified and the ''invalid'' floating-point exception is raised.
26742 ilogb(x), for x zero, infinite, or NaN, raises the ''invalid'' floating-point exception and
26744 <!--page 540 -->
26749 On a binary system, ldexp(x, exp) is equivalent to scalbn(x, exp).
26754 <ul>
26758 <li> log(+(inf)) returns +(inf).
26759 </ul>
26764 <ul>
26768 <li> log10(+(inf)) returns +(inf).
26769 </ul>
26774 <ul>
26777 <li> log1p(x) returns a NaN and raises the ''invalid'' floating-point exception for
26779 <li> log1p(+(inf)) returns +(inf).
26780 </ul>
26785 <ul>
26789 <li> log2(+(inf)) returns +(inf).
26790 </ul>
26795 <ul>
26797 <li> logb((+-)(inf)) returns +(inf).
26798 </ul>
26800 The returned value is exact and is independent of the current rounding direction mode.
26801 <!--page 541 -->
26806 <ul>
26807 <li> modf((+-)x, iptr) returns a result with the same sign as x.
26808 <li> modf((+-)(inf), iptr) returns (+-)0 and stores (+-)(inf) in the object pointed to by iptr.
26809 <li> modf(NaN, iptr) stores a NaN in the object pointed to by iptr (and returns a
26810 NaN).
26811 </ul>
26813 The returned values are exact and are independent of the current rounding direction
26814 mode.
26816 modf behaves as though implemented by
26817 <pre>
26820 #pragma STDC FENV_ACCESS ON
26821 double modf(double value, double *iptr)
26822 {
26823 int save_round = fegetround();
26824 fesetround(FE_TOWARDZERO);
26825 *iptr = nearbyint(value);
26826 fesetround(save_round);
26827 return copysign(
26828 isinf(value) ? 0.0 :
26829 value - (*iptr), value);
26830 }
26831 </pre>
26836 <ul>
26839 <li> scalbn((+-)(inf), n) returns (+-)(inf).
26840 </ul>
26842 If the calculation does not overflow or underflow, the returned value is exact and
26843 independent of the current rounding direction mode.
26844 <!--page 542 -->
26852 <ul>
26854 <li> cbrt((+-)(inf)) returns (+-)(inf).
26855 </ul>
26860 <ul>
26862 <li> fabs((+-)(inf)) returns +(inf).
26863 </ul>
26865 The returned value is exact and is independent of the current rounding direction mode.
26870 <ul>
26871 <li> hypot(x, y), hypot(y, x), and hypot(x, -y) are equivalent.
26873 <li> hypot((+-)(inf), y) returns +(inf), even if y is a NaN.
26874 </ul>
26879 <ul>
26880 <li> pow((+-)0, y) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception
26885 exception.
26891 <li> pow(x, y) returns a NaN and raises the ''invalid'' floating-point exception for
26897 <!--page 543 -->
26904 </ul>
26909 sqrt is fully specified as a basic arithmetic operation in IEC 60559. The returned value
26910 is dependent on the current rounding direction mode.
26918 <ul>
26921 </ul>
26926 <ul>
26929 </ul>
26934 <ul>
26937 <li> lgamma(x) returns +(inf) and raises the ''divide-by-zero'' floating-point exception for
26938 x a negative integer or zero.
26939 <li> lgamma(-(inf)) returns +(inf).
26940 <li> lgamma(+(inf)) returns +(inf).
26941 </ul>
26946 <ul>
26947 <li> tgamma((+-)0) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
26948 <li> tgamma(x) returns a NaN and raises the ''invalid'' floating-point exception for x a
26949 negative integer.
26950 <li> tgamma(-(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
26951 <li> tgamma(+(inf)) returns +(inf).
26952 <!--page 544 -->
26953 </ul>
26961 <ul>
26963 <li> ceil((+-)(inf)) returns (+-)(inf).
26964 </ul>
26966 The returned value is independent of the current rounding direction mode.
26968 The double version of ceil behaves as though implemented by
26969 <pre>
26972 #pragma STDC FENV_ACCESS ON
26973 double ceil(double x)
26974 {
26975 double result;
26976 int save_round = fegetround();
26977 fesetround(FE_UPWARD);
26978 result = rint(x); // or nearbyint instead of rint
26979 fesetround(save_round);
26980 return result;
26981 }
26982 </pre>
26984 The ceil functions may, but are not required to, raise the ''inexact'' floating-point
26985 exception for finite non-integer arguments, as this implementation does.
26990 <ul>
26992 <li> floor((+-)(inf)) returns (+-)(inf).
26993 </ul>
26995 The returned value and is independent of the current rounding direction mode.
26997 See the sample implementation for ceil in <a href="#F.10.6.1">F.10.6.1</a>. The floor functions may, but are
26998 not required to, raise the ''inexact'' floating-point exception for finite non-integer
26999 arguments, as that implementation does.
27004 The nearbyint functions use IEC 60559 rounding according to the current rounding
27005 direction. They do not raise the ''inexact'' floating-point exception if the result differs in
27006 value from the argument.
27007 <ul>
27009 <li> nearbyint((+-)(inf)) returns (+-)(inf) (for all rounding directions).
27010 <!--page 545 -->
27011 </ul>
27016 The rint functions differ from the nearbyint functions only in that they do raise the
27017 ''inexact'' floating-point exception if the result differs in value from the argument.
27022 The lrint and llrint functions provide floating-to-integer conversion as prescribed
27023 by IEC 60559. They round according to the current rounding direction. If the rounded
27024 value is outside the range of the return type, the numeric result is unspecified and the
27025 ''invalid'' floating-point exception is raised. When they raise no other floating-point
27026 exception and the result differs from the argument, they raise the ''inexact'' floating-point
27027 exception.
27032 <ul>
27034 <li> round((+-)(inf)) returns (+-)(inf).
27035 </ul>
27037 The returned value is independent of the current rounding direction mode.
27039 The double version of round behaves as though implemented by
27040 <pre>
27043 #pragma STDC FENV_ACCESS ON
27044 double round(double x)
27045 {
27046 double result;
27047 fenv_t save_env;
27048 feholdexcept(&save_env);
27049 result = rint(x);
27050 if (fetestexcept(FE_INEXACT)) {
27051 fesetround(FE_TOWARDZERO);
27052 result = rint(copysign(0.5 + fabs(x), x));
27053 }
27054 feupdateenv(&save_env);
27055 return result;
27056 }
27057 </pre>
27058 The round functions may, but are not required to, raise the ''inexact'' floating-point
27059 exception for finite non-integer numeric arguments, as this implementation does.
27060 <!--page 546 -->
27065 The lround and llround functions differ from the lrint and llrint functions
27066 with the default rounding direction just in that the lround and llround functions
27067 round halfway cases away from zero and need not raise the ''inexact'' floating-point
27068 exception for non-integer arguments that round to within the range of the return type.
27073 The trunc functions use IEC 60559 rounding toward zero (regardless of the current
27074 rounding direction). The returned value is exact.
27075 <ul>
27077 <li> trunc((+-)(inf)) returns (+-)(inf).
27078 </ul>
27080 The returned value is independent of the current rounding direction mode. The trunc
27081 functions may, but are not required to, raise the ''inexact'' floating-point exception for
27082 finite non-integer arguments.
27090 <ul>
27092 <li> fmod(x, y) returns a NaN and raises the ''invalid'' floating-point exception for x
27093 infinite or y zero (and neither is a NaN).
27094 <li> fmod(x, (+-)(inf)) returns x for x not infinite.
27095 </ul>
27097 When subnormal results are supported, the returned value is exact and is independent of
27098 the current rounding direction mode.
27100 The double version of fmod behaves as though implemented by
27101 <!--page 547 -->
27102 <pre>
27105 #pragma STDC FENV_ACCESS ON
27106 double fmod(double x, double y)
27107 {
27108 double result;
27109 result = remainder(fabs(x), (y = fabs(y)));
27110 if (signbit(result)) result += y;
27111 return copysign(result, x);
27112 }
27113 </pre>
27118 The remainder functions are fully specified as a basic arithmetic operation in
27119 IEC 60559.
27121 When subnormal results are supported, the returned value is exact and is independent of
27122 the current rounding direction mode.
27127 The remquo functions follow the specifications for the remainder functions. They
27128 have no further specifications special to IEC 60559 implementations.
27130 When subnormal results are supported, the returned value is exact and is independent of
27131 the current rounding direction mode.
27139 copysign is specified in the Appendix to IEC 60559.
27141 The returned value is exact and is independent of the current rounding direction mode.
27146 All IEC 60559 implementations support quiet NaNs, in all floating formats.
27148 The returned value is exact and is independent of the current rounding direction mode.
27153 <ul>
27154 <li> nextafter(x, y) raises the ''overflow'' and ''inexact'' floating-point exceptions
27155 for x finite and the function value infinite.
27156 <li> nextafter(x, y) raises the ''underflow'' and ''inexact'' floating-point
27157 exceptions for the function value subnormal or zero and x != y.
27158 </ul>
27160 Even though underflow or overflow can occur, the returned value is independent of the
27161 current rounding direction mode.
27166 No additional requirements beyond those on nextafter.
27168 Even though underflow or overflow can occur, the returned value is independent of the
27169 current rounding direction mode.
27170 <!--page 548 -->
27173 <h4><a name="F.10.9" href="#F.10.9">F.10.9 Maximum, minimum, and positive difference functions</a></h4>
27178 No additional requirements.
27183 If just one argument is a NaN, the fmax functions return the other argument (if both
27184 arguments are NaNs, the functions return a NaN).
27186 The returned value is exact and is independent of the current rounding direction mode.
27189 <pre>
27190 { return (isgreaterequal(x, y) ||
27191 isnan(y)) ? x : y; }
27192 </pre>
27195 <p><small><a name="note374" href="#note374">374)</a> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
27196 return +0; however, implementation in software might be impractical.
27197 </small>
27202 The fmin functions are analogous to the fmax functions (see <a href="#F.10.9.2">F.10.9.2</a>).
27204 The returned value is exact and is independent of the current rounding direction mode.
27212 <ul>
27213 <li> fma(x, y, z) computes xy + z, correctly rounded once.
27214 <li> fma(x, y, z) returns a NaN and optionally raises the ''invalid'' floating-point
27215 exception if one of x and y is infinite, the other is zero, and z is a NaN.
27216 <li> fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if
27217 one of x and y is infinite, the other is zero, and z is not a NaN.
27218 <li> fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if x
27219 times y is an exact infinity and z is also an infinity but with the opposite sign.
27224 <!--page 549 -->
27225 </ul>
27230 Relational operators and their corresponding comparison macros (<a href="#7.12.14">7.12.14</a>) produce
27231 equivalent result values, even if argument values are represented in wider formats. Thus,
27232 comparison macro arguments represented in formats wider than their semantic types are
27233 not converted to the semantic types, unless the wide evaluation method converts operands
27234 of relational operators to their semantic types. The standard wide evaluation methods
27235 characterized by FLT_EVAL_METHOD equal to 1 or 2 (<a href="#5.2.4.2.2">5.2.4.2.2</a>), do not convert
27236 operands of relational operators to their semantic types.
27237 <!--page 550 -->
27241 <pre>
27242 (normative)
27243 IEC 60559-compatible complex arithmetic
27244 </pre>
27249 This annex supplements <a href="#F">annex F</a> to specify complex arithmetic for compatibility with
27250 IEC 60559 real floating-point arithmetic. An implementation that defines
27251 __STDC_IEC_559_COMPLEX__ shall conform to the specifications in this annex.<sup><a href="#note375"><b>375)</b></a></sup>
27254 <p><small><a name="note375" href="#note375">375)</a> Implementations that do not define __STDC_IEC_559_COMPLEX__ are not required to conform
27255 to these specifications.
27256 </small>
27261 There is a new keyword _Imaginary, which is used to specify imaginary types. It is
27262 used as a type specifier within declaration specifiers in the same way as _Complex is
27263 (thus, _Imaginary float is a valid type name).
27265 There are three imaginary types, designated as float _Imaginary, double
27266 _Imaginary, and long double _Imaginary. The imaginary types (along with
27267 the real floating and complex types) are floating types.
27269 For imaginary types, the corresponding real type is given by deleting the keyword
27270 _Imaginary from the type name.
27272 Each imaginary type has the same representation and alignment requirements as the
27273 corresponding real type. The value of an object of imaginary type is the value of the real
27274 representation times the imaginary unit.
27276 The imaginary type domain comprises the imaginary types.
27281 A complex or imaginary value with at least one infinite part is regarded as an infinity
27282 (even if its other part is a NaN). A complex or imaginary value is a finite number if each
27283 of its parts is a finite number (neither infinite nor NaN). A complex or imaginary value is
27284 a zero if each of its parts is a zero.
27289 <!--page 551 -->
27297 Conversions among imaginary types follow rules analogous to those for real floating
27298 types.
27303 When a value of imaginary type is converted to a real type other than _Bool,<sup><a href="#note376"><b>376)</b></a></sup> the
27304 result is a positive zero.
27306 When a value of real type is converted to an imaginary type, the result is a positive
27307 imaginary zero.
27311 </small>
27316 When a value of imaginary type is converted to a complex type, the real part of the
27317 complex result value is a positive zero and the imaginary part of the complex result value
27318 is determined by the conversion rules for the corresponding real types.
27320 When a value of complex type is converted to an imaginary type, the real part of the
27321 complex value is discarded and the value of the imaginary part is converted according to
27322 the conversion rules for the corresponding real types.
27327 The following subclauses supplement <a href="#6.5">6.5</a> in order to specify the type of the result for an
27328 operation with an imaginary operand.
27330 For most operand types, the value of the result of a binary operator with an imaginary or
27331 complex operand is completely determined, with reference to real arithmetic, by the usual
27332 mathematical formula. For some operand types, the usual mathematical formula is
27333 problematic because of its treatment of infinities and because of undue overflow or
27334 underflow; in these cases the result satisfies certain properties (specified in <a href="#G.5.1">G.5.1</a>), but is
27335 not completely determined.
27340 <!--page 552 -->
27346 If one operand has real type and the other operand has imaginary type, then the result has
27347 imaginary type. If both operands have imaginary type, then the result has real type. (If
27348 either operand has complex type, then the result has complex type.)
27350 If the operands are not both complex, then the result and floating-point exception
27351 behavior of the * operator is defined by the usual mathematical formula:
27357 </table>
27359 If the second operand is not complex, then the result and floating-point exception
27360 behavior of the / operator is defined by the usual mathematical formula:
27366 </table>
27368 The * and / operators satisfy the following infinity properties for all real, imaginary, and
27370 <ul>
27371 <li> if one operand is an infinity and the other operand is a nonzero finite number or an
27372 infinity, then the result of the * operator is an infinity;
27373 <li> if the first operand is an infinity and the second operand is a finite number, then the
27374 result of the / operator is an infinity;
27375 <li> if the first operand is a finite number and the second operand is an infinity, then the
27376 result of the / operator is a zero;
27381 <!--page 553 -->
27382 <li> if the first operand is a nonzero finite number or an infinity and the second operand is
27383 a zero, then the result of the / operator is an infinity.
27384 </ul>
27386 If both operands of the * operator are complex or if the second operand of the / operator
27387 is complex, the operator raises floating-point exceptions if appropriate for the calculation
27388 of the parts of the result, and may raise spurious floating-point exceptions.
27390 EXAMPLE 1 Multiplication of double _Complex operands could be implemented as follows. Note
27392 <!--page 554 -->
27393 <pre>
27396 /* Multiply z * w ... */
27397 double complex _Cmultd(double complex z, double complex w)
27398 {
27399 #pragma STDC FP_CONTRACT OFF
27400 double a, b, c, d, ac, bd, ad, bc, x, y;
27401 a = creal(z); b = cimag(z);
27402 c = creal(w); d = cimag(w);
27403 ac = a * c; bd = b * d;
27404 ad = a * d; bc = b * c;
27405 x = ac - bd; y = ad + bc;
27406 if (isnan(x) && isnan(y)) {
27407 /* Recover infinities that computed as NaN+iNaN ... */
27408 int recalc = 0;
27409 if (isinf(a) || isinf(b)) { // z is infinite
27413 if (isnan(c)) c = copysign(0.0, c);
27414 if (isnan(d)) d = copysign(0.0, d);
27415 recalc = 1;
27416 }
27417 if (isinf(c) || isinf(d)) { // w is infinite
27421 if (isnan(a)) a = copysign(0.0, a);
27422 if (isnan(b)) b = copysign(0.0, b);
27423 recalc = 1;
27424 }
27425 if (!recalc && (isinf(ac) || isinf(bd) ||
27426 isinf(ad) || isinf(bc))) {
27427 /* Recover infinities from overflow by changing NaNs to 0 ... */
27428 if (isnan(a)) a = copysign(0.0, a);
27429 if (isnan(b)) b = copysign(0.0, b);
27430 if (isnan(c)) c = copysign(0.0, c);
27431 if (isnan(d)) d = copysign(0.0, d);
27432 recalc = 1;
27433 }
27434 if (recalc) {
27435 x = INFINITY * ( a * c - b * d );
27436 y = INFINITY * ( a * d + b * c );
27437 }
27438 }
27439 return x + I * y;
27440 }
27441 </pre>
27443 This implementation achieves the required treatment of infinities at the cost of only one isnan test in
27444 ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
27447 EXAMPLE 2 Division of two double _Complex operands could be implemented as follows.
27448 <!--page 555 -->
27449 <pre>
27452 /* Divide z / w ... */
27453 double complex _Cdivd(double complex z, double complex w)
27454 {
27455 #pragma STDC FP_CONTRACT OFF
27456 double a, b, c, d, logbw, denom, x, y;
27457 int ilogbw = 0;
27458 a = creal(z); b = cimag(z);
27459 c = creal(w); d = cimag(w);
27460 logbw = logb(fmax(fabs(c), fabs(d)));
27461 if (isfinite(logbw)) {
27462 ilogbw = (int)logbw;
27463 c = scalbn(c, -ilogbw); d = scalbn(d, -ilogbw);
27464 }
27465 denom = c * c + d * d;
27466 x = scalbn((a * c + b * d) / denom, -ilogbw);
27467 y = scalbn((b * c - a * d) / denom, -ilogbw);
27468 /* Recover infinities and zeros that computed as NaN+iNaN; */
27469 /* the only cases are nonzero/zero, infinite/finite, and finite/infinite, ... */
27470 if (isnan(x) && isnan(y)) {
27472 (!isnan(a) || !isnan(b))) {
27473 x = copysign(INFINITY, c) * a;
27474 y = copysign(INFINITY, c) * b;
27475 }
27476 else if ((isinf(a) || isinf(b)) &&
27477 isfinite(c) && isfinite(d)) {
27480 x = INFINITY * ( a * c + b * d );
27481 y = INFINITY * ( b * c - a * d );
27482 }
27483 else if ((logbw == INFINITY) &&
27484 isfinite(a) && isfinite(b)) {
27487 x = 0.0 * ( a * c + b * d );
27488 y = 0.0 * ( b * c - a * d );
27489 }
27490 }
27491 return x + I * y;
27492 }
27493 </pre>
27495 Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
27496 for multiplication. In the spirit of the multiplication example above, this code does not defend against
27497 overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
27498 with division, provides better roundoff characteristics.
27502 <p><small><a name="note377" href="#note377">377)</a> These properties are already implied for those cases covered in the tables, but are required for all cases
27503 (at least where the state for CX_LIMITED_RANGE is ''off'').
27504 </small>
27510 If both operands have imaginary type, then the result has imaginary type. (If one operand
27511 has real type and the other operand has imaginary type, or if either operand has complex
27512 type, then the result has complex type.)
27514 In all cases the result and floating-point exception behavior of a + or - operator is defined
27515 by the usual mathematical formula:
27521 </table>
27526 The macros
27527 <pre>
27528 imaginary
27529 </pre>
27530 and
27531 <pre>
27532 _Imaginary_I
27533 </pre>
27534 are defined, respectively, as _Imaginary and a constant expression of type const
27535 float _Imaginary with the value of the imaginary unit. The macro
27536 <pre>
27537 I
27538 </pre>
27539 is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
27540 the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
27541 imaginary.
27543 This subclause contains specifications for the <a href="#7.3"><complex.h></a> functions that are
27544 particularly suited to IEC 60559 implementations. For families of functions, the
27545 specifications apply to all of the functions even though only the principal function is
27546 <!--page 556 -->
27547 shown. Unless otherwise specified, where the symbol ''(+-)'' occurs in both an argument
27548 and the result, the result has the same sign as the argument.
27550 The functions are continuous onto both sides of their branch cuts, taking into account the
27553 Since complex and imaginary values are composed of real values, each function may be
27554 regarded as computing real values from real values. Except as noted, the functions treat
27555 real infinities, NaNs, signed zeros, subnormals, and the floating-point exception flags in a
27556 manner consistent with the specifications for real functions in F.10.<sup><a href="#note378"><b>378)</b></a></sup>
27558 The functions cimag, conj, cproj, and creal are fully specified for all
27559 implementations, including IEC 60559 ones, in <a href="#7.3.9">7.3.9</a>. These functions raise no floating-
27560 point exceptions.
27562 Each of the functions cabs and carg is specified by a formula in terms of a real
27564 <pre>
27565 cabs(x + iy) = hypot(x, y)
27566 carg(x + iy) = atan2(y, x)
27567 </pre>
27569 Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
27570 a formula in terms of other complex functions (whose special cases are specified below):
27571 <pre>
27572 casin(z) = -i casinh(iz)
27573 catan(z) = -i catanh(iz)
27574 ccos(z) = ccosh(iz)
27575 csin(z) = -i csinh(iz)
27576 ctan(z) = -i ctanh(iz)
27577 </pre>
27579 For the other functions, the following subclauses specify behavior for special cases,
27580 including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
27581 families of functions, the specifications apply to all of the functions even though only the
27582 principal function is shown. For a function f satisfying f (conj(z)) = conj( f (z)), the
27583 specifications for the upper half-plane imply the specifications for the lower half-plane; if
27584 the function f is also either even, f (-z) = f (z), or odd, f (-z) = - f (z), then the
27585 specifications for the first quadrant imply the specifications for the other three quadrants.
27587 In the following subclauses, cis(y) is defined as cos(y) + i sin(y).
27592 <!--page 557 -->
27595 <p><small><a name="note378" href="#note378">378)</a> As noted in <a href="#G.3">G.3</a>, a complex value with at least one infinite part is regarded as an infinity even if its
27596 other part is a NaN.
27597 </small>
27605 <ul>
27606 <li> cacos(conj(z)) = conj(cacos(z)).
27610 <li> cacos(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27611 point exception, for nonzero finite x.
27612 <li> cacos(-(inf) + iy) returns pi - i (inf), for positive-signed finite y.
27616 <li> cacos((+-)(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
27617 result is unspecified).
27618 <li> cacos(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27619 point exception, for finite y.
27620 <li> cacos(NaN + i (inf)) returns NaN - i (inf).
27621 <li> cacos(NaN + iNaN) returns NaN + iNaN.
27622 </ul>
27630 <ul>
27631 <li> cacosh(conj(z)) = conj(cacosh(z)).
27634 <li> cacosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
27635 floating-point exception, for finite x.
27636 <li> cacosh(-(inf) + iy) returns +(inf) + ipi , for positive-signed finite y.
27637 <li> cacosh(+(inf) + iy) returns +(inf) + i0, for positive-signed finite y.
27640 <li> cacosh((+-)(inf) + iNaN) returns +(inf) + iNaN.
27641 <!--page 558 -->
27642 <li> cacosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
27643 floating-point exception, for finite y.
27644 <li> cacosh(NaN + i (inf)) returns +(inf) + iNaN.
27645 <li> cacosh(NaN + iNaN) returns NaN + iNaN.
27646 </ul>
27651 <ul>
27652 <li> casinh(conj(z)) = conj(casinh(z)) and casinh is odd.
27655 <li> casinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
27656 floating-point exception, for finite x.
27657 <li> casinh(+(inf) + iy) returns +(inf) + i0 for positive-signed finite y.
27659 <li> casinh(+(inf) + iNaN) returns +(inf) + iNaN.
27660 <li> casinh(NaN + i0) returns NaN + i0.
27661 <li> casinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
27662 floating-point exception, for finite nonzero y.
27663 <li> casinh(NaN + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result
27664 is unspecified).
27665 <li> casinh(NaN + iNaN) returns NaN + iNaN.
27666 </ul>
27671 <ul>
27672 <li> catanh(conj(z)) = conj(catanh(z)) and catanh is odd.
27676 exception.
27678 <li> catanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
27679 floating-point exception, for nonzero finite x.
27683 <!--page 559 -->
27684 <li> catanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
27685 floating-point exception, for finite y.
27686 <li> catanh(NaN + i (inf)) returns (+-)0 + ipi /2 (where the sign of the real part of the result is
27687 unspecified).
27688 <li> catanh(NaN + iNaN) returns NaN + iNaN.
27689 </ul>
27694 <ul>
27695 <li> ccosh(conj(z)) = conj(ccosh(z)) and ccosh is even.
27698 result is unspecified) and raises the ''invalid'' floating-point exception.
27700 result is unspecified).
27701 <li> ccosh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
27702 exception, for finite nonzero x.
27703 <li> ccosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27704 point exception, for finite nonzero x.
27705 <li> ccosh(+(inf) + i0) returns +(inf) + i0.
27706 <li> ccosh(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
27707 <li> ccosh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
27708 unspecified) and raises the ''invalid'' floating-point exception.
27709 <li> ccosh(+(inf) + iNaN) returns +(inf) + iNaN.
27710 <li> ccosh(NaN + i0) returns NaN (+-) i0 (where the sign of the imaginary part of the
27711 result is unspecified).
27712 <li> ccosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27713 point exception, for all nonzero numbers y.
27714 <li> ccosh(NaN + iNaN) returns NaN + iNaN.
27715 </ul>
27720 <ul>
27721 <li> csinh(conj(z)) = conj(csinh(z)) and csinh is odd.
27723 <li> csinh(+0 + i (inf)) returns (+-)0 + iNaN (where the sign of the real part of the result is
27724 unspecified) and raises the ''invalid'' floating-point exception.
27726 unspecified).
27727 <!--page 560 -->
27728 <li> csinh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
27729 exception, for positive finite x.
27730 <li> csinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27731 point exception, for finite nonzero x.
27732 <li> csinh(+(inf) + i0) returns +(inf) + i0.
27733 <li> csinh(+(inf) + iy) returns +(inf) cis(y), for positive finite y.
27734 <li> csinh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
27735 unspecified) and raises the ''invalid'' floating-point exception.
27736 <li> csinh(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
27737 is unspecified).
27738 <li> csinh(NaN + i0) returns NaN + i0.
27739 <li> csinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27740 point exception, for all nonzero numbers y.
27741 <li> csinh(NaN + iNaN) returns NaN + iNaN.
27742 </ul>
27747 <ul>
27748 <li> ctanh(conj(z)) = conj(ctanh(z))and ctanh is odd.
27750 <li> ctanh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
27751 exception, for finite x.
27752 <li> ctanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27753 point exception, for finite x.
27755 <li> ctanh(+(inf) + i (inf)) returns 1 (+-) i0 (where the sign of the imaginary part of the result
27756 is unspecified).
27758 result is unspecified).
27759 <li> ctanh(NaN + i0) returns NaN + i0.
27760 <li> ctanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27761 point exception, for all nonzero numbers y.
27762 <li> ctanh(NaN + iNaN) returns NaN + iNaN.
27763 <!--page 561 -->
27764 </ul>
27772 <ul>
27773 <li> cexp(conj(z)) = conj(cexp(z)).
27775 <li> cexp(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
27776 exception, for finite x.
27777 <li> cexp(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27778 point exception, for finite x.
27779 <li> cexp(+(inf) + i0) returns +(inf) + i0.
27781 <li> cexp(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
27782 <li> cexp(-(inf) + i (inf)) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts of
27783 the result are unspecified).
27784 <li> cexp(+(inf) + i (inf)) returns (+-)(inf) + iNaN and raises the ''invalid'' floating-point
27785 exception (where the sign of the real part of the result is unspecified).
27786 <li> cexp(-(inf) + iNaN) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts
27787 of the result are unspecified).
27788 <li> cexp(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
27789 is unspecified).
27790 <li> cexp(NaN + i0) returns NaN + i0.
27791 <li> cexp(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27792 point exception, for all nonzero numbers y.
27793 <li> cexp(NaN + iNaN) returns NaN + iNaN.
27794 </ul>
27799 <ul>
27800 <li> clog(conj(z)) = conj(clog(z)).
27802 exception.
27804 exception.
27806 <li> clog(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27807 point exception, for finite x.
27808 <!--page 562 -->
27809 <li> clog(-(inf) + iy) returns +(inf) + ipi , for finite positive-signed y.
27810 <li> clog(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
27813 <li> clog((+-)(inf) + iNaN) returns +(inf) + iNaN.
27814 <li> clog(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27815 point exception, for finite y.
27816 <li> clog(NaN + i (inf)) returns +(inf) + iNaN.
27817 <li> clog(NaN + iNaN) returns NaN + iNaN.
27818 </ul>
27826 The cpow functions raise floating-point exceptions if appropriate for the calculation of
27827 the parts of the result, and may also raise spurious floating-point exceptions.<sup><a href="#note379"><b>379)</b></a></sup>
27830 <p><small><a name="note379" href="#note379">379)</a> This allows cpow( z , c ) to be implemented as cexp(c clog( z )) without precluding
27831 implementations that treat special cases more carefully.
27832 </small>
27837 <ul>
27838 <li> csqrt(conj(z)) = conj(csqrt(z)).
27840 <li> csqrt(x + i (inf)) returns +(inf) + i (inf), for all x (including NaN).
27841 <li> csqrt(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27842 point exception, for finite x.
27844 <li> csqrt(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
27845 <li> csqrt(-(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
27846 result is unspecified).
27847 <li> csqrt(+(inf) + iNaN) returns +(inf) + iNaN.
27848 <li> csqrt(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
27849 point exception, for finite y.
27850 <li> csqrt(NaN + iNaN) returns NaN + iNaN.
27855 <!--page 563 -->
27856 </ul>
27861 Type-generic macros that accept complex arguments also accept imaginary arguments. If
27862 an argument is imaginary, the macro expands to an expression whose type is real,
27863 imaginary, or complex, as appropriate for the particular function: if the argument is
27864 imaginary, then the types of cos, cosh, fabs, carg, cimag, and creal are real; the
27865 types of sin, tan, sinh, tanh, asin, atan, asinh, and atanh are imaginary; and
27866 the types of the others are complex.
27868 Given an imaginary argument, each of the type-generic macros cos, sin, tan, cosh,
27869 sinh, tanh, asin, atan, asinh, atanh is specified by a formula in terms of real
27870 functions:
27871 <!--page 564 -->
27872 <pre>
27873 cos(iy) = cosh(y)
27874 sin(iy) = i sinh(y)
27875 tan(iy) = i tanh(y)
27876 cosh(iy) = cos(y)
27877 sinh(iy) = i sin(y)
27878 tanh(iy) = i tan(y)
27879 asin(iy) = i asinh(y)
27880 atan(iy) = i atanh(y)
27881 asinh(iy) = i asin(y)
27882 atanh(iy) = i atan(y)
27883 </pre>
27887 <pre>
27888 (informative)
27889 Language independent arithmetic
27890 </pre>
27897 IEC 60559 (<a href="#F">annex F</a>) in that it covers integer and diverse floating-point arithmetics.
27902 The relevant C arithmetic types meet the requirements of LIA-1 types if an
27903 implementation adds notification of exceptional arithmetic operations and meets the 1
27904 unit in the last place (ULP) accuracy requirement (LIA-1 subclause <a href="#5.2.8">5.2.8</a>).
27909 The LIA-1 data type Boolean is implemented by the C data type bool with values of
27915 The signed C integer types int, long int, long long int, and the corresponding
27916 unsigned types are compatible with LIA-1. If an implementation adds support for the
27917 LIA-1 exceptional values ''integer_overflow'' and ''undefined'', then those types are
27919 in that overflows or out-of-bounds results silently wrap. An implementation that defines
27920 signed integer types as also being modulo need not detect integer overflow, in which case,
27921 only integer divide-by-zero need be detected.
27923 The parameters for the integer data types can be accessed by the following:
27924 <pre>
27925 maxint INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
27926 ULLONG_MAX
27927 minint INT_MIN, LONG_MIN, LLONG_MIN
27928 </pre>
27930 The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
27931 is always 0 for the unsigned types, and is not provided for those types.
27932 <!--page 565 -->
27937 The integer operations on integer types are the following:
27938 <pre>
27939 addI x + y
27940 subI x - y
27941 mulI x * y
27942 divI, divtI x / y
27943 remI, remtI x % y
27944 negI -x
27945 absI abs(x), labs(x), llabs(x)
27946 eqI x == y
27947 neqI x != y
27948 lssI x < y
27949 leqI x <= y
27950 gtrI x > y
27951 geqI x >= y
27952 </pre>
27953 where x and y are expressions of the same integer type.
27958 The C floating-point types float, double, and long double are compatible with
27960 ''underflow'', ''floating_overflow'', and ''"undefined'', then those types are conformant
27961 with LIA-1. An implementation that uses IEC 60559 floating-point formats and
27962 operations (see <a href="#F">annex F</a>) along with IEC 60559 status flags and traps has LIA-1
27963 conformant types.
27968 The parameters for a floating point data type can be accessed by the following:
27969 <pre>
27970 r FLT_RADIX
27971 p FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG
27972 emax FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP
27973 emin FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP
27974 </pre>
27976 The derived constants for the floating point types are accessed by the following:
27977 <!--page 566 -->
27978 <pre>
27979 fmax FLT_MAX, DBL_MAX, LDBL_MAX
27980 fminN FLT_MIN, DBL_MIN, LDBL_MIN
27981 epsilon FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON
27982 rnd_style FLT_ROUNDS
27983 </pre>
27987 The floating-point operations on floating-point types are the following:
27988 <pre>
27989 addF x + y
27990 subF x - y
27991 mulF x * y
27992 divF x / y
27993 negF -x
27994 absF fabsf(x), fabs(x), fabsl(x)
27995 exponentF 1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
27996 scaleF scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
27997 scalblnf(x, li), scalbln(x, li), scalblnl(x, li)
27998 intpartF modff(x, &y), modf(x, &y), modfl(x, &y)
27999 fractpartF modff(x, &y), modf(x, &y), modfl(x, &y)
28000 eqF x == y
28001 neqF x != y
28002 lssF x < y
28003 leqF x <= y
28004 gtrF x > y
28005 geqF x >= y
28006 </pre>
28007 where x and y are expressions of the same floating point type, n is of type int, and li
28008 is of type long int.
28013 The C Standard requires all floating types to use the same radix and rounding style, so
28014 that only one identifier for each is provided to map to LIA-1.
28016 The FLT_ROUNDS parameter can be used to indicate the LIA-1 rounding styles:
28017 <pre>
28018 truncate FLT_ROUNDS == 0
28019 <!--page 567 -->
28020 nearest FLT_ROUNDS == 1
28021 other FLT_ROUNDS != 0 && FLT_ROUNDS != 1
28022 </pre>
28023 provided that an implementation extends FLT_ROUNDS to cover the rounding style used
28024 in all relevant LIA-1 operations, not just addition as in C.
28029 The LIA-1 type conversions are the following type casts:
28030 <pre>
28031 cvtI' -> I (int)i, (long int)i, (long long int)i,
28032 (unsigned int)i, (unsigned long int)i,
28033 (unsigned long long int)i
28034 cvtF -> I (int)x, (long int)x, (long long int)x,
28035 (unsigned int)x, (unsigned long int)x,
28036 (unsigned long long int)x
28037 cvtI -> F (float)i, (double)i, (long double)i
28038 cvtF' -> F (float)x, (double)x, (long double)x
28039 </pre>
28041 In the above conversions from floating to integer, the use of (cast)x can be replaced with
28042 (cast)round(x), (cast)rint(x), (cast)nearbyint(x), (cast)trunc(x),
28043 (cast)ceil(x), or (cast)floor(x). In addition, C's floating-point to integer
28044 conversion functions, lrint(), llrint(), lround(), and llround(), can be
28045 used. They all meet LIA-1's requirements on floating to integer rounding for in-range
28046 values. For out-of-range values, the conversions shall silently wrap for the modulo types.
28048 The fmod() function is useful for doing silent wrapping to unsigned integer types, e.g.,
28049 fmod( fabs(rint(x)), 65536.0 ) or (0.0 <= (y = fmod( rint(x),
28050 65536.0 )) ? y : 65536.0 + y) will compute an integer value in the range 0.0
28051 to 65535.0 which can then be cast to unsigned short int. But, the
28052 remainder() function is not useful for doing silent wrapping to signed integer types,
28053 e.g., remainder( rint(x), 65536.0 ) will compute an integer value in the
28054 range -32767.0 to +32768.0 which is not, in general, in the range of signed short
28055 int.
28057 C's conversions (casts) from floating-point to floating-point can meet LIA-1
28058 requirements if an implementation uses round-to-nearest (IEC 60559 default).
28060 C's conversions (casts) from integer to floating-point can meet LIA-1 requirements if an
28061 implementation uses round-to-nearest.
28062 <!--page 568 -->
28067 Notification is the process by which a user or program is informed that an exceptional
28068 arithmetic operation has occurred. C's operations are compatible with LIA-1 in that C
28069 allows an implementation to cause a notification to occur when any arithmetic operation
28070 returns an exceptional value as defined in LIA-1 clause 5.
28075 LIA-1 requires at least the following two alternatives for handling of notifications:
28076 setting indicators or trap-and-terminate. LIA-1 allows a third alternative: trap-and-
28077 resume.
28079 An implementation need only support a given notification alternative for the entire
28080 program. An implementation may support the ability to switch between notification
28081 alternatives during execution, but is not required to do so. An implementation can
28082 provide separate selection for each kind of notification, but this is not required.
28084 C allows an implementation to provide notification. C's SIGFPE (for traps) and
28085 FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW (for indicators)
28086 can provide LIA-1 notification.
28088 C's signal handlers are compatible with LIA-1. Default handling of SIGFPE can
28089 provide trap-and-terminate behavior, except for those LIA-1 operations implemented by
28090 math library function calls. User-provided signal handlers for SIGFPE allow for trap-
28091 and-resume behavior with the same constraint.
28098 The following mapping is for floating-point types:
28099 <pre>
28100 undefined FE_INVALID, FE_DIVBYZERO
28101 floating_overflow FE_OVERFLOW
28102 underflow FE_UNDERFLOW
28103 </pre>
28105 The floating-point indicator interrogation and manipulation operations are:
28106 <pre>
28107 set_indicators feraiseexcept(i)
28108 clear_indicators feclearexcept(i)
28109 test_indicators fetestexcept(i)
28110 current_indicators fetestexcept(FE_ALL_EXCEPT)
28111 </pre>
28112 where i is an expression of type int representing a subset of the LIA-1 indicators.
28114 C allows an implementation to provide the following LIA-1 required behavior: at
28115 program termination if any indicator is set the implementation shall send an unambiguous
28116 <!--page 569 -->
28119 LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
28120 This documentation makes that distinction because <a href="#7.6"><fenv.h></a> covers only the floating-
28121 point indicators.
28126 C is compatible with LIA-1's trap requirements for arithmetic operations, but not for
28127 math library functions (which are not permitted to invoke a user's signal handler for
28128 SIGFPE). An implementation can provide an alternative of notification through
28129 termination with a ''hard-to-ignore'' message (see LIA-1 subclause <a href="#6.1.3">6.1.3</a>).
28131 LIA-1 does not require that traps be precise.
28133 C does require that SIGFPE be the signal corresponding to LIA-1 arithmetic exceptions,
28134 if there is any signal raised for them.
28136 C supports signal handlers for SIGFPE and allows trapping of LIA-1 arithmetic
28137 exceptions. When LIA-1 arithmetic exceptions do trap, C's signal-handler mechanism
28138 allows trap-and-terminate (either default implementation behavior or user replacement for
28139 it) or trap-and-resume, at the programmer's option.
28140 <!--page 570 -->
28144 <pre>
28145 (informative)
28146 Common warnings
28147 </pre>
28149 An implementation may generate warnings in many situations, none of which are
28150 specified as part of this International Standard. The following are a few of the more
28151 common situations.
28153 <ul>
28154 <li> A new struct or union type appears in a function prototype (<a href="#6.2.1">6.2.1</a>, <a href="#6.7.2.3">6.7.2.3</a>).
28155 <li> A block with initialization of an object that has automatic storage duration is jumped
28157 <li> An implicit narrowing conversion is encountered, such as the assignment of a long
28158 int or a double to an int, or a pointer to void to a pointer to any type other than
28160 <li> A hexadecimal floating constant cannot be represented exactly in its evaluation format
28162 <li> An integer character constant includes more than one character or a wide character
28165 <li> An ''unordered'' binary operator (not comma, &&, or ||) contains a side effect to an
28166 lvalue in one operand, and a side effect to, or an access to the value of, the identical
28168 <li> A function is called but no prototype has been supplied (<a href="#6.5.2.2">6.5.2.2</a>).
28169 <li> The arguments in a function call do not agree in number and type with those of the
28172 <li> A value is given to an object of an enumerated type other than by assignment of an
28173 enumeration constant that is a member of that type, or an enumeration object that has
28174 the same type, or the value of a function that returns the same enumerated type
28179 <li> A constant expression is used as the controlling expression of a selection statement
28181 <!--page 571 -->
28182 <li> An incorrectly formed preprocessing group is encountered while skipping a
28185 <!--page 572 -->
28186 </ul>
28190 <pre>
28191 (informative)
28192 Portability issues
28193 </pre>
28195 This annex collects some information about portability that appears in this International
28196 Standard.
28201 The following are unspecified:
28202 <ul>
28204 <li> The termination status returned to the hosted environment if the return type of main
28206 <li> The values of objects that are neither lock-free atomic objects nor of type volatile
28207 sig_atomic_t and the state of the floating-point environment, when the
28208 processing of the abstract machine is interrupted by receipt of a signal (<a href="#5.1.2.3">5.1.2.3</a>).
28209 <li> The behavior of the display device if a printing character is written when the active
28211 <li> The behavior of the display device if a backspace character is written when the active
28213 <li> The behavior of the display device if a horizontal tab character is written when the
28214 active position is at or past the last defined horizontal tabulation position (<a href="#5.2.2">5.2.2</a>).
28215 <li> The behavior of the display device if a vertical tab character is written when the active
28216 position is at or past the last defined vertical tabulation position (<a href="#5.2.2">5.2.2</a>).
28217 <li> How an extended source character that does not correspond to a universal character
28218 name counts toward the significant initial characters in an external identifier (<a href="#5.2.4.1">5.2.4.1</a>).
28220 <li> The value of padding bytes when storing values in structures or unions (<a href="#6.2.6.1">6.2.6.1</a>).
28221 <li> The values of bytes that correspond to union members other than the one last stored
28223 <li> The representation used when storing a value in an object that has more than one
28225 <li> The values of any padding bits in integer representations (<a href="#6.2.6.2">6.2.6.2</a>).
28226 <li> Whether certain operators can generate negative zeros and whether a negative zero
28228 <!--page 573 -->
28230 <li> The order in which subexpressions are evaluated and the order in which side effects
28231 take place, except as specified for the function-call (), &&, ||, ? :, and comma
28233 <li> The order in which the function designator, arguments, and subexpressions within the
28235 <li> The order of side effects among compound literal initialization list expressions
28237 <li> The order in which the operands of an assignment operator are evaluated (<a href="#6.5.16">6.5.16</a>).
28238 <li> The alignment of the addressable storage unit allocated to hold a bit-field (<a href="#6.7.2.1">6.7.2.1</a>).
28239 <li> Whether a call to an inline function uses the inline definition or the external definition
28241 <li> Whether or not a size expression is evaluated when it is part of the operand of a
28242 sizeof operator and changing the value of the size expression would not affect the
28244 <li> The order in which any side effects occur among the initialization list expressions in
28247 <li> When a fully expanded macro replacement list contains a function-like macro name
28248 as its last preprocessing token and the next preprocessing token from the source file is
28249 a (, and the fully expanded replacement of that macro ends with the name of the first
28250 macro and the next preprocessing token from the source file is again a (, whether that
28252 <li> The order in which # and ## operations are evaluated during macro substitution
28254 <li> The state of the floating-point status flags when execution passes from a part of the
28255 program translated with FENV_ACCESS ''off'' to a part translated with
28257 <li> The order in which feraiseexcept raises floating-point exceptions, except as
28259 <li> Whether math_errhandling is a macro or an identifier with external linkage
28261 <li> The results of the frexp functions when the specified value is not a floating-point
28263 <!--page 574 -->
28264 <li> The numeric result of the ilogb functions when the correct value is outside the
28265 range of the return type (<a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>).
28266 <li> The result of rounding when the value is out of range (<a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.5">F.10.6.5</a>).
28267 <li> The value stored by the remquo functions in the object pointed to by quo when y is
28269 <li> Whether a comparison macro argument that is represented in a format wider than its
28271 <li> Whether setjmp is a macro or an identifier with external linkage (<a href="#7.13">7.13</a>).
28272 <li> Whether va_copy and va_end are macros or identifiers with external linkage
28274 <li> The hexadecimal digit before the decimal point when a non-normalized floating-point
28275 number is printed with an a or A conversion specifier (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>).
28276 <li> The value of the file position indicator after a successful call to the ungetc function
28277 for a text stream, or the ungetwc function for any stream, until all pushed-back
28278 characters are read or discarded (<a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.29.3.10">7.29.3.10</a>).
28279 <li> The details of the value stored by the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>).
28280 <li> The details of the value returned by the ftell function for a text stream (<a href="#7.21.9.4">7.21.9.4</a>).
28281 <li> Whether the strtod, strtof, strtold, wcstod, wcstof, and wcstold
28282 functions convert a minus-signed sequence to a negative number directly or by
28283 negating the value resulting from converting the corresponding unsigned sequence
28285 <li> The order and contiguity of storage allocated by successive calls to the calloc,
28287 <li> The amount of storage allocated by a successful call to the calloc, malloc, or
28289 <li> Whether a call to the atexit function that does not happen before the exit
28291 <li> Whether a call to the at_quick_exit function that does not happen before the
28293 <li> Which of two elements that compare as equal is matched by the bsearch function
28295 <li> The order of two elements that compare as equal in an array sorted by the qsort
28297 <!--page 575 -->
28298 <li> The encoding of the calendar time returned by the time function (<a href="#7.27.2.4">7.27.2.4</a>).
28299 <li> The characters stored by the strftime or wcsftime function if any of the time
28300 values being converted is outside the normal range (<a href="#7.27.3.5">7.27.3.5</a>, <a href="#7.29.5.1">7.29.5.1</a>).
28301 <li> Whether an encoding error occurs if a wchar_t value that does not correspond to a
28302 member of the extended character set appears in the format string for a function in
28303 <a href="#7.29.2">7.29.2</a> or <a href="#7.29.5">7.29.5</a> and the specified semantics do not require that value to be processed
28305 <li> The conversion state after an encoding error occurs (<a href="#7.29.6.3.2">7.29.6.3.2</a>, <a href="#7.29.6.3.3">7.29.6.3.3</a>, <a href="#7.29.6.4.1">7.29.6.4.1</a>,
28307 <li> The resulting value when the ''invalid'' floating-point exception is raised during
28309 <li> Whether conversion of non-integer IEC 60559 floating values to integer raises the
28311 <li> Whether or when library functions in <a href="#7.12"><math.h></a> raise the ''inexact'' floating-point
28313 <li> Whether or when library functions in <a href="#7.12"><math.h></a> raise an undeserved ''underflow''
28314 floating-point exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
28315 <li> The exponent value stored by frexp for a NaN or infinity (<a href="#F.10.3.4">F.10.3.4</a>).
28316 <li> The numeric result returned by the lrint, llrint, lround, and llround
28317 functions if the rounded value is outside the range of the return type (<a href="#F.10.6.5">F.10.6.5</a>,
28319 <li> The sign of one part of the complex result of several math functions for certain
28320 special cases in IEC 60559 compatible implementations (<a href="#G.6.1.1">G.6.1.1</a>, <a href="#G.6.2.2">G.6.2.2</a>, <a href="#G.6.2.3">G.6.2.3</a>,
28321 <a href="#G.6.2.4">G.6.2.4</a>, <a href="#G.6.2.5">G.6.2.5</a>, <a href="#G.6.2.6">G.6.2.6</a>, <a href="#G.6.3.1">G.6.3.1</a>, <a href="#G.6.4.2">G.6.4.2</a>).
28322 </ul>
28327 The behavior is undefined in the following circumstances:
28328 <ul>
28329 <li> A ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated
28330 (clause 4).
28331 <li> A nonempty source file does not end in a new-line character which is not immediately
28332 preceded by a backslash character or ends in a partial preprocessing token or
28334 <li> Token concatenation produces a character sequence matching the syntax of a
28336 <li> A program in a hosted environment does not define a function named main using one
28338 <!--page 576 -->
28340 <li> A character not in the basic source character set is encountered in a source file, except
28341 in an identifier, a character constant, a string literal, a header name, a comment, or a
28343 <li> An identifier, comment, string literal, character constant, or header name contains an
28344 invalid multibyte character or does not begin and end in the initial shift state (<a href="#5.2.1.2">5.2.1.2</a>).
28345 <li> The same identifier has both internal and external linkage in the same translation unit
28348 <li> The value of a pointer to an object whose lifetime has ended is used (<a href="#6.2.4">6.2.4</a>).
28349 <li> The value of an object with automatic storage duration is used while it is
28350 indeterminate (<a href="#6.2.4">6.2.4</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8">6.8</a>).
28351 <li> A trap representation is read by an lvalue expression that does not have character type
28353 <li> A trap representation is produced by a side effect that modifies any part of the object
28354 using an lvalue expression that does not have character type (<a href="#6.2.6.1">6.2.6.1</a>).
28355 <li> The operands to certain operators are such that they could produce a negative zero
28356 result, but the implementation does not support negative zeros (<a href="#6.2.6.2">6.2.6.2</a>).
28357 <li> Two declarations of the same object or function specify types that are not compatible
28359 <li> A program requires the formation of a composite type from a variable length array
28360 type whose size is specified by an expression that is not evaluated (<a href="#6.2.7">6.2.7</a>).
28361 <li> Conversion to or from an integer type produces a value outside the range that can be
28363 <li> Demotion of one real floating type to another produces a value outside the range that
28366 <li> A non-array lvalue with an incomplete type is used in a context that requires the value
28368 <li> An lvalue designating an object of automatic storage duration that could have been
28369 declared with the register storage class is used in a context that requires the value
28371 <li> An lvalue having array type is converted to a pointer to the initial element of the
28373 <!--page 577 -->
28374 <li> An attempt is made to use the value of a void expression, or an implicit or explicit
28376 <li> Conversion of a pointer to an integer type produces a value outside the range that can
28378 <li> Conversion between two pointer types produces a result that is incorrectly aligned
28380 <li> A pointer is used to call a function whose type is not compatible with the referenced
28382 <li> An unmatched ' or " character is encountered on a logical source line during
28386 <li> A universal character name in an identifier does not designate a character whose
28388 <li> The initial character of an identifier is a universal character name designating a digit
28390 <li> Two identifiers differ only in nonsignificant characters (<a href="#6.4.2.1">6.4.2.1</a>).
28394 delimiters, or the characters ', \, //, or /* occur in the sequence between the "
28396 <li> A side effect on a scalar object is unsequenced relative to either a different side effect
28397 on the same scalar object or a value computation using the value of the same scalar
28399 <li> An exceptional condition occurs during the evaluation of an expression (<a href="#6.5">6.5</a>).
28400 <li> An object has its stored value accessed other than by an lvalue of an allowable type
28402 <li> For a call to a function without a function prototype in scope, the number of
28404 <li> For call to a function without a function prototype in scope where the function is
28405 defined with a function prototype, either the prototype ends with an ellipsis or the
28406 types of the arguments after promotion are not compatible with the types of the
28408 <!--page 578 -->
28409 <li> For a call to a function without a function prototype in scope where the function is not
28410 defined with a function prototype, the types of the arguments after promotion are not
28411 compatible with those of the parameters after promotion (with certain exceptions)
28413 <li> A function is defined with a type that is not compatible with the type (of the
28414 expression) pointed to by the expression that denotes the called function (<a href="#6.5.2.2">6.5.2.2</a>).
28416 <li> The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
28417 <li> A pointer is converted to other than an integer or pointer type (<a href="#6.5.4">6.5.4</a>).
28418 <li> The value of the second operand of the / or % operator is zero (<a href="#6.5.5">6.5.5</a>).
28419 <li> Addition or subtraction of a pointer into, or just beyond, an array object and an
28420 integer type produces a result that does not point into, or just beyond, the same array
28422 <li> Addition or subtraction of a pointer into, or just beyond, an array object and an
28423 integer type produces a result that points just beyond the array object and is used as
28425 <li> Pointers that do not point into, or just beyond, the same array object are subtracted
28427 <li> An array subscript is out of range, even if an object is apparently accessible with the
28430 <li> The result of subtracting two pointers is not representable in an object of type
28432 <li> An expression is shifted by a negative number or by an amount greater than or equal
28434 <li> An expression having signed promoted type is left-shifted and either the value of the
28435 expression is negative or the result of shifting would be not be representable in the
28437 <li> Pointers that do not point to the same aggregate or union (nor just beyond the same
28439 <li> An object is assigned to an inexactly overlapping object or to an exactly overlapping
28441 <li> An expression that is required to be an integer constant expression does not have an
28442 integer type; has operands that are not integer constants, enumeration constants,
28443 character constants, sizeof expressions whose results are integer constants,
28444 <!--page 579 -->
28445 _Alignof expressions, or immediately-cast floating constants; or contains casts
28446 (outside operands to sizeof and _Alignof operators) other than conversions of
28448 <li> A constant expression in an initializer is not, or does not evaluate to, one of the
28449 following: an arithmetic constant expression, a null pointer constant, an address
28450 constant, or an address constant for a complete object type plus or minus an integer
28452 <li> An arithmetic constant expression does not have arithmetic type; has operands that
28453 are not integer constants, floating constants, enumeration constants, character
28454 constants, sizeof expressions whose results are integer constants, or _Alignof
28455 expressions; or contains casts (outside operands to sizeof or _Alignof operators)
28458 address &, or indirection * operator or a pointer cast in creating an address constant
28460 <li> An identifier for an object is declared with no linkage and the type of the object is
28461 incomplete after its declarator, or after its init-declarator if it has an initializer (<a href="#6.7">6.7</a>).
28462 <li> A function is declared at block scope with an explicit storage-class specifier other
28464 <li> A structure or union is defined without any named members (including those
28466 <li> An attempt is made to access, or generate a pointer to just past, a flexible array
28467 member of a structure when the referenced object provides no elements for that array
28469 <li> When the complete type is needed, an incomplete structure or union type is not
28470 completed in the same scope by another declaration of the tag that defines the content
28472 <li> An attempt is made to modify an object defined with a const-qualified type through
28474 <li> An attempt is made to refer to an object defined with a volatile-qualified type through
28476 <li> The specification of a function type includes any type qualifiers (<a href="#6.7.3">6.7.3</a>).
28477 <li> Two qualified types that are required to be compatible do not have the identically
28479 <li> An object which has been modified is accessed through a restrict-qualified pointer to
28480 a const-qualified type, or through a restrict-qualified pointer and another pointer that
28481 <!--page 580 -->
28483 <li> A restrict-qualified pointer is assigned a value based on another restricted pointer
28484 whose associated block neither began execution before the block associated with this
28486 <li> A function with external linkage is declared with an inline function specifier, but is
28488 <li> A function declared with a _Noreturn function specifier returns to its caller (<a href="#6.7.4">6.7.4</a>).
28489 <li> The definition of an object has an alignment specifier and another declaration of that
28491 <li> Declarations of an object in different translation units have different alignment
28493 <li> Two pointer types that are required to be compatible are not identically qualified, or
28495 <li> The size expression in an array declaration is not a constant expression and evaluates
28497 <li> In a context requiring two array types to be compatible, they do not have compatible
28498 element types, or their size specifiers evaluate to unequal values (<a href="#6.7.6.2">6.7.6.2</a>).
28499 <li> A declaration of an array parameter includes the keyword static within the [ and
28500 ] and the corresponding argument does not provide access to the first element of an
28502 <li> A storage-class specifier or type qualifier modifies the keyword void as a function
28504 <li> In a context requiring two function types to be compatible, they do not have
28505 compatible return types, or their parameters disagree in use of the ellipsis terminator
28506 or the number and type of parameters (after default argument promotion, when there
28507 is no parameter type list or when one type is specified by a function definition with an
28509 <li> The value of an unnamed member of a structure or union is used (<a href="#6.7.9">6.7.9</a>).
28510 <li> The initializer for a scalar is neither a single expression nor a single expression
28512 <li> The initializer for a structure or union object that has automatic storage duration is
28513 neither an initializer list nor a single expression that has compatible structure or union
28515 <li> The initializer for an aggregate or union, other than an array initialized by a string
28516 literal, is not a brace-enclosed list of initializers for its elements or members (<a href="#6.7.9">6.7.9</a>).
28517 <!--page 581 -->
28518 <li> An identifier with external linkage is used, but in the program there does not exist
28519 exactly one external definition for the identifier, or the identifier is not used and there
28521 <li> A function definition includes an identifier list, but the types of the parameters are not
28523 <li> An adjusted parameter type in a function definition is not a complete object type
28525 <li> A function that accepts a variable number of arguments is defined without a
28527 <li> The } that terminates a function is reached, and the value of the function call is used
28529 <li> An identifier for an object with internal linkage and an incomplete type is declared
28531 <li> The token defined is generated during the expansion of a #if or #elif
28532 preprocessing directive, or the use of the defined unary operator does not match
28534 <li> The #include preprocessing directive that results after expansion does not match
28536 <li> The character sequence in an #include preprocessing directive does not start with a
28538 <li> There are sequences of preprocessing tokens within the list of macro arguments that
28540 <li> The result of the preprocessing operator # is not a valid character string literal
28542 <li> The result of the preprocessing operator ## is not a valid preprocessing token
28544 <li> The #line preprocessing directive that results after expansion does not match one of
28545 the two well-defined forms, or its digit sequence specifies zero or a number greater
28547 <li> A non-STDC #pragma preprocessing directive that is documented as causing
28548 translation failure or some other form of undefined behavior is encountered (<a href="#6.10.6">6.10.6</a>).
28549 <li> A #pragma STDC preprocessing directive does not match one of the well-defined
28551 <li> The name of a predefined macro, or the identifier defined, is the subject of a
28553 <!--page 582 -->
28554 <li> An attempt is made to copy an object to an overlapping object by use of a library
28555 function, other than as explicitly allowed (e.g., memmove) (clause 7).
28556 <li> A file with the same name as one of the standard headers, not provided as part of the
28557 implementation, is placed in any of the standard places that are searched for included
28559 <li> A header is included within an external declaration or definition (<a href="#7.1.2">7.1.2</a>).
28560 <li> A function, object, type, or macro that is specified as being declared or defined by
28561 some standard header is used before any header that declares or defines it is included
28563 <li> A standard header is included while a macro is defined with the same name as a
28565 <li> The program attempts to declare a library function itself, rather than via a standard
28567 <li> The program declares or defines a reserved identifier, other than as allowed by <a href="#7.1.4">7.1.4</a>
28569 <li> The program removes the definition of a macro whose name begins with an
28571 <li> An argument to a library function has an invalid value or a type not expected by a
28573 <li> The pointer passed to a library function array parameter does not have a value such
28575 <li> The macro definition of assert is suppressed in order to access an actual function
28578 <li> The CX_LIMITED_RANGE, FENV_ACCESS, or FP_CONTRACT pragma is used in
28579 any context other than outside all external declarations or preceding all explicit
28580 declarations and statements inside a compound statement (<a href="#7.3.4">7.3.4</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.12.2">7.12.2</a>).
28581 <li> The value of an argument to a character handling function is neither equal to the value
28583 <li> A macro definition of errno is suppressed in order to access an actual object, or the
28585 <li> Part of the program tests floating-point status flags, sets floating-point control modes,
28586 or runs under non-default mode settings, but was translated with the state for the
28588 <!--page 583 -->
28589 <li> The exception-mask argument for one of the functions that provide access to the
28590 floating-point status flags has a nonzero value not obtained by bitwise OR of the
28592 <li> The fesetexceptflag function is used to set floating-point status flags that were
28593 not specified in the call to the fegetexceptflag function that provided the value
28595 <li> The argument to fesetenv or feupdateenv is neither an object set by a call to
28596 fegetenv or feholdexcept, nor is it an environment macro (<a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>).
28597 <li> The value of the result of an integer arithmetic or conversion function cannot be
28598 represented (<a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.22.6.1">7.22.6.1</a>, <a href="#7.22.6.2">7.22.6.2</a>, <a href="#7.22.1">7.22.1</a>).
28599 <li> The program modifies the string pointed to by the value returned by the setlocale
28601 <li> The program modifies the structure pointed to by the value returned by the
28603 <li> A macro definition of math_errhandling is suppressed or the program defines
28605 <li> An argument to a floating-point classification or comparison macro is not of real
28607 <li> A macro definition of setjmp is suppressed in order to access an actual function, or
28609 <li> An invocation of the setjmp macro occurs other than in an allowed context
28611 <li> The longjmp function is invoked to restore a nonexistent environment (<a href="#7.13.2.1">7.13.2.1</a>).
28612 <li> After a longjmp, there is an attempt to access the value of an object of automatic
28613 storage duration that does not have volatile-qualified type, local to the function
28614 containing the invocation of the corresponding setjmp macro, that was changed
28616 <li> The program specifies an invalid pointer to a signal handler function (<a href="#7.14.1.1">7.14.1.1</a>).
28617 <li> A signal handler returns when the signal corresponded to a computational exception
28619 <li> A signal handler called in response to SIGFPE, SIGILL, SIGSEGV, or any other
28620 implementation-defined value corresponding to a computational exception returns
28622 <li> A signal occurs as the result of calling the abort or raise function, and the signal
28624 <!--page 584 -->
28625 <li> A signal occurs other than as the result of calling the abort or raise function, and
28626 the signal handler refers to an object with static or thread storage duration that is not a
28627 lock-free atomic object other than by assigning a value to an object declared as
28628 volatile sig_atomic_t, or calls any function in the standard library other
28629 than the abort function, the _Exit function, the quick_exit function, or the
28631 <li> The value of errno is referred to after a signal occurred other than as the result of
28632 calling the abort or raise function and the corresponding signal handler obtained
28634 <li> A signal is generated by an asynchronous signal handler (<a href="#7.14.1.1">7.14.1.1</a>).
28635 <li> The signal function is used in a multi-threaded program (<a href="#7.14.1.1">7.14.1.1</a>).
28636 <li> A function with a variable number of arguments attempts to access its varying
28637 arguments other than through a properly declared and initialized va_list object, or
28638 before the va_start macro is invoked (<a href="#7.16">7.16</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.4">7.16.1.4</a>).
28639 <li> The macro va_arg is invoked using the parameter ap that was passed to a function
28641 <li> A macro definition of va_start, va_arg, va_copy, or va_end is suppressed in
28642 order to access an actual function, or the program defines an external identifier with
28644 <li> The va_start or va_copy macro is invoked without a corresponding invocation
28645 of the va_end macro in the same function, or vice versa (<a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>,
28647 <li> The type parameter to the va_arg macro is not such that a pointer to an object of
28649 <li> The va_arg macro is invoked when there is no actual next argument, or with a
28650 specified type that is not compatible with the promoted type of the actual next
28652 <li> The va_copy or va_start macro is called to initialize a va_list that was
28653 previously initialized by either macro without an intervening invocation of the
28654 va_end macro for the same va_list (<a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.4">7.16.1.4</a>).
28655 <li> The parameter parmN of a va_start macro is declared with the register
28656 storage class, with a function or array type, or with a type that is not compatible with
28657 the type that results after application of the default argument promotions (<a href="#7.16.1.4">7.16.1.4</a>).
28658 <li> The member designator parameter of an offsetof macro is an invalid right
28659 operand of the . operator for the type parameter, or designates a bit-field (<a href="#7.19">7.19</a>).
28660 <!--page 585 -->
28661 <li> The argument in an instance of one of the integer-constant macros is not a decimal,
28662 octal, or hexadecimal constant, or it has a value that exceeds the limits for the
28664 <li> A byte input/output function is applied to a wide-oriented stream, or a wide character
28666 <li> Use is made of any portion of a file beyond the most recent wide character written to
28668 <li> The value of a pointer to a FILE object is used after the associated file is closed
28670 <li> The stream for the fflush function points to an input stream or to an update stream
28672 <li> The string pointed to by the mode argument in a call to the fopen function does not
28674 <li> An output operation on an update stream is followed by an input operation without an
28675 intervening call to the fflush function or a file positioning function, or an input
28676 operation on an update stream is followed by an output operation with an intervening
28678 <li> An attempt is made to use the contents of the array that was supplied in a call to the
28680 <li> There are insufficient arguments for the format in a call to one of the formatted
28681 input/output functions, or an argument does not have an appropriate type (<a href="#7.21.6.1">7.21.6.1</a>,
28682 <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>).
28683 <li> The format in a call to one of the formatted input/output functions or to the
28684 strftime or wcsftime function is not a valid multibyte character sequence that
28685 begins and ends in its initial shift state (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.27.3.5">7.27.3.5</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>,
28687 <li> In a call to one of the formatted output functions, a precision appears with a
28688 conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>).
28689 <li> A conversion specification for a formatted output function uses an asterisk to denote
28690 an argument-supplied field width or precision, but the corresponding argument is not
28693 conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>).
28694 <li> A conversion specification for one of the formatted input/output functions uses a
28695 length modifier with a conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>,
28696 <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>).
28697 <!--page 586 -->
28698 <li> An s conversion specifier is encountered by one of the formatted output functions,
28699 and the argument is missing the null terminator (unless a precision is specified that
28700 does not require null termination) (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>).
28701 <li> An n conversion specification for one of the formatted input/output functions includes
28702 any flags, an assignment-suppressing character, a field width, or a precision (<a href="#7.21.6.1">7.21.6.1</a>,
28703 <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>).
28704 <li> A % conversion specifier is encountered by one of the formatted input/output
28705 functions, but the complete conversion specification is not exactly %% (<a href="#7.21.6.1">7.21.6.1</a>,
28706 <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>).
28707 <li> An invalid conversion specification is found in the format for one of the formatted
28708 input/output functions, or the strftime or wcsftime function (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
28709 <a href="#7.27.3.5">7.27.3.5</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#7.29.5.1">7.29.5.1</a>).
28710 <li> The number of characters or wide characters transmitted by a formatted output
28711 function (or written to an array, or that would have been written to an array) is greater
28713 <li> The number of input items assigned by a formatted input function is greater than
28715 <li> The result of a conversion by one of the formatted input functions cannot be
28716 represented in the corresponding object, or the receiving object does not have an
28718 <li> A c, s, or [ conversion specifier is encountered by one of the formatted input
28719 functions, and the array pointed to by the corresponding argument is not large enough
28720 to accept the input sequence (and a null terminator if the conversion specifier is s or
28722 <li> A c, s, or [ conversion specifier with an l qualifier is encountered by one of the
28723 formatted input functions, but the input is not a valid multibyte character sequence
28724 that begins in the initial shift state (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a>).
28725 <li> The input item for a %p conversion by one of the formatted input functions is not a
28726 value converted earlier during the same program execution (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a>).
28727 <li> The vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf,
28728 vsscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, or
28729 vwscanf function is called with an improperly initialized va_list argument, or
28730 the argument is used (other than in an invocation of va_end) after the function
28731 returns (<a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
28732 <a href="#7.29.2.5">7.29.2.5</a>, <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.2.7">7.29.2.7</a>, <a href="#7.29.2.8">7.29.2.8</a>, <a href="#7.29.2.9">7.29.2.9</a>, <a href="#7.29.2.10">7.29.2.10</a>).
28733 <li> The contents of the array supplied in a call to the fgets or fgetws function are
28734 used after a read error occurred (<a href="#7.21.7.2">7.21.7.2</a>, <a href="#7.29.3.2">7.29.3.2</a>).
28735 <!--page 587 -->
28736 <li> The file position indicator for a binary stream is used after a call to the ungetc
28738 <li> The file position indicator for a stream is used after an error occurred during a call to
28739 the fread or fwrite function (<a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>).
28740 <li> A partial element read by a call to the fread function is used (<a href="#7.21.8.1">7.21.8.1</a>).
28741 <li> The fseek function is called for a text stream with a nonzero offset and either the
28742 offset was not returned by a previous successful call to the ftell function on a
28743 stream associated with the same file or whence is not SEEK_SET (<a href="#7.21.9.2">7.21.9.2</a>).
28744 <li> The fsetpos function is called to set a position that was not returned by a previous
28745 successful call to the fgetpos function on a stream associated with the same file
28747 <li> A non-null pointer returned by a call to the calloc, malloc, or realloc function
28749 <li> The value of a pointer that refers to space deallocated by a call to the free or
28751 <li> The alignment requested of the aligned_alloc function is not valid or not
28752 supported by the implementation, or the size requested is not an integral multiple of
28754 <li> The pointer argument to the free or realloc function does not match a pointer
28755 earlier returned by a memory management function, or the space has been deallocated
28756 by a call to free or realloc (<a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>).
28757 <li> The value of the object allocated by the malloc function is used (<a href="#7.22.3.4">7.22.3.4</a>).
28758 <li> The value of any bytes in a new object allocated by the realloc function beyond
28760 <li> The program calls the exit or quick_exit function more than once, or calls both
28762 <li> During the call to a function registered with the atexit or at_quick_exit
28763 function, a call is made to the longjmp function that would terminate the call to the
28765 <li> The string set up by the getenv or strerror function is modified by the program
28767 <li> A signal is raised while the quick_exit function is executing (<a href="#7.22.4.7">7.22.4.7</a>).
28768 <li> A command is executed through the system function in a way that is documented as
28769 causing termination or some other form of undefined behavior (<a href="#7.22.4.8">7.22.4.8</a>).
28770 <!--page 588 -->
28771 <li> A searching or sorting utility function is called with an invalid pointer argument, even
28773 <li> The comparison function called by a searching or sorting utility function alters the
28774 contents of the array being searched or sorted, or returns ordering values
28776 <li> The array being searched by the bsearch function does not have its elements in
28778 <li> The current conversion state is used by a multibyte/wide character conversion
28780 <li> A string or wide string utility function is instructed to access an array beyond the end
28782 <li> A string or wide string utility function is called with an invalid pointer argument, even
28784 <li> The contents of the destination array are used after a call to the strxfrm,
28785 strftime, wcsxfrm, or wcsftime function in which the specified length was
28786 too small to hold the entire null-terminated result (<a href="#7.24.4.5">7.24.4.5</a>, <a href="#7.27.3.5">7.27.3.5</a>, <a href="#7.29.4.4.4">7.29.4.4.4</a>,
28788 <li> The first argument in the very first call to the strtok or wcstok is a null pointer
28790 <li> The type of an argument to a type-generic macro is not compatible with the type of
28792 <li> A complex argument is supplied for a generic parameter of a type-generic macro that
28794 <li> At least one member of the broken-down time passed to asctime contains a value
28795 outside its normal range, or the calculated year exceeds four digits or is less than the
28797 <li> The argument corresponding to an s specifier without an l qualifier in a call to the
28798 fwprintf function does not point to a valid multibyte character sequence that
28800 <li> In a call to the wcstok function, the object pointed to by ptr does not have the
28801 value stored by the previous call for the same wide string (<a href="#7.29.4.5.7">7.29.4.5.7</a>).
28803 <li> The value of an argument of type wint_t to a wide character classification or case
28804 mapping function is neither equal to the value of WEOF nor representable as a
28806 <!--page 589 -->
28807 <li> The iswctype function is called using a different LC_CTYPE category from the
28808 one in effect for the call to the wctype function that returned the description
28810 <li> The towctrans function is called using a different LC_CTYPE category from the
28811 one in effect for the call to the wctrans function that returned the description
28813 </ul>
28818 A conforming implementation is required to document its choice of behavior in each of
28819 the areas listed in this subclause. The following are implementation-defined:
28824 <ul>
28825 <li> How a diagnostic is identified (<a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>).
28826 <li> Whether each nonempty sequence of white-space characters other than new-line is
28827 retained or replaced by one space character in translation phase 3 (<a href="#5.1.1.2">5.1.1.2</a>).
28828 </ul>
28833 <ul>
28834 <li> The mapping between physical source file multibyte characters and the source
28836 <li> The name and type of the function called at program startup in a freestanding
28838 <li> The effect of program termination in a freestanding environment (<a href="#5.1.2.1">5.1.2.1</a>).
28839 <li> An alternative manner in which the main function may be defined (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
28840 <li> The values given to the strings pointed to by the argv argument to main (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
28842 <li> Whether a program can have more than one thread of execution in a freestanding
28844 <li> The set of signals, their semantics, and their default handling (<a href="#7.14">7.14</a>).
28845 <li> Signal values other than SIGFPE, SIGILL, and SIGSEGV that correspond to a
28847 <li> Signals for which the equivalent of signal(sig, SIG_IGN); is executed at
28849 <li> The set of environment names and the method for altering the environment list used
28851 <li> The manner of execution of the string by the system function (<a href="#7.22.4.8">7.22.4.8</a>).
28852 <!--page 590 -->
28853 </ul>
28858 <ul>
28859 <li> Which additional multibyte characters may appear in identifiers and their
28861 <li> The number of significant initial characters in an identifier (<a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2">6.4.2</a>).
28862 </ul>
28867 <ul>
28870 <li> The unique value of the member of the execution character set produced for each of
28872 <li> The value of a char object into which has been stored any character other than a
28874 <li> Which of signed char or unsigned char has the same range, representation,
28876 <li> The mapping of members of the source character set (in character constants and string
28877 literals) to members of the execution character set (<a href="#6.4.4.4">6.4.4.4</a>, <a href="#5.1.1.2">5.1.1.2</a>).
28878 <li> The value of an integer character constant containing more than one character or
28879 containing a character or escape sequence that does not map to a single-byte
28881 <li> The value of a wide character constant containing more than one multibyte character
28882 or a single multibyte character that maps to multiple members of the extended
28883 execution character set, or containing a multibyte character or escape sequence not
28885 <li> The current locale used to convert a wide character constant consisting of a single
28886 multibyte character that maps to a member of the extended execution character set
28888 <li> Whether differently-prefixed wide string literal tokens can be concatenated and, if so,
28890 <li> The current locale used to convert a wide string literal into corresponding wide
28892 <li> The value of a string literal containing a multibyte character or escape sequence not
28894 <li> The encoding of any of wchar_t, char16_t, and char32_t where the
28895 corresponding standard encoding macro (__STDC_ISO_10646__,
28897 <!--page 591 -->
28898 </ul>
28903 <ul>
28904 <li> Any extended integer types that exist in the implementation (<a href="#6.2.5">6.2.5</a>).
28905 <li> Whether signed integer types are represented using sign and magnitude, two's
28906 complement, or ones' complement, and whether the extraordinary value is a trap
28908 <li> The rank of any extended integer type relative to another extended integer type with
28910 <li> The result of, or the signal raised by, converting an integer to a signed integer type
28911 when the value cannot be represented in an object of that type (<a href="#6.3.1.3">6.3.1.3</a>).
28913 </ul>
28918 <ul>
28919 <li> The accuracy of the floating-point operations and of the library functions in
28920 <a href="#7.12"><math.h></a> and <a href="#7.3"><complex.h></a> that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
28921 <li> The accuracy of the conversions between floating-point internal representations and
28922 string representations performed by the library functions in <a href="#7.21"><stdio.h></a>,
28923 <a href="#7.22"><stdlib.h></a>, and <a href="#7.29"><wchar.h></a> (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
28924 <li> The rounding behaviors characterized by non-standard values of FLT_ROUNDS
28926 <li> The evaluation methods characterized by non-standard negative values of
28928 <li> The direction of rounding when an integer is converted to a floating-point number that
28930 <li> The direction of rounding when a floating-point number is converted to a narrower
28932 <li> How the nearest representable value or the larger or smaller representable value
28933 immediately adjacent to the nearest representable value is chosen for certain floating
28935 <li> Whether and how floating expressions are contracted when not disallowed by the
28938 <li> Additional floating-point exceptions, rounding modes, environments, and
28941 <!--page 592 -->
28942 </ul>
28947 <ul>
28948 <li> The result of converting a pointer to an integer or vice versa (<a href="#6.3.2.3">6.3.2.3</a>).
28949 <li> The size of the result of subtracting two pointers to elements of the same array
28951 </ul>
28956 <ul>
28957 <li> The extent to which suggestions made by using the register storage-class
28959 <li> The extent to which suggestions made by using the inline function specifier are
28961 </ul>
28964 <h4><a name="J.3.9" href="#J.3.9">J.3.9 Structures, unions, enumerations, and bit-fields</a></h4>
28966 <ul>
28967 <li> Whether a ''plain'' int bit-field is treated as a signed int bit-field or as an
28969 <li> Allowable bit-field types other than _Bool, signed int, and unsigned int
28972 <li> Whether a bit-field can straddle a storage-unit boundary (<a href="#6.7.2.1">6.7.2.1</a>).
28974 <li> The alignment of non-bit-field members of structures (<a href="#6.7.2.1">6.7.2.1</a>). This should present
28975 no problem unless binary data written by one implementation is read by another.
28977 </ul>
28982 <ul>
28983 <li> What constitutes an access to an object that has volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
28984 </ul>
28989 <ul>
28990 <li> The locations within #pragma directives where header name preprocessing tokens
28992 <li> How sequences in both forms of header names are mapped to headers or external
28994 <li> Whether the value of a character constant in a constant expression that controls
28995 conditional inclusion matches the value of the same character constant in the
28997 <li> Whether the value of a single-character character constant in a constant expression
28999 <!--page 593 -->
29000 <li> The places that are searched for an included < > delimited header, and how the places
29004 <li> The method by which preprocessing tokens (possibly resulting from macro
29005 expansion) in a #include directive are combined into a header name (<a href="#6.10.2">6.10.2</a>).
29007 <li> Whether the # operator inserts a \ character before the \ character that begins a
29008 universal character name in a character constant or string literal (<a href="#6.10.3.2">6.10.3.2</a>).
29009 <li> The behavior on each recognized non-STDC #pragma directive (<a href="#6.10.6">6.10.6</a>).
29010 <li> The definitions for __DATE__ and __TIME__ when respectively, the date and
29012 </ul>
29017 <ul>
29018 <li> Any library facilities available to a freestanding program, other than the minimal set
29020 <li> The format of the diagnostic printed by the assert macro (<a href="#7.2.1.1">7.2.1.1</a>).
29021 <li> The representation of the floating-point status flags stored by the
29023 <li> Whether the feraiseexcept function raises the ''inexact'' floating-point
29024 exception in addition to the ''overflow'' or ''underflow'' floating-point exception
29028 <li> The types defined for float_t and double_t when the value of the
29030 <li> Domain errors for the mathematics functions, other than those required by this
29032 <li> The values returned by the mathematics functions on domain errors or pole errors
29034 <li> The values returned by the mathematics functions on underflow range errors, whether
29035 errno is set to the value of the macro ERANGE when the integer expression
29036 math_errhandling & MATH_ERRNO is nonzero, and whether the ''underflow''
29037 floating-point exception is raised when the integer expression math_errhandling
29039 <!--page 594 -->
29040 <li> Whether a domain error occurs or zero is returned when an fmod function has a
29042 <li> Whether a domain error occurs or zero is returned when a remainder function has
29046 <li> Whether a domain error occurs or zero is returned when a remquo function has a
29048 <li> Whether the equivalent of signal(sig, SIG_DFL); is executed prior to the call
29049 of a signal handler, and, if not, the blocking of signals that is performed (<a href="#7.14.1.1">7.14.1.1</a>).
29051 <li> Whether the last line of a text stream requires a terminating new-line character
29053 <li> Whether space characters that are written out to a text stream immediately before a
29055 <li> The number of null characters that may be appended to data written to a binary
29057 <li> Whether the file position indicator of an append-mode stream is initially positioned at
29059 <li> Whether a write on a text stream causes the associated file to be truncated beyond that
29064 <li> Whether the same file can be simultaneously open multiple times (<a href="#7.21.3">7.21.3</a>).
29065 <li> The nature and choice of encodings used for multibyte characters in files (<a href="#7.21.3">7.21.3</a>).
29067 <li> The effect if a file with the new name exists prior to a call to the rename function
29069 <li> Whether an open temporary file is removed upon abnormal program termination
29071 <li> Which changes of mode are permitted (if any), and under what circumstances
29073 <!--page 595 -->
29074 <li> The style used to print an infinity or NaN, and the meaning of any n-char or n-wchar
29075 sequence printed for a NaN (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>).
29076 <li> The output for %p conversion in the fprintf or fwprintf function (<a href="#7.21.6.1">7.21.6.1</a>,
29078 <li> The interpretation of a - character that is neither the first nor the last character, nor
29079 the second where a ^ character is the first, in the scanlist for %[ conversion in the
29080 fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>).
29081 <li> The set of sequences matched by a %p conversion and the interpretation of the
29082 corresponding input item in the fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a>).
29083 <li> The value to which the macro errno is set by the fgetpos, fsetpos, or ftell
29084 functions on failure (<a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>).
29085 <li> The meaning of any n-char or n-wchar sequence in a string representing a NaN that is
29086 converted by the strtod, strtof, strtold, wcstod, wcstof, or wcstold
29088 <li> Whether or not the strtod, strtof, strtold, wcstod, wcstof, or wcstold
29089 function sets errno to ERANGE when underflow occurs (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.29.4.1.1">7.29.4.1.1</a>).
29090 <li> Whether the calloc, malloc, and realloc functions return a null pointer or a
29091 pointer to an allocated object when the size requested is zero (<a href="#7.22.3">7.22.3</a>).
29092 <li> Whether open streams with unwritten buffered data are flushed, open streams are
29093 closed, or temporary files are removed when the abort or _Exit function is called
29095 <li> The termination status returned to the host environment by the abort, exit,
29096 _Exit, or quick_exit function (<a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>).
29097 <li> The value returned by the system function when its argument is not a null pointer
29099 <li> The range and precision of times representable in clock_t and time_t (<a href="#7.27">7.27</a>). *
29103 <li> The replacement string for the %Z specifier to the strftime, and wcsftime
29104 functions in the "C" locale (<a href="#7.27.3.5">7.27.3.5</a>, <a href="#7.29.5.1">7.29.5.1</a>).
29105 <li> Whether the functions in <a href="#7.12"><math.h></a> honor the rounding direction mode in an
29106 IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.10">F.10</a>).
29107 <!--page 596 -->
29108 </ul>
29113 <ul>
29114 <li> The values or expressions assigned to the macros specified in the headers
29115 <a href="#7.7"><float.h></a>, <a href="#7.10"><limits.h></a>, and <a href="#7.20"><stdint.h></a> (<a href="#5.2.4.2">5.2.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>).
29116 <li> The result of attempting to indirectly access an object with automatic or thread
29117 storage duration from a thread other than the one with which it is associated (<a href="#6.2.4">6.2.4</a>).
29118 <li> The number, order, and encoding of bytes in any object (when not explicitly specified
29120 <li> Whether any extended alignments are supported and the contexts in which they are
29122 <li> Valid alignment values other than those returned by an _Alignof expression for
29124 <li> The value of the result of the sizeof and _Alignof operators (<a href="#6.5.3.4">6.5.3.4</a>).
29125 </ul>
29130 The following characteristics of a hosted environment are locale-specific and are required
29131 to be documented by the implementation:
29132 <ul>
29133 <li> Additional members of the source and execution character sets beyond the basic
29135 <li> The presence, meaning, and representation of additional multibyte characters in the
29137 <li> The shift states used for the encoding of multibyte characters (<a href="#5.2.1.2">5.2.1.2</a>).
29142 <li> The sets of characters tested for by the isalpha, isblank, islower, ispunct,
29143 isspace, isupper, iswalpha, iswblank, iswlower, iswpunct,
29144 iswspace, or iswupper functions (<a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>,
29145 <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.30.2.1.2">7.30.2.1.2</a>, <a href="#7.30.2.1.3">7.30.2.1.3</a>, <a href="#7.30.2.1.7">7.30.2.1.7</a>, <a href="#7.30.2.1.9">7.30.2.1.9</a>, <a href="#7.30.2.1.10">7.30.2.1.10</a>, <a href="#7.30.2.1.11">7.30.2.1.11</a>).
29147 <li> Additional subject sequences accepted by the numeric conversion functions (<a href="#7.22.1">7.22.1</a>,
29149 <li> The collation sequence of the execution character set (<a href="#7.24.4.3">7.24.4.3</a>, <a href="#7.29.4.4.2">7.29.4.4.2</a>).
29150 <!--page 597 -->
29151 <li> The contents of the error message strings set up by the strerror function
29153 <li> The formats for time and date (<a href="#7.27.3.5">7.27.3.5</a>, <a href="#7.29.5.1">7.29.5.1</a>).
29154 <li> Character mappings that are supported by the towctrans function (<a href="#7.30.1">7.30.1</a>).
29155 <li> Character classifications that are supported by the iswctype function (<a href="#7.30.1">7.30.1</a>).
29156 </ul>
29161 The following extensions are widely used in many systems, but are not portable to all
29162 implementations. The inclusion of any extension that may cause a strictly conforming
29163 program to become invalid renders an implementation nonconforming. Examples of such
29164 extensions are new keywords, extra library functions declared in standard headers, or
29165 predefined macros with names that do not begin with an underscore.
29170 In a hosted environment, the main function receives a third argument, char *envp[],
29171 that points to a null-terminated array of pointers to char, each of which points to a string
29172 that provides information about the environment for this execution of the program
29178 Characters other than the underscore _, letters, and digits, that are not part of the basic
29179 source character set (such as the dollar sign $, or characters in national character sets)
29185 All characters in identifiers (with or without external linkage) are significant (<a href="#6.4.2">6.4.2</a>).
29190 A function identifier, or the identifier of an object the declaration of which contains the
29196 String literals are modifiable (in which case, identical string literals should denote distinct
29198 <!--page 598 -->
29203 Additional arithmetic types, such as __int128 or double double, and their
29204 appropriate conversions are defined (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1">6.3.1</a>). Additional floating types may have
29205 more range or precision than long double, may be used for evaluating expressions of
29206 other floating types, and may be used to define float_t or double_t. Additional
29207 floating types may also have less range or precision than float.
29212 A pointer to an object or to void may be cast to a pointer to a function, allowing data to
29215 A pointer to a function may be cast to a pointer to an object or to void, allowing a
29216 function to be inspected or modified (for example, by a debugger) (<a href="#6.5.4">6.5.4</a>).
29221 A bit-field may be declared with a type other than _Bool, unsigned int, or
29227 The fortran function specifier may be used in a function declaration to indicate that
29228 calls suitable for FORTRAN should be generated, or that a different representation for the
29234 The asm keyword may be used to insert assembly language directly into the translator
29235 output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
29236 <pre>
29237 asm ( character-string-literal );
29238 </pre>
29243 There may be more than one external definition for the identifier of an object, with or
29244 without the explicit use of the keyword extern; if the definitions disagree, or more than
29246 <!--page 599 -->
29251 Macro names that do not begin with an underscore, describing the translation and
29252 execution environments, are defined by the implementation before translation begins
29258 If any floating-point status flags are set on normal termination after all calls to functions
29259 registered by the atexit function have been made (see <a href="#7.22.4.4">7.22.4.4</a>), the implementation
29260 writes some diagnostics indicating the fact to the stderr stream, if it is still open,
29265 Handlers for specific signals are called with extra arguments in addition to the signal
29269 <h4><a name="J.5.15" href="#J.5.15">J.5.15 Additional stream types and file-opening modes</a></h4>
29273 Additional file-opening modes may be specified by characters appended to the mode
29279 The file position indicator is decremented by each successful call to the ungetc or
29280 ungetwc function for a text stream, except if its value was zero before a call (<a href="#7.21.7.10">7.21.7.10</a>,
29286 Functions declared in <a href="#7.3"><complex.h></a> and <a href="#7.12"><math.h></a> raise SIGFPE to report errors
29287 instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
29289 <!--page 600 -->
29293 <pre>
29294 (normative)
29295 Bounds-checking interfaces
29296 </pre>
29301 Traditionally, the C Library has contained many functions that trust the programmer to
29302 provide output character arrays big enough to hold the result being produced. Not only
29303 do these functions not check that the arrays are big enough, they frequently lack the
29304 information needed to perform such checks. While it is possible to write safe, robust, and
29305 error-free code using the existing library, the library tends to promote programming styles
29306 that lead to mysterious failures if a result is too big for the provided array.
29308 A common programming style is to declare character arrays large enough to handle most
29309 practical cases. However, if these arrays are not large enough to handle the resulting
29310 strings, data can be written past the end of the array overwriting other data and program
29311 structures. The program never gets any indication that a problem exists, and so never has
29312 a chance to recover or to fail gracefully.
29314 Worse, this style of programming has compromised the security of computers and
29315 networks. Buffer overflows can often be exploited to run arbitrary code with the
29316 permissions of the vulnerable (defective) program.
29318 If the programmer writes runtime checks to verify lengths before calling library
29319 functions, then those runtime checks frequently duplicate work done inside the library
29320 functions, which discover string lengths as a side effect of doing their job.
29322 This annex provides alternative library functions that promote safer, more secure
29323 programming. The alternative functions verify that output buffers are large enough for
29324 the intended result and return a failure indicator if they are not. Data is never written past
29325 the end of an array. All string results are null terminated.
29327 This annex also addresses another problem that complicates writing robust code:
29328 functions that are not reentrant because they return pointers to static objects owned by the
29329 function. Such functions can be troublesome since a previously returned result can
29330 change if the function is called again, perhaps by another thread.
29331 <!--page 601 -->
29336 This annex specifies a series of optional extensions that can be useful in the mitigation of
29337 security vulnerabilities in programs, and comprise new functions, macros, and types
29338 declared or defined in existing standard headers.
29340 An implementation that defines __STDC_LIB_EXT1__ shall conform to the
29343 Subclause <a href="#K.3">K.3</a> should be read as if it were merged into the parallel structure of named
29344 subclauses of clause 7.
29347 <p><small><a name="note380" href="#note380">380)</a> Implementations that do not define __STDC_LIB_EXT1__ are not required to conform to these
29348 specifications.
29349 </small>
29360 The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are not
29361 declared or defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
29362 defined as a macro which expands to the integer constant 0 at the point in the source file
29363 where the appropriate header is first included.
29365 The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are
29366 declared and defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
29367 defined as a macro which expands to the integer constant 1 at the point in the source file
29370 It is implementation-defined whether the functions, macros, and types declared or defined
29371 in <a href="#K.3">K.3</a> and its subclauses are declared or defined by their respective headers if
29372 __STDC_WANT_LIB_EXT1__ is not defined as a macro at the point in the source file
29375 Within a preprocessing translation unit, __STDC_WANT_LIB_EXT1__ shall be
29376 defined identically for all inclusions of any headers from subclause <a href="#K.3">K.3</a>. If
29377 __STDC_WANT_LIB_EXT1__ is defined differently for any such inclusion, the
29378 implementation shall issue a diagnostic as if a preprocessor error directive were used.
29381 <!--page 602 -->
29384 <p><small><a name="note381" href="#note381">381)</a> Future revisions of this International Standard may define meanings for other values of
29385 __STDC_WANT_LIB_EXT1__.
29386 </small>
29387 <p><small><a name="note382" href="#note382">382)</a> Subclause <a href="#7.1.3">7.1.3</a> reserves certain names and patterns of names that an implementation may use in
29388 headers. All other names are not reserved, and a conforming implementation is not permitted to use
29389 them. While some of the names defined in <a href="#K.3">K.3</a> and its subclauses are reserved, others are not. If an
29390 unreserved name is defined in a header when __STDC_WANT_LIB_EXT1__ is defined as 0, the
29391 implementation is not conforming.
29392 </small>
29397 Each macro name in any of the following subclauses is reserved for use as specified if it
29398 is defined by any of its associated headers when included; unless explicitly stated
29401 All identifiers with external linkage in any of the following subclauses are reserved for
29402 use as identifiers with external linkage if any of them are used by the program. None of
29403 them are reserved if none of them are used.
29405 Each identifier with file scope listed in any of the following subclauses is reserved for use
29406 as a macro name and as an identifier with file scope in the same name space if it is
29407 defined by any of its associated headers when included.
29412 An implementation may set errno for the functions defined in this annex, but is not
29413 required to.
29418 Most functions in this annex include as part of their specification a list of runtime-
29419 constraints. These runtime-constraints are requirements on the program using the
29422 Implementations shall verify that the runtime-constraints for a function are not violated
29423 by the program. If a runtime-constraint is violated, the implementation shall call the
29424 currently registered runtime-constraint handler (see set_constraint_handler_s
29425 in <a href="#7.22"><stdlib.h></a>). Multiple runtime-constraint violations in the same call to a library
29426 function result in only one call to the runtime-constraint handler. It is unspecified which
29427 one of the multiple runtime-constraint violations cause the handler to be called.
29429 If the runtime-constraints section for a function states an action to be performed when a
29430 runtime-constraint violation occurs, the function shall perform the action before calling
29431 the runtime-constraint handler. If the runtime-constraints section lists actions that are
29432 prohibited when a runtime-constraint violation occurs, then such actions are prohibited to
29433 the function both before calling the handler and after the handler returns.
29435 The runtime-constraint handler might not return. If the handler does return, the library
29436 function whose runtime-constraint was violated shall return some indication of failure as
29437 given by the returns section in the function's specification.
29441 <!--page 603 -->
29444 <p><small><a name="note383" href="#note383">383)</a> Although runtime-constraints replace many cases of undefined behavior, undefined behavior still
29445 exists in this annex. Implementations are free to detect any case of undefined behavior and treat it as a
29446 runtime-constraint violation by calling the runtime-constraint handler. This license comes directly
29447 from the definition of undefined behavior.
29448 </small>
29455 The type is
29456 <pre>
29457 errno_t
29458 </pre>
29462 <p><small><a name="note384" href="#note384">384)</a> As a matter of programming style, errno_t may be used as the type of something that deals only
29463 with the values that might be found in errno. For example, a function which returns the value of
29464 errno might be declared as having the return type errno_t.
29465 </small>
29472 The type is
29473 <pre>
29474 rsize_t
29475 </pre>
29479 <p><small><a name="note385" href="#note385">385)</a> See the description of the RSIZE_MAX macro in <a href="#7.20"><stdint.h></a>.
29480 </small>
29487 The macro is
29488 <pre>
29489 RSIZE_MAX
29490 </pre>
29491 which expands to a value<sup><a href="#note386"><b>386)</b></a></sup> of type size_t. Functions that have parameters of type
29492 rsize_t consider it a runtime-constraint violation if the values of those parameters are
29493 greater than RSIZE_MAX.
29496 Extremely large object sizes are frequently a sign that an object's size was calculated
29497 incorrectly. For example, negative numbers appear as very large positive numbers when
29498 converted to an unsigned type like size_t. Also, some implementations do not support
29499 objects as large as the maximum value that can be represented by type size_t.
29501 For those reasons, it is sometimes beneficial to restrict the range of object sizes to detect
29502 programming errors. For implementations targeting machines with large address spaces,
29503 it is recommended that RSIZE_MAX be defined as the smaller of the size of the largest
29505 some legitimate, but very large, objects. Implementations targeting machines with small
29506 address spaces may wish to define RSIZE_MAX as SIZE_MAX, which means that there
29508 <!--page 604 -->
29509 is no object size that is considered a runtime-constraint violation.
29512 <p><small><a name="note386" href="#note386">386)</a> The macro RSIZE_MAX need not expand to a constant expression.
29513 </small>
29520 The macros are
29521 <pre>
29522 L_tmpnam_s
29523 </pre>
29524 which expands to an integer constant expression that is the size needed for an array of
29525 char large enough to hold a temporary file name string generated by the tmpnam_s
29526 function;
29527 <pre>
29528 TMP_MAX_S
29529 </pre>
29530 which expands to an integer constant expression that is the maximum number of unique
29531 file names that can be generated by the tmpnam_s function.
29533 The types are
29534 <pre>
29535 errno_t
29536 </pre>
29537 which is type int; and
29538 <pre>
29539 rsize_t
29540 </pre>
29541 which is the type size_t.
29550 <pre>
29551 #define __STDC_WANT_LIB_EXT1__ 1
29553 errno_t tmpfile_s(FILE * restrict * restrict streamptr);
29554 </pre>
29555 Runtime-constraints
29557 streamptr shall not be a null pointer.
29559 If there is a runtime-constraint violation, tmpfile_s does not attempt to create a file.
29562 The tmpfile_s function creates a temporary binary file that is different from any other
29563 existing file and that will automatically be removed when it is closed or at program
29564 termination. If the program terminates abnormally, whether an open temporary file is
29565 removed is implementation-defined. The file is opened for update with "wb+" mode
29566 with the meaning that mode has in the fopen_s function (including the mode's effect
29567 on exclusive access and file permissions).
29568 <!--page 605 -->
29570 If the file was created successfully, then the pointer to FILE pointed to by streamptr
29571 will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
29572 to FILE pointed to by streamptr will be set to a null pointer.
29574 It should be possible to open at least TMP_MAX_S temporary files during the lifetime of
29575 the program (this limit may be shared with tmpnam_s) and there should be no limit on
29576 the number simultaneously open other than this limit and any limit on the number of open
29577 files (FOPEN_MAX).
29580 The tmpfile_s function returns zero if it created the file. If it did not create the file or
29581 there was a runtime-constraint violation, tmpfile_s returns a nonzero value.
29587 <pre>
29588 #define __STDC_WANT_LIB_EXT1__ 1
29590 errno_t tmpnam_s(char *s, rsize_t maxsize);
29591 </pre>
29592 Runtime-constraints
29594 s shall not be a null pointer. maxsize shall be less than or equal to RSIZE_MAX.
29595 maxsize shall be greater than the length of the generated file name string.
29598 The tmpnam_s function generates a string that is a valid file name and that is not the
29599 same as the name of an existing file.<sup><a href="#note387"><b>387)</b></a></sup> The function is potentially capable of generating
29600 TMP_MAX_S different strings, but any or all of them may already be in use by existing
29601 files and thus not be suitable return values. The lengths of these strings shall be less than
29602 the value of the L_tmpnam_s macro.
29604 The tmpnam_s function generates a different string each time it is called.
29606 It is assumed that s points to an array of at least maxsize characters. This array will be
29607 set to generated string, as specified below.
29611 <!--page 606 -->
29613 The implementation shall behave as if no library function except tmpnam calls the
29617 After a program obtains a file name using the tmpnam_s function and before the
29618 program creates a file with that name, the possibility exists that someone else may create
29619 a file with that same name. To avoid this race condition, the tmpfile_s function
29620 should be used instead of tmpnam_s when possible. One situation that requires the use
29621 of the tmpnam_s function is when the program needs to create a temporary directory
29622 rather than a temporary file.
29625 If no suitable string can be generated, or if there is a runtime-constraint violation, the
29626 tmpnam_s function writes a null character to s[0] (only if s is not null and maxsize
29627 is greater than zero) and returns a nonzero value.
29629 Otherwise, the tmpnam_s function writes the string in the array pointed to by s and
29630 returns zero.
29633 The value of the macro TMP_MAX_S shall be at least 25.
29636 <p><small><a name="note387" href="#note387">387)</a> Files created using strings generated by the tmpnam_s function are temporary only in the sense that
29637 their names should not collide with those generated by conventional naming rules for the
29638 implementation. It is still necessary to use the remove function to remove such files when their use
29639 is ended, and before program termination. Implementations should take care in choosing the patterns
29640 used for names returned by tmpnam_s. For example, making a thread id part of the names avoids the
29641 race condition and possible conflict when multiple programs run simultaneously by the same user
29642 generate the same temporary file names.
29643 </small>
29644 <p><small><a name="note388" href="#note388">388)</a> An implementation may have tmpnam call tmpnam_s (perhaps so there is only one naming
29645 convention for temporary files), but this is not required.
29646 </small>
29655 <pre>
29656 #define __STDC_WANT_LIB_EXT1__ 1
29658 errno_t fopen_s(FILE * restrict * restrict streamptr,
29659 const char * restrict filename,
29660 const char * restrict mode);
29661 </pre>
29662 Runtime-constraints
29664 None of streamptr, filename, or mode shall be a null pointer.
29666 If there is a runtime-constraint violation, fopen_s does not attempt to open a file.
29667 Furthermore, if streamptr is not a null pointer, fopen_s sets *streamptr to the
29668 null pointer.
29673 <!--page 607 -->
29676 The fopen_s function opens the file whose name is the string pointed to by
29677 filename, and associates a stream with it.
29679 The mode string shall be as described for fopen, with the addition that modes starting
29680 with the character 'w' or 'a' may be preceded by the character 'u', see below:
29681 <dl>
29683 permissions
29686 permissions
29688 permissions
29691 permissions
29693 permissions
29696 default permissions
29698 permissions
29701 default permissions
29702 </dl>
29704 Opening a file with exclusive mode ('x' as the last character in the mode argument)
29705 fails if the file already exists or cannot be created.
29707 To the extent that the underlying system supports the concepts, files opened for writing
29708 shall be opened with exclusive (also known as non-shared) access. If the file is being
29709 created, and the first character of the mode string is not 'u', to the extent that the
29710 underlying system supports it, the file shall have a file permission that prevents other
29711 users on the system from accessing the file. If the file is being created and first character
29712 of the mode string is 'u', then by the time the file has been closed, it shall have the
29715 If the file was opened successfully, then the pointer to FILE pointed to by streamptr
29716 will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
29719 <!--page 608 -->
29720 to FILE pointed to by streamptr will be set to a null pointer.
29723 The fopen_s function returns zero if it opened the file. If it did not open the file or if
29724 there was a runtime-constraint violation, fopen_s returns a nonzero value.
29727 <p><small><a name="note389" href="#note389">389)</a> These are the same permissions that the file would have been created with by fopen.
29728 </small>
29734 <pre>
29735 #define __STDC_WANT_LIB_EXT1__ 1
29737 errno_t freopen_s(FILE * restrict * restrict newstreamptr,
29738 const char * restrict filename,
29739 const char * restrict mode,
29740 FILE * restrict stream);
29741 </pre>
29742 Runtime-constraints
29744 None of newstreamptr, mode, and stream shall be a null pointer.
29746 If there is a runtime-constraint violation, freopen_s neither attempts to close any file
29747 associated with stream nor attempts to open a file. Furthermore, if newstreamptr is
29748 not a null pointer, fopen_s sets *newstreamptr to the null pointer.
29751 The freopen_s function opens the file whose name is the string pointed to by
29752 filename and associates the stream pointed to by stream with it. The mode
29753 argument has the same meaning as in the fopen_s function (including the mode's effect
29754 on exclusive access and file permissions).
29756 If filename is a null pointer, the freopen_s function attempts to change the mode of
29757 the stream to that specified by mode, as if the name of the file currently associated with
29758 the stream had been used. It is implementation-defined which changes of mode are
29759 permitted (if any), and under what circumstances.
29761 The freopen_s function first attempts to close any file that is associated with stream.
29762 Failure to close the file is ignored. The error and end-of-file indicators for the stream are
29763 cleared.
29765 If the file was opened successfully, then the pointer to FILE pointed to by
29766 newstreamptr will be set to the value of stream. Otherwise, the pointer to FILE
29767 pointed to by newstreamptr will be set to a null pointer.
29770 The freopen_s function returns zero if it opened the file. If it did not open the file or
29771 there was a runtime-constraint violation, freopen_s returns a nonzero value.
29772 <!--page 609 -->
29777 Unless explicitly stated otherwise, if the execution of a function described in this
29778 subclause causes copying to take place between objects that overlap, the objects take on
29779 unspecified values.
29785 <pre>
29786 #define __STDC_WANT_LIB_EXT1__ 1
29788 int fprintf_s(FILE * restrict stream,
29789 const char * restrict format, ...);
29790 </pre>
29791 Runtime-constraints
29793 Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note390"><b>390)</b></a></sup> (modified or
29794 not by flags, field width, or precision) shall not appear in the string pointed to by
29795 format. Any argument to fprintf_s corresponding to a %s specifier shall not be a
29796 null pointer.
29798 If there is a runtime-constraint violation,<sup><a href="#note391"><b>391)</b></a></sup> the fprintf_s function does not attempt
29799 to produce further output, and it is unspecified to what extent fprintf_s produced
29800 output before discovering the runtime-constraint violation.
29803 The fprintf_s function is equivalent to the fprintf function except for the explicit
29804 runtime-constraints listed above.
29807 The fprintf_s function returns the number of characters transmitted, or a negative
29808 value if an output error, encoding error, or runtime-constraint violation occurred.
29813 <!--page 610 -->
29816 <p><small><a name="note390" href="#note390">390)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
29817 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
29818 format string was %%n.
29819 </small>
29820 <p><small><a name="note391" href="#note391">391)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
29821 implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
29822 constraint violation.
29823 </small>
29829 <pre>
29830 #define __STDC_WANT_LIB_EXT1__ 1
29832 int fscanf_s(FILE * restrict stream,
29833 const char * restrict format, ...);
29834 </pre>
29835 Runtime-constraints
29837 Neither stream nor format shall be a null pointer. Any argument indirected though in
29838 order to store converted input shall not be a null pointer.
29840 If there is a runtime-constraint violation,<sup><a href="#note392"><b>392)</b></a></sup> the fscanf_s function does not attempt to
29841 perform further input, and it is unspecified to what extent fscanf_s performed input
29842 before discovering the runtime-constraint violation.
29845 The fscanf_s function is equivalent to fscanf except that the c, s, and [ conversion
29846 specifiers apply to a pair of arguments (unless assignment suppression is indicated by a
29847 *). The first of these arguments is the same as for fscanf. That argument is
29848 immediately followed in the argument list by the second argument, which has type
29849 rsize_t and gives the number of elements in the array pointed to by the first argument
29850 of the pair. If the first argument points to a scalar object, it is considered to be an array of
29853 A matching failure occurs if the number of elements in a receiving object is insufficient to
29854 hold the converted input (including any trailing null character).
29857 The fscanf_s function returns the value of the macro EOF if an input failure occurs
29858 before any conversion or if there is a runtime-constraint violation. Otherwise, the
29860 <!--page 611 -->
29861 fscanf_s function returns the number of input items assigned, which can be fewer than
29862 provided for, or even zero, in the event of an early matching failure.
29864 EXAMPLE 1 The call:
29865 <pre>
29866 #define __STDC_WANT_LIB_EXT1__ 1
29868 /* ... */
29869 int n, i; float x; char name[50];
29871 </pre>
29872 with the input line:
29873 <pre>
29874 25 54.32E-1 thompson
29875 </pre>
29876 will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
29877 thompson\0.
29880 EXAMPLE 2 The call:
29881 <pre>
29882 #define __STDC_WANT_LIB_EXT1__ 1
29884 /* ... */
29885 int n; char s[5];
29886 n = fscanf_s(stdin, "%s", s, sizeof s);
29887 </pre>
29888 with the input line:
29889 <pre>
29890 hello
29891 </pre>
29892 will assign to n the value 0 since a matching failure occurred because the sequence hello\0 requires an
29893 array of six characters to store it.
29897 <p><small><a name="note392" href="#note392">392)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
29898 implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
29899 constraint violation.
29900 </small>
29901 <p><small><a name="note393" href="#note393">393)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
29902 used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
29903 argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
29904 the format is not known at translation time. For example, an implementation may issue a diagnostic
29905 for each argument after format that has of type pointer to one of char, signed char,
29906 unsigned char, or void that is not followed by an argument of a type compatible with
29907 rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
29908 using the hh length modifier, a length argument must follow the pointer argument. Another useful
29909 diagnostic could flag any non-pointer argument following format that did not have a type
29910 compatible with rsize_t.
29911 </small>
29917 <pre>
29918 #define __STDC_WANT_LIB_EXT1__ 1
29920 int printf_s(const char * restrict format, ...);
29921 </pre>
29922 Runtime-constraints
29924 format shall not be a null pointer. The %n specifier<sup><a href="#note394"><b>394)</b></a></sup> (modified or not by flags, field
29925 width, or precision) shall not appear in the string pointed to by format. Any argument
29926 to printf_s corresponding to a %s specifier shall not be a null pointer.
29928 If there is a runtime-constraint violation, the printf_s function does not attempt to
29929 produce further output, and it is unspecified to what extent printf_s produced output
29930 before discovering the runtime-constraint violation.
29933 <!--page 612 -->
29936 The printf_s function is equivalent to the printf function except for the explicit
29937 runtime-constraints listed above.
29940 The printf_s function returns the number of characters transmitted, or a negative
29941 value if an output error, encoding error, or runtime-constraint violation occurred.
29944 <p><small><a name="note394" href="#note394">394)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
29945 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
29946 format string was %%n.
29947 </small>
29953 <pre>
29954 #define __STDC_WANT_LIB_EXT1__ 1
29956 int scanf_s(const char * restrict format, ...);
29957 </pre>
29958 Runtime-constraints
29960 format shall not be a null pointer. Any argument indirected though in order to store
29961 converted input shall not be a null pointer.
29963 If there is a runtime-constraint violation, the scanf_s function does not attempt to
29964 perform further input, and it is unspecified to what extent scanf_s performed input
29965 before discovering the runtime-constraint violation.
29968 The scanf_s function is equivalent to fscanf_s with the argument stdin
29969 interposed before the arguments to scanf_s.
29972 The scanf_s function returns the value of the macro EOF if an input failure occurs
29973 before any conversion or if there is a runtime-constraint violation. Otherwise, the
29974 scanf_s function returns the number of input items assigned, which can be fewer than
29975 provided for, or even zero, in the event of an early matching failure.
29981 <pre>
29982 #define __STDC_WANT_LIB_EXT1__ 1
29984 int snprintf_s(char * restrict s, rsize_t n,
29985 const char * restrict format, ...);
29986 </pre>
29987 Runtime-constraints
29989 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
29990 than RSIZE_MAX. The %n specifier<sup><a href="#note395"><b>395)</b></a></sup> (modified or not by flags, field width, or
29991 precision) shall not appear in the string pointed to by format. Any argument to
29992 <!--page 613 -->
29993 snprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
29994 error shall occur.
29996 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
29997 than zero and less than RSIZE_MAX, then the snprintf_s function sets s[0] to the
29998 null character.
30001 The snprintf_s function is equivalent to the snprintf function except for the
30002 explicit runtime-constraints listed above.
30004 The snprintf_s function, unlike sprintf_s, will truncate the result to fit within the
30005 array pointed to by s.
30008 The snprintf_s function returns the number of characters that would have been
30009 written had n been sufficiently large, not counting the terminating null character, or a
30010 negative value if a runtime-constraint violation occurred. Thus, the null-terminated
30011 output has been completely written if and only if the returned value is nonnegative and
30012 less than n.
30015 <p><small><a name="note395" href="#note395">395)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
30016 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
30017 format string was %%n.
30018 </small>
30024 <pre>
30025 #define __STDC_WANT_LIB_EXT1__ 1
30027 int sprintf_s(char * restrict s, rsize_t n,
30028 const char * restrict format, ...);
30029 </pre>
30030 Runtime-constraints
30032 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
30033 than RSIZE_MAX. The number of characters (including the trailing null) required for the
30034 result to be written to the array pointed to by s shall not be greater than n. The %n
30035 specifier<sup><a href="#note396"><b>396)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
30036 string pointed to by format. Any argument to sprintf_s corresponding to a %s
30037 specifier shall not be a null pointer. No encoding error shall occur.
30041 <!--page 614 -->
30043 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
30044 than zero and less than RSIZE_MAX, then the sprintf_s function sets s[0] to the
30045 null character.
30048 The sprintf_s function is equivalent to the sprintf function except for the
30049 parameter n and the explicit runtime-constraints listed above.
30051 The sprintf_s function, unlike snprintf_s, treats a result too big for the array
30052 pointed to by s as a runtime-constraint violation.
30055 If no runtime-constraint violation occurred, the sprintf_s function returns the number
30056 of characters written in the array, not counting the terminating null character. If an
30057 encoding error occurred, sprintf_s returns a negative value. If any other runtime-
30058 constraint violation occurred, sprintf_s returns zero.
30061 <p><small><a name="note396" href="#note396">396)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
30062 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
30063 format string was %%n.
30064 </small>
30070 <pre>
30071 #define __STDC_WANT_LIB_EXT1__ 1
30073 int sscanf_s(const char * restrict s,
30074 const char * restrict format, ...);
30075 </pre>
30076 Runtime-constraints
30078 Neither s nor format shall be a null pointer. Any argument indirected though in order
30079 to store converted input shall not be a null pointer.
30081 If there is a runtime-constraint violation, the sscanf_s function does not attempt to
30082 perform further input, and it is unspecified to what extent sscanf_s performed input
30083 before discovering the runtime-constraint violation.
30086 The sscanf_s function is equivalent to fscanf_s, except that input is obtained from
30087 a string (specified by the argument s) rather than from a stream. Reaching the end of the
30088 string is equivalent to encountering end-of-file for the fscanf_s function. If copying
30089 takes place between objects that overlap, the objects take on unspecified values.
30092 The sscanf_s function returns the value of the macro EOF if an input failure occurs
30093 before any conversion or if there is a runtime-constraint violation. Otherwise, the
30094 sscanf_s function returns the number of input items assigned, which can be fewer than
30095 provided for, or even zero, in the event of an early matching failure.
30096 <!--page 615 -->
30102 <pre>
30103 #define __STDC_WANT_LIB_EXT1__ 1
30106 int vfprintf_s(FILE * restrict stream,
30107 const char * restrict format,
30108 va_list arg);
30109 </pre>
30110 Runtime-constraints
30112 Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note397"><b>397)</b></a></sup> (modified or
30113 not by flags, field width, or precision) shall not appear in the string pointed to by
30114 format. Any argument to vfprintf_s corresponding to a %s specifier shall not be a
30115 null pointer.
30117 If there is a runtime-constraint violation, the vfprintf_s function does not attempt to
30118 produce further output, and it is unspecified to what extent vfprintf_s produced
30119 output before discovering the runtime-constraint violation.
30122 The vfprintf_s function is equivalent to the vfprintf function except for the
30123 explicit runtime-constraints listed above.
30126 The vfprintf_s function returns the number of characters transmitted, or a negative
30127 value if an output error, encoding error, or runtime-constraint violation occurred.
30130 <p><small><a name="note397" href="#note397">397)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
30131 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
30132 format string was %%n.
30133 </small>
30139 <pre>
30140 #define __STDC_WANT_LIB_EXT1__ 1
30143 int vfscanf_s(FILE * restrict stream,
30144 const char * restrict format,
30145 va_list arg);
30146 </pre>
30151 <!--page 616 -->
30152 Runtime-constraints
30154 Neither stream nor format shall be a null pointer. Any argument indirected though in
30155 order to store converted input shall not be a null pointer.
30157 If there is a runtime-constraint violation, the vfscanf_s function does not attempt to
30158 perform further input, and it is unspecified to what extent vfscanf_s performed input
30159 before discovering the runtime-constraint violation.
30162 The vfscanf_s function is equivalent to fscanf_s, with the variable argument list
30163 replaced by arg, which shall have been initialized by the va_start macro (and
30164 possibly subsequent va_arg calls). The vfscanf_s function does not invoke the
30168 The vfscanf_s function returns the value of the macro EOF if an input failure occurs
30169 before any conversion or if there is a runtime-constraint violation. Otherwise, the
30170 vfscanf_s function returns the number of input items assigned, which can be fewer
30171 than provided for, or even zero, in the event of an early matching failure.
30174 <p><small><a name="note398" href="#note398">398)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
30175 vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
30176 indeterminate.
30177 </small>
30183 <pre>
30184 #define __STDC_WANT_LIB_EXT1__ 1
30187 int vprintf_s(const char * restrict format,
30188 va_list arg);
30189 </pre>
30190 Runtime-constraints
30192 format shall not be a null pointer. The %n specifier<sup><a href="#note399"><b>399)</b></a></sup> (modified or not by flags, field
30193 width, or precision) shall not appear in the string pointed to by format. Any argument
30194 to vprintf_s corresponding to a %s specifier shall not be a null pointer.
30196 If there is a runtime-constraint violation, the vprintf_s function does not attempt to
30197 produce further output, and it is unspecified to what extent vprintf_s produced output
30198 before discovering the runtime-constraint violation.
30200 <!--page 617 -->
30203 The vprintf_s function is equivalent to the vprintf function except for the explicit
30204 runtime-constraints listed above.
30207 The vprintf_s function returns the number of characters transmitted, or a negative
30208 value if an output error, encoding error, or runtime-constraint violation occurred.
30211 <p><small><a name="note399" href="#note399">399)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
30212 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
30213 format string was %%n.
30214 </small>
30220 <pre>
30221 #define __STDC_WANT_LIB_EXT1__ 1
30224 int vscanf_s(const char * restrict format,
30225 va_list arg);
30226 </pre>
30227 Runtime-constraints
30229 format shall not be a null pointer. Any argument indirected though in order to store
30230 converted input shall not be a null pointer.
30232 If there is a runtime-constraint violation, the vscanf_s function does not attempt to
30233 perform further input, and it is unspecified to what extent vscanf_s performed input
30234 before discovering the runtime-constraint violation.
30237 The vscanf_s function is equivalent to scanf_s, with the variable argument list
30238 replaced by arg, which shall have been initialized by the va_start macro (and
30239 possibly subsequent va_arg calls). The vscanf_s function does not invoke the
30243 The vscanf_s function returns the value of the macro EOF if an input failure occurs
30244 before any conversion or if there is a runtime-constraint violation. Otherwise, the
30245 vscanf_s function returns the number of input items assigned, which can be fewer than
30246 provided for, or even zero, in the event of an early matching failure.
30251 <!--page 618 -->
30254 <p><small><a name="note400" href="#note400">400)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
30255 vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
30256 indeterminate.
30257 </small>
30263 <pre>
30264 #define __STDC_WANT_LIB_EXT1__ 1
30267 int vsnprintf_s(char * restrict s, rsize_t n,
30268 const char * restrict format,
30269 va_list arg);
30270 </pre>
30271 Runtime-constraints
30273 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
30274 than RSIZE_MAX. The %n specifier<sup><a href="#note401"><b>401)</b></a></sup> (modified or not by flags, field width, or
30275 precision) shall not appear in the string pointed to by format. Any argument to
30276 vsnprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
30277 error shall occur.
30279 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
30280 than zero and less than RSIZE_MAX, then the vsnprintf_s function sets s[0] to the
30281 null character.
30284 The vsnprintf_s function is equivalent to the vsnprintf function except for the
30285 explicit runtime-constraints listed above.
30287 The vsnprintf_s function, unlike vsprintf_s, will truncate the result to fit within
30288 the array pointed to by s.
30291 The vsnprintf_s function returns the number of characters that would have been
30292 written had n been sufficiently large, not counting the terminating null character, or a
30293 negative value if a runtime-constraint violation occurred. Thus, the null-terminated
30294 output has been completely written if and only if the returned value is nonnegative and
30295 less than n.
30300 <!--page 619 -->
30303 <p><small><a name="note401" href="#note401">401)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
30304 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
30305 format string was %%n.
30306 </small>
30312 <pre>
30313 #define __STDC_WANT_LIB_EXT1__ 1
30316 int vsprintf_s(char * restrict s, rsize_t n,
30317 const char * restrict format,
30318 va_list arg);
30319 </pre>
30320 Runtime-constraints
30322 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
30323 than RSIZE_MAX. The number of characters (including the trailing null) required for the
30324 result to be written to the array pointed to by s shall not be greater than n. The %n
30325 specifier<sup><a href="#note402"><b>402)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
30326 string pointed to by format. Any argument to vsprintf_s corresponding to a %s
30327 specifier shall not be a null pointer. No encoding error shall occur.
30329 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
30330 than zero and less than RSIZE_MAX, then the vsprintf_s function sets s[0] to the
30331 null character.
30334 The vsprintf_s function is equivalent to the vsprintf function except for the
30335 parameter n and the explicit runtime-constraints listed above.
30337 The vsprintf_s function, unlike vsnprintf_s, treats a result too big for the array
30338 pointed to by s as a runtime-constraint violation.
30341 If no runtime-constraint violation occurred, the vsprintf_s function returns the
30342 number of characters written in the array, not counting the terminating null character. If
30343 an encoding error occurred, vsprintf_s returns a negative value. If any other
30344 runtime-constraint violation occurred, vsprintf_s returns zero.
30349 <!--page 620 -->
30352 <p><small><a name="note402" href="#note402">402)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
30353 at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
30354 format string was %%n.
30355 </small>
30361 <pre>
30362 #define __STDC_WANT_LIB_EXT1__ 1
30365 int vsscanf_s(const char * restrict s,
30366 const char * restrict format,
30367 va_list arg);
30368 </pre>
30369 Runtime-constraints
30371 Neither s nor format shall be a null pointer. Any argument indirected though in order
30372 to store converted input shall not be a null pointer.
30374 If there is a runtime-constraint violation, the vsscanf_s function does not attempt to
30375 perform further input, and it is unspecified to what extent vsscanf_s performed input
30376 before discovering the runtime-constraint violation.
30379 The vsscanf_s function is equivalent to sscanf_s, with the variable argument list
30380 replaced by arg, which shall have been initialized by the va_start macro (and
30381 possibly subsequent va_arg calls). The vsscanf_s function does not invoke the
30385 The vsscanf_s function returns the value of the macro EOF if an input failure occurs
30386 before any conversion or if there is a runtime-constraint violation. Otherwise, the
30387 vscanf_s function returns the number of input items assigned, which can be fewer than
30388 provided for, or even zero, in the event of an early matching failure.
30391 <p><small><a name="note403" href="#note403">403)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
30392 vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
30393 indeterminate.
30394 </small>
30403 <pre>
30404 #define __STDC_WANT_LIB_EXT1__ 1
30406 char *gets_s(char *s, rsize_t n);
30407 </pre>
30412 <!--page 621 -->
30413 Runtime-constraints
30415 s shall not be a null pointer. n shall neither be equal to zero nor be greater than
30416 RSIZE_MAX. A new-line character, end-of-file, or read error shall occur within reading
30419 If there is a runtime-constraint violation, s[0] is set to the null character, and characters
30420 are read and discarded from stdin until a new-line character is read, or end-of-file or a
30421 read error occurs.
30424 The gets_s function reads at most one less than the number of characters specified by n
30425 from the stream pointed to by stdin, into the array pointed to by s. No additional
30426 characters are read after a new-line character (which is discarded) or after end-of-file.
30427 The discarded new-line character does not count towards number of characters read. A
30428 null character is written immediately after the last character read into the array.
30430 If end-of-file is encountered and no characters have been read into the array, or if a read
30431 error occurs during the operation, then s[0] is set to the null character, and the other
30432 elements of s take unspecified values.
30435 The fgets function allows properly-written programs to safely process input lines too
30436 long to store in the result array. In general this requires that callers of fgets pay
30437 attention to the presence or absence of a new-line character in the result array. Consider
30438 using fgets (along with any needed processing based on new-line characters) instead of
30439 gets_s.
30442 The gets_s function returns s if successful. If there was a runtime-constraint violation,
30443 or if end-of-file is encountered and no characters have been read into the array, or if a
30444 read error occurs during the operation, then a null pointer is returned.
30449 <!--page 622 -->
30452 <p><small><a name="note404" href="#note404">404)</a> The gets_s function, unlike the historical gets function, makes it a runtime-constraint violation for
30453 a line of input to overflow the buffer to store it. Unlike the fgets function, gets_s maintains a
30454 one-to-one relationship between input lines and successful calls to gets_s. Programs that use gets
30455 expect such a relationship.
30456 </small>
30463 The types are
30464 <pre>
30465 errno_t
30466 </pre>
30467 which is type int; and
30468 <pre>
30469 rsize_t
30470 </pre>
30471 which is the type size_t; and
30472 <pre>
30473 constraint_handler_t
30474 </pre>
30475 which has the following definition
30476 <pre>
30477 typedef void (*constraint_handler_t)(
30478 const char * restrict msg,
30479 void * restrict ptr,
30480 errno_t error);
30481 </pre>
30487 <h5><a name="K.3.6.1.1" href="#K.3.6.1.1">K.3.6.1.1 The set_constraint_handler_s function</a></h5>
30490 <pre>
30491 #define __STDC_WANT_LIB_EXT1__ 1
30493 constraint_handler_t set_constraint_handler_s(
30494 constraint_handler_t handler);
30495 </pre>
30498 The set_constraint_handler_s function sets the runtime-constraint handler to
30499 be handler. The runtime-constraint handler is the function to be called when a library
30500 function detects a runtime-constraint violation. Only the most recent handler registered
30501 with set_constraint_handler_s is called when a runtime-constraint violation
30502 occurs.
30504 When the handler is called, it is passed the following arguments in the following order:
30505 <ol>
30506 <li> A pointer to a character string describing the runtime-constraint violation.
30507 <li> A null pointer or a pointer to an implementation defined object.
30508 <li> If the function calling the handler has a return type declared as errno_t, the
30509 return value of the function is passed. Otherwise, a positive value of type
30510 errno_t is passed.
30511 <!--page 623 -->
30512 </ol>
30514 The implementation has a default constraint handler that is used if no calls to the
30515 set_constraint_handler_s function have been made. The behavior of the
30516 default handler is implementation-defined, and it may cause the program to exit or abort.
30518 If the handler argument to set_constraint_handler_s is a null pointer, the
30519 implementation default handler becomes the current constraint handler.
30522 The set_constraint_handler_s function returns a pointer to the previously
30526 <p><small><a name="note405" href="#note405">405)</a> If the previous handler was registered by calling set_constraint_handler_s with a null
30527 pointer argument, a pointer to the implementation default handler is returned (not NULL).
30528 </small>
30534 <pre>
30535 #define __STDC_WANT_LIB_EXT1__ 1
30537 void abort_handler_s(
30538 const char * restrict msg,
30539 void * restrict ptr,
30540 errno_t error);
30541 </pre>
30544 A pointer to the abort_handler_s function shall be a suitable argument to the
30545 set_constraint_handler_s function.
30547 The abort_handler_s function writes a message on the standard error stream in an
30548 implementation-defined format. The message shall include the string pointed to by msg.
30549 The abort_handler_s function then calls the abort function.<sup><a href="#note406"><b>406)</b></a></sup>
30552 The abort_handler_s function does not return to its caller.
30557 <!--page 624 -->
30560 <p><small><a name="note406" href="#note406">406)</a> Many implementations invoke a debugger when the abort function is called.
30561 </small>
30567 <pre>
30568 #define __STDC_WANT_LIB_EXT1__ 1
30570 void ignore_handler_s(
30571 const char * restrict msg,
30572 void * restrict ptr,
30573 errno_t error);
30574 </pre>
30577 A pointer to the ignore_handler_s function shall be a suitable argument to the
30578 set_constraint_handler_s function.
30580 The ignore_handler_s function simply returns to its caller.<sup><a href="#note407"><b>407)</b></a></sup>
30583 The ignore_handler_s function returns no value.
30586 <p><small><a name="note407" href="#note407">407)</a> If the runtime-constraint handler is set to the ignore_handler_s function, any library function in
30587 which a runtime-constraint violation occurs will return to its caller. The caller can determine whether
30588 a runtime-constraint violation occurred based on the library function's specification (usually, the
30589 library function returns a nonzero errno_t).
30590 </small>
30599 <pre>
30600 #define __STDC_WANT_LIB_EXT1__ 1
30602 errno_t getenv_s(size_t * restrict len,
30603 char * restrict value, rsize_t maxsize,
30604 const char * restrict name);
30605 </pre>
30606 Runtime-constraints
30608 name shall not be a null pointer. maxsize shall neither equal zero nor be greater than
30609 RSIZE_MAX. If maxsize is not equal to zero, then value shall not be a null pointer.
30611 If there is a runtime-constraint violation, the integer pointed to by len is set to 0 (if len
30612 is not null), and the environment list is not searched.
30615 The getenv_s function searches an environment list, provided by the host environment,
30616 for a string that matches the string pointed to by name.
30619 <!--page 625 -->
30621 If that name is found then getenv_s performs the following actions. If len is not a
30622 null pointer, the length of the string associated with the matched list member is stored in
30623 the integer pointed to by len. If the length of the associated string is less than maxsize,
30624 then the associated string is copied to the array pointed to by value.
30626 If that name is not found then getenv_s performs the following actions. If len is not
30627 a null pointer, zero is stored in the integer pointed to by len. If maxsize is greater than
30628 zero, then value[0] is set to the null character.
30630 The set of environment names and the method for altering the environment list are
30631 implementation-defined. The getenv_s function need not avoid data races with other
30632 threads of execution that modify the environment list.<sup><a href="#note408"><b>408)</b></a></sup>
30635 The getenv_s function returns zero if the specified name is found and the associated
30636 string was successfully stored in value. Otherwise, a nonzero value is returned.
30639 <p><small><a name="note408" href="#note408">408)</a> Many implementations provide non-standard functions that modify the environment list.
30640 </small>
30645 These utilities make use of a comparison function to search or sort arrays of unspecified
30646 type. Where an argument declared as size_t nmemb specifies the length of the array
30647 for a function, if nmemb has the value zero on a call to that function, then the comparison
30648 function is not called, a search finds no matching element, sorting performs no
30649 rearrangement, and the pointer to the array may be null.
30651 The implementation shall ensure that the second argument of the comparison function
30652 (when called from bsearch_s), or both arguments (when called from qsort_s), are
30653 pointers to elements of the array.<sup><a href="#note409"><b>409)</b></a></sup> The first argument when called from bsearch_s
30654 shall equal key.
30656 The comparison function shall not alter the contents of either the array or search key. The
30657 implementation may reorder elements of the array between calls to the comparison
30658 function, but shall not otherwise alter the contents of any individual element.
30660 When the same objects (consisting of size bytes, irrespective of their current positions
30661 in the array) are passed more than once to the comparison function, the results shall be
30662 consistent with one another. That is, for qsort_s they shall define a total ordering on
30663 the array, and for bsearch_s the same object shall always compare the same way with
30664 the key.
30666 <!--page 626 -->
30668 A sequence point occurs immediately before and immediately after each call to the
30669 comparison function, and also between any call to the comparison function and any
30670 movement of the objects passed as arguments to that call.
30673 <p><small><a name="note409" href="#note409">409)</a> That is, if the value passed is p, then the following expressions are always valid and nonzero:
30675 <pre>
30676 ((char *)p - (char *)base) % size == 0
30677 (char *)p >= (char *)base
30678 (char *)p < (char *)base + nmemb * size
30679 </pre>
30680 </small>
30686 <pre>
30687 #define __STDC_WANT_LIB_EXT1__ 1
30689 void *bsearch_s(const void *key, const void *base,
30690 rsize_t nmemb, rsize_t size,
30691 int (*compar)(const void *k, const void *y,
30692 void *context),
30693 void *context);
30694 </pre>
30695 Runtime-constraints
30697 Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
30698 zero, then none of key, base, or compar shall be a null pointer.
30700 If there is a runtime-constraint violation, the bsearch_s function does not search the
30701 array.
30704 The bsearch_s function searches an array of nmemb objects, the initial element of
30705 which is pointed to by base, for an element that matches the object pointed to by key.
30706 The size of each element of the array is specified by size.
30708 The comparison function pointed to by compar is called with three arguments. The first
30709 two point to the key object and to an array element, in that order. The function shall
30710 return an integer less than, equal to, or greater than zero if the key object is considered,
30711 respectively, to be less than, to match, or to be greater than the array element. The array
30712 shall consist of: all the elements that compare less than, all the elements that compare
30713 equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note410"><b>410)</b></a></sup>
30714 The third argument to the comparison function is the context argument passed to
30715 bsearch_s. The sole use of context by bsearch_s is to pass it to the comparison
30721 <!--page 627 -->
30724 The bsearch_s function returns a pointer to a matching element of the array, or a null
30725 pointer if no match is found or there is a runtime-constraint violation. If two elements
30726 compare as equal, which element is matched is unspecified.
30729 <p><small><a name="note410" href="#note410">410)</a> In practice, this means that the entire array has been sorted according to the comparison function.
30730 </small>
30731 <p><small><a name="note411" href="#note411">411)</a> The context argument is for the use of the comparison function in performing its duties. For
30732 example, it might specify a collating sequence used by the comparison function.
30733 </small>
30739 <pre>
30740 #define __STDC_WANT_LIB_EXT1__ 1
30742 errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
30743 int (*compar)(const void *x, const void *y,
30744 void *context),
30745 void *context);
30746 </pre>
30747 Runtime-constraints
30749 Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
30750 zero, then neither base nor compar shall be a null pointer.
30752 If there is a runtime-constraint violation, the qsort_s function does not sort the array.
30755 The qsort_s function sorts an array of nmemb objects, the initial element of which is
30756 pointed to by base. The size of each object is specified by size.
30758 The contents of the array are sorted into ascending order according to a comparison
30759 function pointed to by compar, which is called with three arguments. The first two
30760 point to the objects being compared. The function shall return an integer less than, equal
30761 to, or greater than zero if the first argument is considered to be respectively less than,
30762 equal to, or greater than the second. The third argument to the comparison function is the
30763 context argument passed to qsort_s. The sole use of context by qsort_s is to
30766 If two elements compare as equal, their relative order in the resulting sorted array is
30767 unspecified.
30770 The qsort_s function returns zero if there was no runtime-constraint violation.
30771 Otherwise, a nonzero value is returned.
30776 <!--page 628 -->
30779 <p><small><a name="note412" href="#note412">412)</a> The context argument is for the use of the comparison function in performing its duties. For
30780 example, it might specify a collating sequence used by the comparison function.
30781 </small>
30784 <h5><a name="K.3.6.4" href="#K.3.6.4">K.3.6.4 Multibyte/wide character conversion functions</a></h5>
30786 The behavior of the multibyte character functions is affected by the LC_CTYPE category
30787 of the current locale. For a state-dependent encoding, each function is placed into its
30788 initial conversion state by a call for which its character pointer argument, s, is a null
30789 pointer. Subsequent calls with s as other than a null pointer cause the internal conversion
30790 state of the function to be altered as necessary. A call with s as a null pointer causes
30791 these functions to set the int pointed to by their status argument to a nonzero value if
30792 encodings have state dependency, and zero otherwise.<sup><a href="#note413"><b>413)</b></a></sup> Changing the LC_CTYPE
30793 category causes the conversion state of these functions to be indeterminate.
30796 <p><small><a name="note413" href="#note413">413)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
30797 character codes, but are grouped with an adjacent multibyte character.
30798 </small>
30804 <pre>
30805 #define __STDC_WANT_LIB_EXT1__ 1
30807 errno_t wctomb_s(int * restrict status,
30808 char * restrict s,
30809 rsize_t smax,
30810 wchar_t wc);
30811 </pre>
30812 Runtime-constraints
30814 Let n denote the number of bytes needed to represent the multibyte character
30815 corresponding to the wide character given by wc (including any shift sequences).
30817 If s is not a null pointer, then smax shall not be less than n, and smax shall not be
30818 greater than RSIZE_MAX. If s is a null pointer, then smax shall equal zero.
30820 If there is a runtime-constraint violation, wctomb_s does not modify the int pointed to
30821 by status, and if s is not a null pointer, no more than smax elements in the array
30822 pointed to by s will be accessed.
30825 The wctomb_s function determines n and stores the multibyte character representation
30826 of wc in the array whose first element is pointed to by s (if s is not a null pointer). The
30827 number of characters stored never exceeds MB_CUR_MAX or smax. If wc is a null wide
30828 character, a null byte is stored, preceded by any shift sequence needed to restore the
30829 initial shift state, and the function is left in the initial conversion state.
30831 The implementation shall behave as if no library function calls the wctomb_s function.
30835 <!--page 629 -->
30837 If s is a null pointer, the wctomb_s function stores into the int pointed to by status a
30838 nonzero or zero value, if multibyte character encodings, respectively, do or do not have
30839 state-dependent encodings.
30841 If s is not a null pointer, the wctomb_s function stores into the int pointed to by
30842 status either n or -1 if wc, respectively, does or does not correspond to a valid
30843 multibyte character.
30845 In no case will the int pointed to by status be set to a value greater than the
30846 MB_CUR_MAX macro.
30849 The wctomb_s function returns zero if successful, and a nonzero value if there was a
30850 runtime-constraint violation or wc did not correspond to a valid multibyte character.
30853 <h5><a name="K.3.6.5" href="#K.3.6.5">K.3.6.5 Multibyte/wide string conversion functions</a></h5>
30855 The behavior of the multibyte string functions is affected by the LC_CTYPE category of
30856 the current locale.
30862 <pre>
30864 errno_t mbstowcs_s(size_t * restrict retval,
30865 wchar_t * restrict dst, rsize_t dstmax,
30866 const char * restrict src, rsize_t len);
30867 </pre>
30868 Runtime-constraints
30870 Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
30871 neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
30872 then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
30873 zero. If dst is not a null pointer and len is not less than dstmax, then a null character
30874 shall occur within the first dstmax multibyte characters of the array pointed to by src.
30876 If there is a runtime-constraint violation, then mbstowcs_s does the following. If
30877 retval is not a null pointer, then mbstowcs_s sets *retval to (size_t)(-1). If
30878 dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
30879 then mbstowcs_s sets dst[0] to the null wide character.
30882 The mbstowcs_s function converts a sequence of multibyte characters that begins in
30883 the initial shift state from the array pointed to by src into a sequence of corresponding
30884 wide characters. If dst is not a null pointer, the converted characters are stored into the
30885 array pointed to by dst. Conversion continues up to and including a terminating null
30886 character, which is also stored. Conversion stops earlier in two cases: when a sequence of
30887 <!--page 630 -->
30888 bytes is encountered that does not form a valid multibyte character, or (if dst is not a
30889 null pointer) when len wide characters have been stored into the array pointed to by
30890 dst.<sup><a href="#note414"><b>414)</b></a></sup> If dst is not a null pointer and no null wide character was stored into the array
30891 pointed to by dst, then dst[len] is set to the null wide character. Each conversion
30892 takes place as if by a call to the mbrtowc function.
30894 Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
30895 sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
30896 the mbstowcs_s function stores the value (size_t)(-1) into *retval.
30897 Otherwise, the mbstowcs_s function stores into *retval the number of multibyte
30898 characters successfully converted, not including the terminating null character (if any).
30900 All elements following the terminating null wide character (if any) written by
30901 mbstowcs_s in the array of dstmax wide characters pointed to by dst take
30904 If copying takes place between objects that overlap, the objects take on unspecified
30905 values.
30908 The mbstowcs_s function returns zero if no runtime-constraint violation and no
30909 encoding error occurred. Otherwise, a nonzero value is returned.
30912 <p><small><a name="note414" href="#note414">414)</a> Thus, the value of len is ignored if dst is a null pointer.
30913 </small>
30914 <p><small><a name="note415" href="#note415">415)</a> This allows an implementation to attempt converting the multibyte string before discovering a
30915 terminating null character did not occur where required.
30916 </small>
30922 <pre>
30924 errno_t wcstombs_s(size_t * restrict retval,
30925 char * restrict dst, rsize_t dstmax,
30926 const wchar_t * restrict src, rsize_t len);
30927 </pre>
30928 Runtime-constraints
30930 Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
30931 neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
30932 then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
30933 zero. If dst is not a null pointer and len is not less than dstmax, then the conversion
30934 shall have been stopped (see below) because a terminating null wide character was
30935 reached or because an encoding error occurred.
30940 <!--page 631 -->
30942 If there is a runtime-constraint violation, then wcstombs_s does the following. If
30943 retval is not a null pointer, then wcstombs_s sets *retval to (size_t)(-1). If
30944 dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
30945 then wcstombs_s sets dst[0] to the null character.
30948 The wcstombs_s function converts a sequence of wide characters from the array
30949 pointed to by src into a sequence of corresponding multibyte characters that begins in
30950 the initial shift state. If dst is not a null pointer, the converted characters are then stored
30951 into the array pointed to by dst. Conversion continues up to and including a terminating
30952 null wide character, which is also stored. Conversion stops earlier in two cases:
30953 <ul>
30954 <li> when a wide character is reached that does not correspond to a valid multibyte
30955 character;
30956 <li> (if dst is not a null pointer) when the next multibyte character would exceed the
30957 limit of n total bytes to be stored into the array pointed to by dst. If the wide
30958 character being converted is the null wide character, then n is the lesser of len or
30959 dstmax. Otherwise, n is the lesser of len or dstmax-1.
30960 </ul>
30961 If the conversion stops without converting a null wide character and dst is not a null
30962 pointer, then a null character is stored into the array pointed to by dst immediately
30963 following any multibyte characters already stored. Each conversion takes place as if by a
30966 Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
30967 wide character that does not correspond to a valid multibyte character, an encoding error
30968 occurs: the wcstombs_s function stores the value (size_t)(-1) into *retval.
30969 Otherwise, the wcstombs_s function stores into *retval the number of bytes in the
30970 resulting multibyte character sequence, not including the terminating null character (if
30971 any).
30973 All elements following the terminating null character (if any) written by wcstombs_s
30974 in the array of dstmax elements pointed to by dst take unspecified values when
30977 If copying takes place between objects that overlap, the objects take on unspecified
30978 values.
30981 <!--page 632 -->
30984 The wcstombs_s function returns zero if no runtime-constraint violation and no
30985 encoding error occurred. Otherwise, a nonzero value is returned.
30988 <p><small><a name="note416" href="#note416">416)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
30989 include those necessary to reach the initial shift state immediately before the null byte. However, if
30990 the conversion stops before a terminating null wide character has been reached, the result will be null
30991 terminated, but might not end in the initial shift state.
30992 </small>
30993 <p><small><a name="note417" href="#note417">417)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
30994 runtime-constraint violation.
30995 </small>
31002 The types are
31003 <pre>
31004 errno_t
31005 </pre>
31006 which is type int; and
31007 <pre>
31008 rsize_t
31009 </pre>
31010 which is the type size_t.
31019 <pre>
31020 #define __STDC_WANT_LIB_EXT1__ 1
31022 errno_t memcpy_s(void * restrict s1, rsize_t s1max,
31023 const void * restrict s2, rsize_t n);
31024 </pre>
31025 Runtime-constraints
31027 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
31028 RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
31029 objects that overlap.
31031 If there is a runtime-constraint violation, the memcpy_s function stores zeros in the first
31032 s1max characters of the object pointed to by s1 if s1 is not a null pointer and s1max is
31033 not greater than RSIZE_MAX.
31036 The memcpy_s function copies n characters from the object pointed to by s2 into the
31037 object pointed to by s1.
31040 The memcpy_s function returns zero if there was no runtime-constraint violation.
31041 Otherwise, a nonzero value is returned.
31042 <!--page 633 -->
31048 <pre>
31049 #define __STDC_WANT_LIB_EXT1__ 1
31051 errno_t memmove_s(void *s1, rsize_t s1max,
31052 const void *s2, rsize_t n);
31053 </pre>
31054 Runtime-constraints
31056 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
31057 RSIZE_MAX. n shall not be greater than s1max.
31059 If there is a runtime-constraint violation, the memmove_s function stores zeros in the
31060 first s1max characters of the object pointed to by s1 if s1 is not a null pointer and
31061 s1max is not greater than RSIZE_MAX.
31064 The memmove_s function copies n characters from the object pointed to by s2 into the
31065 object pointed to by s1. This copying takes place as if the n characters from the object
31066 pointed to by s2 are first copied into a temporary array of n characters that does not
31067 overlap the objects pointed to by s1 or s2, and then the n characters from the temporary
31068 array are copied into the object pointed to by s1.
31071 The memmove_s function returns zero if there was no runtime-constraint violation.
31072 Otherwise, a nonzero value is returned.
31078 <pre>
31079 #define __STDC_WANT_LIB_EXT1__ 1
31081 errno_t strcpy_s(char * restrict s1,
31082 rsize_t s1max,
31083 const char * restrict s2);
31084 </pre>
31085 Runtime-constraints
31087 Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
31088 s1max shall not equal zero. s1max shall be greater than strnlen_s(s2, s1max).
31089 Copying shall not take place between objects that overlap.
31091 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
31092 greater than zero and not greater than RSIZE_MAX, then strcpy_s sets s1[0] to the
31093 null character.
31094 <!--page 634 -->
31097 The strcpy_s function copies the string pointed to by s2 (including the terminating
31098 null character) into the array pointed to by s1.
31100 All elements following the terminating null character (if any) written by strcpy_s in
31101 the array of s1max characters pointed to by s1 take unspecified values when
31105 The strcpy_s function returns zero<sup><a href="#note419"><b>419)</b></a></sup> if there was no runtime-constraint violation.
31106 Otherwise, a nonzero value is returned.
31109 <p><small><a name="note418" href="#note418">418)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
31110 any of those characters are null. Such an approach might write a character to every element of s1
31111 before discovering that the first element should be set to the null character.
31112 </small>
31113 <p><small><a name="note419" href="#note419">419)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
31114 within the array pointed to by s1 and that the result in s1 is null terminated.
31115 </small>
31121 <pre>
31122 #define __STDC_WANT_LIB_EXT1__ 1
31124 errno_t strncpy_s(char * restrict s1,
31125 rsize_t s1max,
31126 const char * restrict s2,
31127 rsize_t n);
31128 </pre>
31129 Runtime-constraints
31131 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
31132 RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
31133 shall be greater than strnlen_s(s2, s1max). Copying shall not take place between
31134 objects that overlap.
31136 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
31137 greater than zero and not greater than RSIZE_MAX, then strncpy_s sets s1[0] to the
31138 null character.
31141 The strncpy_s function copies not more than n successive characters (characters that
31142 follow a null character are not copied) from the array pointed to by s2 to the array
31143 pointed to by s1. If no null character was copied from s2, then s1[n] is set to a null
31144 character.
31147 <!--page 635 -->
31149 All elements following the terminating null character (if any) written by strncpy_s in
31150 the array of s1max characters pointed to by s1 take unspecified values when
31154 The strncpy_s function returns zero<sup><a href="#note421"><b>421)</b></a></sup> if there was no runtime-constraint violation.
31155 Otherwise, a nonzero value is returned.
31157 EXAMPLE 1 The strncpy_s function can be used to copy a string without the danger that the result
31158 will not be null terminated or that characters will be written past the end of the destination array.
31159 <pre>
31160 #define __STDC_WANT_LIB_EXT1__ 1
31162 /* ... */
31164 char src2[7] = {'g', 'o', 'o', 'd', 'b', 'y', 'e'};
31166 int r1, r2, r3;
31170 </pre>
31171 The first call will assign to r1 the value zero and to dst1 the sequence hello\0.
31172 The second call will assign to r2 a nonzero value and to dst2 the sequence \0.
31173 The third call will assign to r3 the value zero and to dst3 the sequence good\0.
31177 <p><small><a name="note420" href="#note420">420)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
31178 any of those characters are null. Such an approach might write a character to every element of s1
31179 before discovering that the first element should be set to the null character.
31180 </small>
31181 <p><small><a name="note421" href="#note421">421)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
31182 within the array pointed to by s1 and that the result in s1 is null terminated.
31183 </small>
31192 <pre>
31193 #define __STDC_WANT_LIB_EXT1__ 1
31195 errno_t strcat_s(char * restrict s1,
31196 rsize_t s1max,
31197 const char * restrict s2);
31198 </pre>
31199 Runtime-constraints
31201 Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
31202 strcat_s.
31207 <!--page 636 -->
31209 Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
31210 s1max shall not equal zero. m shall not equal zero.<sup><a href="#note422"><b>422)</b></a></sup> m shall be greater than
31211 strnlen_s(s2, m). Copying shall not take place between objects that overlap.
31213 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
31214 greater than zero and not greater than RSIZE_MAX, then strcat_s sets s1[0] to the
31215 null character.
31218 The strcat_s function appends a copy of the string pointed to by s2 (including the
31219 terminating null character) to the end of the string pointed to by s1. The initial character
31220 from s2 overwrites the null character at the end of s1.
31222 All elements following the terminating null character (if any) written by strcat_s in
31223 the array of s1max characters pointed to by s1 take unspecified values when
31227 The strcat_s function returns zero<sup><a href="#note424"><b>424)</b></a></sup> if there was no runtime-constraint violation.
31228 Otherwise, a nonzero value is returned.
31231 <p><small><a name="note422" href="#note422">422)</a> Zero means that s1 was not null terminated upon entry to strcat_s.
31232 </small>
31233 <p><small><a name="note423" href="#note423">423)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
31234 any of those characters are null. Such an approach might write a character to every element of s1
31235 before discovering that the first element should be set to the null character.
31236 </small>
31237 <p><small><a name="note424" href="#note424">424)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
31238 appended to the string pointed to by s1 and that the result in s1 is null terminated.
31239 </small>
31245 <pre>
31246 #define __STDC_WANT_LIB_EXT1__ 1
31248 errno_t strncat_s(char * restrict s1,
31249 rsize_t s1max,
31250 const char * restrict s2,
31251 rsize_t n);
31252 </pre>
31253 Runtime-constraints
31255 Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
31256 strncat_s.
31258 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
31259 RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note425"><b>425)</b></a></sup> If n is not less
31262 <!--page 637 -->
31263 than m, then m shall be greater than strnlen_s(s2, m). Copying shall not take
31264 place between objects that overlap.
31266 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
31267 greater than zero and not greater than RSIZE_MAX, then strncat_s sets s1[0] to the
31268 null character.
31271 The strncat_s function appends not more than n successive characters (characters
31272 that follow a null character are not copied) from the array pointed to by s2 to the end of
31273 the string pointed to by s1. The initial character from s2 overwrites the null character at
31274 the end of s1. If no null character was copied from s2, then s1[s1max-m+n] is set to
31275 a null character.
31277 All elements following the terminating null character (if any) written by strncat_s in
31278 the array of s1max characters pointed to by s1 take unspecified values when
31282 The strncat_s function returns zero<sup><a href="#note427"><b>427)</b></a></sup> if there was no runtime-constraint violation.
31283 Otherwise, a nonzero value is returned.
31285 EXAMPLE 1 The strncat_s function can be used to copy a string without the danger that the result
31286 will not be null terminated or that characters will be written past the end of the destination array.
31287 <pre>
31288 #define __STDC_WANT_LIB_EXT1__ 1
31290 /* ... */
31296 int r1, r2, r3, r4;
31301 </pre>
31302 After the first call r1 will have the value zero and s1 will contain the sequence goodbye\0.
31306 <!--page 638 -->
31307 After the second call r2 will have the value zero and s2 will contain the sequence hello\0.
31308 After the third call r3 will have a nonzero value and s3 will contain the sequence \0.
31309 After the fourth call r4 will have the value zero and s4 will contain the sequence abcdef\0.
31313 <p><small><a name="note425" href="#note425">425)</a> Zero means that s1 was not null terminated upon entry to strncat_s.
31314 </small>
31315 <p><small><a name="note426" href="#note426">426)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
31316 any of those characters are null. Such an approach might write a character to every element of s1
31317 before discovering that the first element should be set to the null character.
31318 </small>
31319 <p><small><a name="note427" href="#note427">427)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
31320 appended to the string pointed to by s1 and that the result in s1 is null terminated.
31321 </small>
31330 <pre>
31331 #define __STDC_WANT_LIB_EXT1__ 1
31333 char *strtok_s(char * restrict s1,
31334 rsize_t * restrict s1max,
31335 const char * restrict s2,
31336 char ** restrict ptr);
31337 </pre>
31338 Runtime-constraints
31340 None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
31341 shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
31342 The end of the token found shall occur within the first *s1max characters of s1 for the
31343 first call, and shall occur within the first *s1max characters of where searching resumes
31344 on subsequent calls.
31346 If there is a runtime-constraint violation, the strtok_s function does not indirect
31347 through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
31350 A sequence of calls to the strtok_s function breaks the string pointed to by s1 into a
31351 sequence of tokens, each of which is delimited by a character from the string pointed to
31352 by s2. The fourth argument points to a caller-provided char pointer into which the
31353 strtok_s function stores information necessary for it to continue scanning the same
31354 string.
31356 The first call in a sequence has a non-null first argument and s1max points to an object
31357 whose value is the number of elements in the character array pointed to by the first
31358 argument. The first call stores an initial value in the object pointed to by ptr and
31359 updates the value pointed to by s1max to reflect the number of elements that remain in
31360 relation to ptr. Subsequent calls in the sequence have a null first argument and the
31361 objects pointed to by s1max and ptr are required to have the values stored by the
31362 previous call in the sequence, which are then updated. The separator string pointed to by
31363 s2 may be different from call to call.
31365 The first call in the sequence searches the string pointed to by s1 for the first character
31366 that is not contained in the current separator string pointed to by s2. If no such character
31367 is found, then there are no tokens in the string pointed to by s1 and the strtok_s
31368 function returns a null pointer. If such a character is found, it is the start of the first token.
31369 <!--page 639 -->
31371 The strtok_s function then searches from there for the first character in s1 that is
31372 contained in the current separator string. If no such character is found, the current token
31373 extends to the end of the string pointed to by s1, and subsequent searches in the same
31374 string for a token return a null pointer. If such a character is found, it is overwritten by a
31375 null character, which terminates the current token.
31377 In all cases, the strtok_s function stores sufficient information in the pointer pointed
31378 to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
31379 value for ptr, shall start searching just past the element overwritten by a null character
31380 (if any).
31383 The strtok_s function returns a pointer to the first character of a token, or a null
31384 pointer if there is no token or there is a runtime-constraint violation.
31386 EXAMPLE
31387 <pre>
31388 #define __STDC_WANT_LIB_EXT1__ 1
31390 static char str1[] = "?a???b,,,#c";
31391 static char str2[] = "\t \t";
31392 char *t, *ptr1, *ptr2;
31393 rsize_t max1 = sizeof (str1);
31394 rsize_t max2 = sizeof (str2);
31400 </pre>
31410 <pre>
31411 #define __STDC_WANT_LIB_EXT1__ 1
31413 errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)
31414 </pre>
31415 Runtime-constraints
31417 s shall not be a null pointer. Neither smax nor n shall be greater than RSIZE_MAX. n
31418 shall not be greater than smax.
31420 If there is a runtime-constraint violation, then if s is not a null pointer and smax is not
31421 greater than RSIZE_MAX, the memset_s function stores the value of c (converted to an
31422 unsigned char) into each of the first smax characters of the object pointed to by s.
31423 <!--page 640 -->
31426 The memset_s function copies the value of c (converted to an unsigned char) into
31427 each of the first n characters of the object pointed to by s. Unlike memset, any call to
31428 the memset_s function shall be evaluated strictly according to the rules of the abstract
31429 machine as described in (<a href="#5.1.2.3">5.1.2.3</a>). That is, any call to the memset_s function shall
31430 assume that the memory indicated by s and n may be accessible in the future and thus
31431 must contain the values indicated by c.
31434 The memset_s function returns zero if there was no runtime-constraint violation.
31435 Otherwise, a nonzero value is returned.
31441 <pre>
31442 #define __STDC_WANT_LIB_EXT1__ 1
31444 errno_t strerror_s(char *s, rsize_t maxsize,
31445 errno_t errnum);
31446 </pre>
31447 Runtime-constraints
31449 s shall not be a null pointer. maxsize shall not be greater than RSIZE_MAX.
31450 maxsize shall not equal zero.
31452 If there is a runtime-constraint violation, then the array (if any) pointed to by s is not
31453 modified.
31456 The strerror_s function maps the number in errnum to a locale-specific message
31457 string. Typically, the values for errnum come from errno, but strerror_s shall
31458 map any value of type int to a message.
31460 If the length of the desired string is less than maxsize, then the string is copied to the
31461 array pointed to by s.
31463 Otherwise, if maxsize is greater than zero, then maxsize-1 characters are copied
31464 from the string to the array pointed to by s and then s[maxsize-1] is set to the null
31469 The strerror_s function returns zero if the length of the desired string was less than
31470 maxsize and there was no runtime-constraint violation. Otherwise, the strerror_s
31471 function returns a nonzero value.
31472 <!--page 641 -->
31478 <pre>
31479 #define __STDC_WANT_LIB_EXT1__ 1
31481 size_t strerrorlen_s(errno_t errnum);
31482 </pre>
31485 The strerrorlen_s function calculates the length of the (untruncated) locale-specific
31486 message string that the strerror_s function maps to errnum.
31489 The strerrorlen_s function returns the number of characters (not including the null
31490 character) in the full message string.
31496 <pre>
31497 #define __STDC_WANT_LIB_EXT1__ 1
31499 size_t strnlen_s(const char *s, size_t maxsize);
31500 </pre>
31503 The strnlen_s function computes the length of the string pointed to by s.
31506 If s is a null pointer,<sup><a href="#note428"><b>428)</b></a></sup> then the strnlen_s function returns zero.
31508 Otherwise, the strnlen_s function returns the number of characters that precede the
31509 terminating null character. If there is no null character in the first maxsize characters of
31510 s then strnlen_s returns maxsize. At most the first maxsize characters of s shall
31511 be accessed by strnlen_s.
31516 <!--page 642 -->
31519 <p><small><a name="note428" href="#note428">428)</a> Note that the strnlen_s function has no runtime-constraints. This lack of runtime-constraints
31520 along with the values returned for a null pointer or an unterminated string argument make
31521 strnlen_s useful in algorithms that gracefully handle such exceptional data.
31522 </small>
31529 The types are
31530 <pre>
31531 errno_t
31532 </pre>
31533 which is type int; and
31534 <pre>
31535 rsize_t
31536 </pre>
31537 which is the type size_t.
31542 A broken-down time is normalized if the values of the members of the tm structure are in
31546 <p><small><a name="note429" href="#note429">429)</a> The normal ranges are defined in <a href="#7.27.1">7.27.1</a>.
31547 </small>
31552 Like the strftime function, the asctime_s and ctime_s functions do not return a
31553 pointer to a static object, and other library functions are permitted to call them.
31559 <pre>
31560 #define __STDC_WANT_LIB_EXT1__ 1
31562 errno_t asctime_s(char *s, rsize_t maxsize,
31563 const struct tm *timeptr);
31564 </pre>
31565 Runtime-constraints
31567 Neither s nor timeptr shall be a null pointer. maxsize shall not be less than 26 and
31568 shall not be greater than RSIZE_MAX. The broken-down time pointed to by timeptr
31569 shall be normalized. The calendar year represented by the broken-down time pointed to
31570 by timeptr shall not be less than calendar year 0 and shall not be greater than calendar
31571 year 9999.
31573 If there is a runtime-constraint violation, there is no attempt to convert the time, and
31574 s[0] is set to a null character if s is not a null pointer and maxsize is not zero and is
31575 not greater than RSIZE_MAX.
31578 The asctime_s function converts the normalized broken-down time in the structure
31579 pointed to by timeptr into a 26 character (including the null character) string in the
31582 <!--page 643 -->
31583 form
31584 <pre>
31586 </pre>
31587 The fields making up this string are (in order):
31588 <ol>
31590 following three character weekday names: Sun, Mon, Tue, Wed, Thu, Fri, and Sat.
31591 <li> The character space.
31593 three character month names: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct,
31594 Nov, and Dec.
31595 <li> The character space.
31597 "%2d".
31598 <li> The character space.
31600 "%.2d".
31601 <li> The character colon.
31603 "%.2d".
31604 <li> The character colon.
31606 "%.2d".
31607 <li> The character space.
31609 format "%4d".
31610 <li> The character new line.
31611 <li> The null character.
31612 </ol>
31614 The strftime function allows more flexible formatting and supports locale-specific
31615 behavior. If you do not require the exact form of the result string produced by the
31616 asctime_s function, consider using the strftime function instead.
31619 The asctime_s function returns zero if the time was successfully converted and stored
31620 into the array pointed to by s. Otherwise, it returns a nonzero value.
31621 <!--page 644 -->
31627 <pre>
31628 #define __STDC_WANT_LIB_EXT1__ 1
31630 errno_t ctime_s(char *s, rsize_t maxsize,
31631 const time_t *timer);
31632 </pre>
31633 Runtime-constraints
31635 Neither s nor timer shall be a null pointer. maxsize shall not be less than 26 and
31636 shall not be greater than RSIZE_MAX.
31638 If there is a runtime-constraint violation, s[0] is set to a null character if s is not a null
31639 pointer and maxsize is not equal zero and is not greater than RSIZE_MAX.
31642 The ctime_s function converts the calendar time pointed to by timer to local time in
31643 the form of a string. It is equivalent to
31644 <pre>
31645 asctime_s(s, maxsize, localtime_s(timer))
31646 </pre>
31648 The strftime function allows more flexible formatting and supports locale-specific
31649 behavior. If you do not require the exact form of the result string produced by the
31650 ctime_s function, consider using the strftime function instead.
31653 The ctime_s function returns zero if the time was successfully converted and stored
31654 into the array pointed to by s. Otherwise, it returns a nonzero value.
31660 <pre>
31661 #define __STDC_WANT_LIB_EXT1__ 1
31663 struct tm *gmtime_s(const time_t * restrict timer,
31664 struct tm * restrict result);
31665 </pre>
31666 Runtime-constraints
31668 Neither timer nor result shall be a null pointer.
31670 If there is a runtime-constraint violation, there is no attempt to convert the time.
31673 The gmtime_s function converts the calendar time pointed to by timer into a broken-
31674 down time, expressed as UTC. The broken-down time is stored in the structure pointed
31675 <!--page 645 -->
31676 to by result.
31679 The gmtime_s function returns result, or a null pointer if the specified time cannot
31680 be converted to UTC or there is a runtime-constraint violation.
31686 <pre>
31687 #define __STDC_WANT_LIB_EXT1__ 1
31689 struct tm *localtime_s(const time_t * restrict timer,
31690 struct tm * restrict result);
31691 </pre>
31692 Runtime-constraints
31694 Neither timer nor result shall be a null pointer.
31696 If there is a runtime-constraint violation, there is no attempt to convert the time.
31699 The localtime_s function converts the calendar time pointed to by timer into a
31700 broken-down time, expressed as local time. The broken-down time is stored in the
31701 structure pointed to by result.
31704 The localtime_s function returns result, or a null pointer if the specified time
31705 cannot be converted to local time or there is a runtime-constraint violation.
31708 <h4><a name="K.3.9" href="#K.3.9">K.3.9 Extended multibyte and wide character utilities <wchar.h></a></h4>
31712 The types are
31713 <pre>
31714 errno_t
31715 </pre>
31716 which is type int; and
31717 <pre>
31718 rsize_t
31719 </pre>
31720 which is the type size_t.
31722 Unless explicitly stated otherwise, if the execution of a function described in this
31723 subclause causes copying to take place between objects that overlap, the objects take on
31724 unspecified values.
31725 <!--page 646 -->
31728 <h5><a name="K.3.9.1" href="#K.3.9.1">K.3.9.1 Formatted wide character input/output functions</a></h5>
31734 <pre>
31735 #define __STDC_WANT_LIB_EXT1__ 1
31737 int fwprintf_s(FILE * restrict stream,
31738 const wchar_t * restrict format, ...);
31739 </pre>
31740 Runtime-constraints
31742 Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note430"><b>430)</b></a></sup> (modified or
31743 not by flags, field width, or precision) shall not appear in the wide string pointed to by
31744 format. Any argument to fwprintf_s corresponding to a %s specifier shall not be a
31745 null pointer.
31747 If there is a runtime-constraint violation, the fwprintf_s function does not attempt to
31748 produce further output, and it is unspecified to what extent fwprintf_s produced
31749 output before discovering the runtime-constraint violation.
31752 The fwprintf_s function is equivalent to the fwprintf function except for the
31753 explicit runtime-constraints listed above.
31756 The fwprintf_s function returns the number of wide characters transmitted, or a
31757 negative value if an output error, encoding error, or runtime-constraint violation occurred.
31760 <p><small><a name="note430" href="#note430">430)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
31761 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
31762 example, if the entire format string was L"%%n".
31763 </small>
31769 <pre>
31770 #define __STDC_WANT_LIB_EXT1__ 1
31773 int fwscanf_s(FILE * restrict stream,
31774 const wchar_t * restrict format, ...);
31775 </pre>
31776 Runtime-constraints
31778 Neither stream nor format shall be a null pointer. Any argument indirected though in
31779 order to store converted input shall not be a null pointer.
31782 <!--page 647 -->
31784 If there is a runtime-constraint violation, the fwscanf_s function does not attempt to
31785 perform further input, and it is unspecified to what extent fwscanf_s performed input
31786 before discovering the runtime-constraint violation.
31789 The fwscanf_s function is equivalent to fwscanf except that the c, s, and [
31790 conversion specifiers apply to a pair of arguments (unless assignment suppression is
31791 indicated by a *). The first of these arguments is the same as for fwscanf. That
31792 argument is immediately followed in the argument list by the second argument, which has
31793 type size_t and gives the number of elements in the array pointed to by the first
31794 argument of the pair. If the first argument points to a scalar object, it is considered to be
31797 A matching failure occurs if the number of elements in a receiving object is insufficient to
31798 hold the converted input (including any trailing null character).
31801 The fwscanf_s function returns the value of the macro EOF if an input failure occurs
31802 before any conversion or if there is a runtime-constraint violation. Otherwise, the
31803 fwscanf_s function returns the number of input items assigned, which can be fewer
31804 than provided for, or even zero, in the event of an early matching failure.
31807 <p><small><a name="note431" href="#note431">431)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
31808 used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
31809 argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
31810 the format is not known at translation time. For example, an implementation may issue a diagnostic
31811 for each argument after format that has of type pointer to one of char, signed char,
31812 unsigned char, or void that is not followed by an argument of a type compatible with
31813 rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
31814 using the hh length modifier, a length argument must follow the pointer argument. Another useful
31815 diagnostic could flag any non-pointer argument following format that did not have a type
31816 compatible with rsize_t.
31817 </small>
31823 <pre>
31824 #define __STDC_WANT_LIB_EXT1__ 1
31826 int snwprintf_s(wchar_t * restrict s,
31827 rsize_t n,
31828 const wchar_t * restrict format, ...);
31829 </pre>
31830 Runtime-constraints
31832 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
31833 than RSIZE_MAX. The %n specifier<sup><a href="#note432"><b>432)</b></a></sup> (modified or not by flags, field width, or
31835 <!--page 648 -->
31836 precision) shall not appear in the wide string pointed to by format. Any argument to
31837 snwprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
31838 error shall occur.
31840 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
31841 than zero and less than RSIZE_MAX, then the snwprintf_s function sets s[0] to the
31842 null wide character.
31845 The snwprintf_s function is equivalent to the swprintf function except for the
31846 explicit runtime-constraints listed above.
31848 The snwprintf_s function, unlike swprintf_s, will truncate the result to fit within
31849 the array pointed to by s.
31852 The snwprintf_s function returns the number of wide characters that would have
31853 been written had n been sufficiently large, not counting the terminating wide null
31854 character, or a negative value if a runtime-constraint violation occurred. Thus, the null-
31855 terminated output has been completely written if and only if the returned value is
31856 nonnegative and less than n.
31859 <p><small><a name="note432" href="#note432">432)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
31860 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
31861 example, if the entire format string was L"%%n".
31862 </small>
31868 <pre>
31869 #define __STDC_WANT_LIB_EXT1__ 1
31871 int swprintf_s(wchar_t * restrict s, rsize_t n,
31872 const wchar_t * restrict format, ...);
31873 </pre>
31874 Runtime-constraints
31876 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
31877 than RSIZE_MAX. The number of wide characters (including the trailing null) required
31878 for the result to be written to the array pointed to by s shall not be greater than n. The %n
31879 specifier<sup><a href="#note433"><b>433)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
31880 wide string pointed to by format. Any argument to swprintf_s corresponding to a
31881 %s specifier shall not be a null pointer. No encoding error shall occur.
31884 <!--page 649 -->
31886 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
31887 than zero and less than RSIZE_MAX, then the swprintf_s function sets s[0] to the
31888 null wide character.
31891 The swprintf_s function is equivalent to the swprintf function except for the
31892 explicit runtime-constraints listed above.
31894 The swprintf_s function, unlike snwprintf_s, treats a result too big for the array
31895 pointed to by s as a runtime-constraint violation.
31898 If no runtime-constraint violation occurred, the swprintf_s function returns the
31899 number of wide characters written in the array, not counting the terminating null wide
31900 character. If an encoding error occurred or if n or more wide characters are requested to
31901 be written, swprintf_s returns a negative value. If any other runtime-constraint
31902 violation occurred, swprintf_s returns zero.
31905 <p><small><a name="note433" href="#note433">433)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
31906 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
31907 example, if the entire format string was L"%%n".
31908 </small>
31914 <pre>
31915 #define __STDC_WANT_LIB_EXT1__ 1
31917 int swscanf_s(const wchar_t * restrict s,
31918 const wchar_t * restrict format, ...);
31919 </pre>
31920 Runtime-constraints
31922 Neither s nor format shall be a null pointer. Any argument indirected though in order
31923 to store converted input shall not be a null pointer.
31925 If there is a runtime-constraint violation, the swscanf_s function does not attempt to
31926 perform further input, and it is unspecified to what extent swscanf_s performed input
31927 before discovering the runtime-constraint violation.
31930 The swscanf_s function is equivalent to fwscanf_s, except that the argument s
31931 specifies a wide string from which the input is to be obtained, rather than from a stream.
31932 Reaching the end of the wide string is equivalent to encountering end-of-file for the
31933 fwscanf_s function.
31936 The swscanf_s function returns the value of the macro EOF if an input failure occurs
31937 before any conversion or if there is a runtime-constraint violation. Otherwise, the
31938 swscanf_s function returns the number of input items assigned, which can be fewer
31939 than provided for, or even zero, in the event of an early matching failure.
31940 <!--page 650 -->
31946 <pre>
31947 #define __STDC_WANT_LIB_EXT1__ 1
31951 int vfwprintf_s(FILE * restrict stream,
31952 const wchar_t * restrict format,
31953 va_list arg);
31954 </pre>
31955 Runtime-constraints
31957 Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note434"><b>434)</b></a></sup> (modified or
31958 not by flags, field width, or precision) shall not appear in the wide string pointed to by
31959 format. Any argument to vfwprintf_s corresponding to a %s specifier shall not be
31960 a null pointer.
31962 If there is a runtime-constraint violation, the vfwprintf_s function does not attempt
31963 to produce further output, and it is unspecified to what extent vfwprintf_s produced
31964 output before discovering the runtime-constraint violation.
31967 The vfwprintf_s function is equivalent to the vfwprintf function except for the
31968 explicit runtime-constraints listed above.
31971 The vfwprintf_s function returns the number of wide characters transmitted, or a
31972 negative value if an output error, encoding error, or runtime-constraint violation occurred.
31975 <p><small><a name="note434" href="#note434">434)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
31976 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
31977 example, if the entire format string was L"%%n".
31978 </small>
31984 <pre>
31985 #define __STDC_WANT_LIB_EXT1__ 1
31989 int vfwscanf_s(FILE * restrict stream,
31990 const wchar_t * restrict format, va_list arg);
31991 </pre>
31995 <!--page 651 -->
31996 Runtime-constraints
31998 Neither stream nor format shall be a null pointer. Any argument indirected though in
31999 order to store converted input shall not be a null pointer.
32001 If there is a runtime-constraint violation, the vfwscanf_s function does not attempt to
32002 perform further input, and it is unspecified to what extent vfwscanf_s performed input
32003 before discovering the runtime-constraint violation.
32006 The vfwscanf_s function is equivalent to fwscanf_s, with the variable argument
32007 list replaced by arg, which shall have been initialized by the va_start macro (and
32008 possibly subsequent va_arg calls). The vfwscanf_s function does not invoke the
32012 The vfwscanf_s function returns the value of the macro EOF if an input failure occurs
32013 before any conversion or if there is a runtime-constraint violation. Otherwise, the
32014 vfwscanf_s function returns the number of input items assigned, which can be fewer
32015 than provided for, or even zero, in the event of an early matching failure.
32018 <p><small><a name="note435" href="#note435">435)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
32019 value of arg after the return is indeterminate.
32020 </small>
32026 <pre>
32027 #define __STDC_WANT_LIB_EXT1__ 1
32030 int vsnwprintf_s(wchar_t * restrict s,
32031 rsize_t n,
32032 const wchar_t * restrict format,
32033 va_list arg);
32034 </pre>
32035 Runtime-constraints
32037 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
32038 than RSIZE_MAX. The %n specifier<sup><a href="#note436"><b>436)</b></a></sup> (modified or not by flags, field width, or
32039 precision) shall not appear in the wide string pointed to by format. Any argument to
32040 vsnwprintf_s corresponding to a %s specifier shall not be a null pointer. No
32041 encoding error shall occur.
32043 <!--page 652 -->
32045 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
32046 than zero and less than RSIZE_MAX, then the vsnwprintf_s function sets s[0] to
32047 the null wide character.
32050 The vsnwprintf_s function is equivalent to the vswprintf function except for the
32051 explicit runtime-constraints listed above.
32053 The vsnwprintf_s function, unlike vswprintf_s, will truncate the result to fit
32054 within the array pointed to by s.
32057 The vsnwprintf_s function returns the number of wide characters that would have
32058 been written had n been sufficiently large, not counting the terminating null character, or
32059 a negative value if a runtime-constraint violation occurred. Thus, the null-terminated
32060 output has been completely written if and only if the returned value is nonnegative and
32061 less than n.
32064 <p><small><a name="note436" href="#note436">436)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
32065 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
32066 example, if the entire format string was L"%%n".
32067 </small>
32073 <pre>
32074 #define __STDC_WANT_LIB_EXT1__ 1
32077 int vswprintf_s(wchar_t * restrict s,
32078 rsize_t n,
32079 const wchar_t * restrict format,
32080 va_list arg);
32081 </pre>
32082 Runtime-constraints
32084 Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
32085 than RSIZE_MAX. The number of wide characters (including the trailing null) required
32086 for the result to be written to the array pointed to by s shall not be greater than n. The %n
32087 specifier<sup><a href="#note437"><b>437)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
32088 wide string pointed to by format. Any argument to vswprintf_s corresponding to a
32089 %s specifier shall not be a null pointer. No encoding error shall occur.
32091 If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
32092 than zero and less than RSIZE_MAX, then the vswprintf_s function sets s[0] to the
32093 null wide character.
32095 <!--page 653 -->
32098 The vswprintf_s function is equivalent to the vswprintf function except for the
32099 explicit runtime-constraints listed above.
32101 The vswprintf_s function, unlike vsnwprintf_s, treats a result too big for the
32102 array pointed to by s as a runtime-constraint violation.
32105 If no runtime-constraint violation occurred, the vswprintf_s function returns the
32106 number of wide characters written in the array, not counting the terminating null wide
32107 character. If an encoding error occurred or if n or more wide characters are requested to
32108 be written, vswprintf_s returns a negative value. If any other runtime-constraint
32109 violation occurred, vswprintf_s returns zero.
32112 <p><small><a name="note437" href="#note437">437)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
32113 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
32114 example, if the entire format string was L"%%n".
32115 </small>
32121 <pre>
32122 #define __STDC_WANT_LIB_EXT1__ 1
32125 int vswscanf_s(const wchar_t * restrict s,
32126 const wchar_t * restrict format,
32127 va_list arg);
32128 </pre>
32129 Runtime-constraints
32131 Neither s nor format shall be a null pointer. Any argument indirected though in order
32132 to store converted input shall not be a null pointer.
32134 If there is a runtime-constraint violation, the vswscanf_s function does not attempt to
32135 perform further input, and it is unspecified to what extent vswscanf_s performed input
32136 before discovering the runtime-constraint violation.
32139 The vswscanf_s function is equivalent to swscanf_s, with the variable argument
32140 list replaced by arg, which shall have been initialized by the va_start macro (and
32141 possibly subsequent va_arg calls). The vswscanf_s function does not invoke the
32147 <!--page 654 -->
32150 The vswscanf_s function returns the value of the macro EOF if an input failure occurs
32151 before any conversion or if there is a runtime-constraint violation. Otherwise, the
32152 vswscanf_s function returns the number of input items assigned, which can be fewer
32153 than provided for, or even zero, in the event of an early matching failure.
32156 <p><small><a name="note438" href="#note438">438)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
32157 value of arg after the return is indeterminate.
32158 </small>
32164 <pre>
32165 #define __STDC_WANT_LIB_EXT1__ 1
32168 int vwprintf_s(const wchar_t * restrict format,
32169 va_list arg);
32170 </pre>
32171 Runtime-constraints
32173 format shall not be a null pointer. The %n specifier<sup><a href="#note439"><b>439)</b></a></sup> (modified or not by flags, field
32174 width, or precision) shall not appear in the wide string pointed to by format. Any
32175 argument to vwprintf_s corresponding to a %s specifier shall not be a null pointer.
32177 If there is a runtime-constraint violation, the vwprintf_s function does not attempt to
32178 produce further output, and it is unspecified to what extent vwprintf_s produced
32179 output before discovering the runtime-constraint violation.
32182 The vwprintf_s function is equivalent to the vwprintf function except for the
32183 explicit runtime-constraints listed above.
32186 The vwprintf_s function returns the number of wide characters transmitted, or a
32187 negative value if an output error, encoding error, or runtime-constraint violation occurred.
32192 <!--page 655 -->
32195 <p><small><a name="note439" href="#note439">439)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
32196 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
32197 example, if the entire format string was L"%%n".
32198 </small>
32204 <pre>
32205 #define __STDC_WANT_LIB_EXT1__ 1
32208 int vwscanf_s(const wchar_t * restrict format,
32209 va_list arg);
32210 </pre>
32211 Runtime-constraints
32213 format shall not be a null pointer. Any argument indirected though in order to store
32214 converted input shall not be a null pointer.
32216 If there is a runtime-constraint violation, the vwscanf_s function does not attempt to
32217 perform further input, and it is unspecified to what extent vwscanf_s performed input
32218 before discovering the runtime-constraint violation.
32221 The vwscanf_s function is equivalent to wscanf_s, with the variable argument list
32222 replaced by arg, which shall have been initialized by the va_start macro (and
32223 possibly subsequent va_arg calls). The vwscanf_s function does not invoke the
32227 The vwscanf_s function returns the value of the macro EOF if an input failure occurs
32228 before any conversion or if there is a runtime-constraint violation. Otherwise, the
32229 vwscanf_s function returns the number of input items assigned, which can be fewer
32230 than provided for, or even zero, in the event of an early matching failure.
32233 <p><small><a name="note440" href="#note440">440)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
32234 value of arg after the return is indeterminate.
32235 </small>
32241 <pre>
32242 #define __STDC_WANT_LIB_EXT1__ 1
32244 int wprintf_s(const wchar_t * restrict format, ...);
32245 </pre>
32246 Runtime-constraints
32248 format shall not be a null pointer. The %n specifier<sup><a href="#note441"><b>441)</b></a></sup> (modified or not by flags, field
32250 <!--page 656 -->
32251 width, or precision) shall not appear in the wide string pointed to by format. Any
32252 argument to wprintf_s corresponding to a %s specifier shall not be a null pointer.
32254 If there is a runtime-constraint violation, the wprintf_s function does not attempt to
32255 produce further output, and it is unspecified to what extent wprintf_s produced output
32256 before discovering the runtime-constraint violation.
32259 The wprintf_s function is equivalent to the wprintf function except for the explicit
32260 runtime-constraints listed above.
32263 The wprintf_s function returns the number of wide characters transmitted, or a
32264 negative value if an output error, encoding error, or runtime-constraint violation occurred.
32267 <p><small><a name="note441" href="#note441">441)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
32268 string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
32269 example, if the entire format string was L"%%n".
32270 </small>
32276 <pre>
32277 #define __STDC_WANT_LIB_EXT1__ 1
32279 int wscanf_s(const wchar_t * restrict format, ...);
32280 </pre>
32281 Runtime-constraints
32283 format shall not be a null pointer. Any argument indirected though in order to store
32284 converted input shall not be a null pointer.
32286 If there is a runtime-constraint violation, the wscanf_s function does not attempt to
32287 perform further input, and it is unspecified to what extent wscanf_s performed input
32288 before discovering the runtime-constraint violation.
32291 The wscanf_s function is equivalent to fwscanf_s with the argument stdin
32292 interposed before the arguments to wscanf_s.
32295 The wscanf_s function returns the value of the macro EOF if an input failure occurs
32296 before any conversion or if there is a runtime-constraint violation. Otherwise, the
32297 wscanf_s function returns the number of input items assigned, which can be fewer than
32298 provided for, or even zero, in the event of an early matching failure.
32299 <!--page 657 -->
32311 <pre>
32312 #define __STDC_WANT_LIB_EXT1__ 1
32314 errno_t wcscpy_s(wchar_t * restrict s1,
32315 rsize_t s1max,
32316 const wchar_t * restrict s2);
32317 </pre>
32318 Runtime-constraints
32320 Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
32321 s1max shall not equal zero. s1max shall be greater than wcsnlen_s(s2, s1max).
32322 Copying shall not take place between objects that overlap.
32324 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
32325 greater than zero and not greater than RSIZE_MAX, then wcscpy_s sets s1[0] to the
32326 null wide character.
32329 The wcscpy_s function copies the wide string pointed to by s2 (including the
32330 terminating null wide character) into the array pointed to by s1.
32332 All elements following the terminating null wide character (if any) written by
32333 wcscpy_s in the array of s1max wide characters pointed to by s1 take unspecified
32337 The wcscpy_s function returns zero<sup><a href="#note443"><b>443)</b></a></sup> if there was no runtime-constraint violation.
32338 Otherwise, a nonzero value is returned.
32343 <!--page 658 -->
32346 <p><small><a name="note442" href="#note442">442)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
32347 if any of those wide characters are null. Such an approach might write a wide character to every
32348 element of s1 before discovering that the first element should be set to the null wide character.
32349 </small>
32350 <p><small><a name="note443" href="#note443">443)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
32351 fit within the array pointed to by s1 and that the result in s1 is null terminated.
32352 </small>
32358 <pre>
32359 #define __STDC_WANT_LIB_EXT1__ 1
32361 errno_t wcsncpy_s(wchar_t * restrict s1,
32362 rsize_t s1max,
32363 const wchar_t * restrict s2,
32364 rsize_t n);
32365 </pre>
32366 Runtime-constraints
32368 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
32369 RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
32370 shall be greater than wcsnlen_s(s2, s1max). Copying shall not take place between
32371 objects that overlap.
32373 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
32374 greater than zero and not greater than RSIZE_MAX, then wcsncpy_s sets s1[0] to the
32375 null wide character.
32378 The wcsncpy_s function copies not more than n successive wide characters (wide
32379 characters that follow a null wide character are not copied) from the array pointed to by
32380 s2 to the array pointed to by s1. If no null wide character was copied from s2, then
32381 s1[n] is set to a null wide character.
32383 All elements following the terminating null wide character (if any) written by
32384 wcsncpy_s in the array of s1max wide characters pointed to by s1 take unspecified
32388 The wcsncpy_s function returns zero<sup><a href="#note445"><b>445)</b></a></sup> if there was no runtime-constraint violation.
32389 Otherwise, a nonzero value is returned.
32391 EXAMPLE 1 The wcsncpy_s function can be used to copy a wide string without the danger that the
32392 result will not be null terminated or that wide characters will be written past the end of the destination
32393 array.
32398 <!--page 659 -->
32399 <pre>
32400 #define __STDC_WANT_LIB_EXT1__ 1
32402 /* ... */
32404 wchar_t src2[7] = {L'g', L'o', L'o', L'd', L'b', L'y', L'e'};
32406 int r1, r2, r3;
32410 </pre>
32411 The first call will assign to r1 the value zero and to dst1 the sequence of wide characters hello\0.
32412 The second call will assign to r2 a nonzero value and to dst2 the sequence of wide characters \0.
32413 The third call will assign to r3 the value zero and to dst3 the sequence of wide characters good\0.
32417 <p><small><a name="note444" href="#note444">444)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
32418 if any of those wide characters are null. Such an approach might write a wide character to every
32419 element of s1 before discovering that the first element should be set to the null wide character.
32420 </small>
32421 <p><small><a name="note445" href="#note445">445)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
32422 fit within the array pointed to by s1 and that the result in s1 is null terminated.
32423 </small>
32429 <pre>
32430 #define __STDC_WANT_LIB_EXT1__ 1
32432 errno_t wmemcpy_s(wchar_t * restrict s1,
32433 rsize_t s1max,
32434 const wchar_t * restrict s2,
32435 rsize_t n);
32436 </pre>
32437 Runtime-constraints
32439 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
32440 RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
32441 objects that overlap.
32443 If there is a runtime-constraint violation, the wmemcpy_s function stores zeros in the
32444 first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
32445 s1max is not greater than RSIZE_MAX.
32448 The wmemcpy_s function copies n successive wide characters from the object pointed
32449 to by s2 into the object pointed to by s1.
32452 The wmemcpy_s function returns zero if there was no runtime-constraint violation.
32453 Otherwise, a nonzero value is returned.
32454 <!--page 660 -->
32460 <pre>
32461 #define __STDC_WANT_LIB_EXT1__ 1
32463 errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
32464 const wchar_t *s2, rsize_t n);
32465 </pre>
32466 Runtime-constraints
32468 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
32469 RSIZE_MAX. n shall not be greater than s1max.
32471 If there is a runtime-constraint violation, the wmemmove_s function stores zeros in the
32472 first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
32473 s1max is not greater than RSIZE_MAX.
32476 The wmemmove_s function copies n successive wide characters from the object pointed
32477 to by s2 into the object pointed to by s1. This copying takes place as if the n wide
32478 characters from the object pointed to by s2 are first copied into a temporary array of n
32479 wide characters that does not overlap the objects pointed to by s1 or s2, and then the n
32480 wide characters from the temporary array are copied into the object pointed to by s1.
32483 The wmemmove_s function returns zero if there was no runtime-constraint violation.
32484 Otherwise, a nonzero value is returned.
32487 <h5><a name="K.3.9.2.2" href="#K.3.9.2.2">K.3.9.2.2 Wide string concatenation functions</a></h5>
32493 <pre>
32494 #define __STDC_WANT_LIB_EXT1__ 1
32496 errno_t wcscat_s(wchar_t * restrict s1,
32497 rsize_t s1max,
32498 const wchar_t * restrict s2);
32499 </pre>
32500 Runtime-constraints
32502 Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
32503 wcscat_s.
32505 Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
32506 s1max shall not equal zero. m shall not equal zero.<sup><a href="#note446"><b>446)</b></a></sup> m shall be greater than
32507 wcsnlen_s(s2, m). Copying shall not take place between objects that overlap.
32508 <!--page 661 -->
32510 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
32511 greater than zero and not greater than RSIZE_MAX, then wcscat_s sets s1[0] to the
32512 null wide character.
32515 The wcscat_s function appends a copy of the wide string pointed to by s2 (including
32516 the terminating null wide character) to the end of the wide string pointed to by s1. The
32517 initial wide character from s2 overwrites the null wide character at the end of s1.
32519 All elements following the terminating null wide character (if any) written by
32520 wcscat_s in the array of s1max wide characters pointed to by s1 take unspecified
32524 The wcscat_s function returns zero<sup><a href="#note448"><b>448)</b></a></sup> if there was no runtime-constraint violation.
32525 Otherwise, a nonzero value is returned.
32528 <p><small><a name="note446" href="#note446">446)</a> Zero means that s1 was not null terminated upon entry to wcscat_s.
32529 </small>
32530 <p><small><a name="note447" href="#note447">447)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
32531 checking if any of those wide characters are null. Such an approach might write a wide character to
32532 every element of s1 before discovering that the first element should be set to the null wide character.
32533 </small>
32534 <p><small><a name="note448" href="#note448">448)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
32535 s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
32536 </small>
32542 <pre>
32543 #define __STDC_WANT_LIB_EXT1__ 1
32545 errno_t wcsncat_s(wchar_t * restrict s1,
32546 rsize_t s1max,
32547 const wchar_t * restrict s2,
32548 rsize_t n);
32549 </pre>
32550 Runtime-constraints
32552 Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
32553 wcsncat_s.
32555 Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
32556 RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note449"><b>449)</b></a></sup> If n is not less
32557 than m, then m shall be greater than wcsnlen_s(s2, m). Copying shall not take
32558 place between objects that overlap.
32561 <!--page 662 -->
32563 If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
32564 greater than zero and not greater than RSIZE_MAX, then wcsncat_s sets s1[0] to the
32565 null wide character.
32568 The wcsncat_s function appends not more than n successive wide characters (wide
32569 characters that follow a null wide character are not copied) from the array pointed to by
32570 s2 to the end of the wide string pointed to by s1. The initial wide character from s2
32571 overwrites the null wide character at the end of s1. If no null wide character was copied
32572 from s2, then s1[s1max-m+n] is set to a null wide character.
32574 All elements following the terminating null wide character (if any) written by
32575 wcsncat_s in the array of s1max wide characters pointed to by s1 take unspecified
32579 The wcsncat_s function returns zero<sup><a href="#note451"><b>451)</b></a></sup> if there was no runtime-constraint violation.
32580 Otherwise, a nonzero value is returned.
32582 EXAMPLE 1 The wcsncat_s function can be used to copy a wide string without the danger that the
32583 result will not be null terminated or that wide characters will be written past the end of the destination
32584 array.
32585 <pre>
32586 #define __STDC_WANT_LIB_EXT1__ 1
32588 /* ... */
32594 int r1, r2, r3, r4;
32599 </pre>
32600 After the first call r1 will have the value zero and s1 will be the wide character sequence goodbye\0.
32601 After the second call r2 will have the value zero and s2 will be the wide character sequence hello\0.
32602 After the third call r3 will have a nonzero value and s3 will be the wide character sequence \0.
32603 After the fourth call r4 will have the value zero and s4 will be the wide character sequence abcdef\0.
32608 <!--page 663 -->
32611 <p><small><a name="note449" href="#note449">449)</a> Zero means that s1 was not null terminated upon entry to wcsncat_s.
32612 </small>
32613 <p><small><a name="note450" href="#note450">450)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
32614 checking if any of those wide characters are null. Such an approach might write a wide character to
32615 every element of s1 before discovering that the first element should be set to the null wide character.
32616 </small>
32617 <p><small><a name="note451" href="#note451">451)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
32618 s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
32619 </small>
32628 <pre>
32629 #define __STDC_WANT_LIB_EXT1__ 1
32631 wchar_t *wcstok_s(wchar_t * restrict s1,
32632 rsize_t * restrict s1max,
32633 const wchar_t * restrict s2,
32634 wchar_t ** restrict ptr);
32635 </pre>
32636 Runtime-constraints
32638 None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
32639 shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
32640 The end of the token found shall occur within the first *s1max wide characters of s1 for
32641 the first call, and shall occur within the first *s1max wide characters of where searching
32642 resumes on subsequent calls.
32644 If there is a runtime-constraint violation, the wcstok_s function does not indirect
32645 through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
32648 A sequence of calls to the wcstok_s function breaks the wide string pointed to by s1
32649 into a sequence of tokens, each of which is delimited by a wide character from the wide
32650 string pointed to by s2. The fourth argument points to a caller-provided wchar_t
32651 pointer into which the wcstok_s function stores information necessary for it to
32652 continue scanning the same wide string.
32654 The first call in a sequence has a non-null first argument and s1max points to an object
32655 whose value is the number of elements in the wide character array pointed to by the first
32656 argument. The first call stores an initial value in the object pointed to by ptr and
32657 updates the value pointed to by s1max to reflect the number of elements that remain in
32658 relation to ptr. Subsequent calls in the sequence have a null first argument and the
32659 objects pointed to by s1max and ptr are required to have the values stored by the
32660 previous call in the sequence, which are then updated. The separator wide string pointed
32661 to by s2 may be different from call to call.
32663 The first call in the sequence searches the wide string pointed to by s1 for the first wide
32664 character that is not contained in the current separator wide string pointed to by s2. If no
32665 such wide character is found, then there are no tokens in the wide string pointed to by s1
32666 and the wcstok_s function returns a null pointer. If such a wide character is found, it is
32667 the start of the first token.
32668 <!--page 664 -->
32670 The wcstok_s function then searches from there for the first wide character in s1 that
32671 is contained in the current separator wide string. If no such wide character is found, the
32672 current token extends to the end of the wide string pointed to by s1, and subsequent
32673 searches in the same wide string for a token return a null pointer. If such a wide character
32674 is found, it is overwritten by a null wide character, which terminates the current token.
32676 In all cases, the wcstok_s function stores sufficient information in the pointer pointed
32677 to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
32678 value for ptr, shall start searching just past the element overwritten by a null wide
32679 character (if any).
32682 The wcstok_s function returns a pointer to the first wide character of a token, or a null
32683 pointer if there is no token or there is a runtime-constraint violation.
32685 EXAMPLE
32686 <pre>
32687 #define __STDC_WANT_LIB_EXT1__ 1
32689 static wchar_t str1[] = L"?a???b,,,#c";
32690 static wchar_t str2[] = L"\t \t";
32691 wchar_t *t, *ptr1, *ptr2;
32692 rsize_t max1 = wcslen(str1)+1;
32693 rsize_t max2 = wcslen(str2)+1;
32699 </pre>
32709 <pre>
32710 #define __STDC_WANT_LIB_EXT1__ 1
32712 size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
32713 </pre>
32716 The wcsnlen_s function computes the length of the wide string pointed to by s.
32719 If s is a null pointer,<sup><a href="#note452"><b>452)</b></a></sup> then the wcsnlen_s function returns zero.
32721 Otherwise, the wcsnlen_s function returns the number of wide characters that precede
32722 the terminating null wide character. If there is no null wide character in the first
32723 maxsize wide characters of s then wcsnlen_s returns maxsize. At most the first
32724 <!--page 665 -->
32725 maxsize wide characters of s shall be accessed by wcsnlen_s.
32728 <p><small><a name="note452" href="#note452">452)</a> Note that the wcsnlen_s function has no runtime-constraints. This lack of runtime-constraints
32729 along with the values returned for a null pointer or an unterminated wide string argument make
32730 wcsnlen_s useful in algorithms that gracefully handle such exceptional data.
32731 </small>
32734 <h5><a name="K.3.9.3" href="#K.3.9.3">K.3.9.3 Extended multibyte/wide character conversion utilities</a></h5>
32737 <h5><a name="K.3.9.3.1" href="#K.3.9.3.1">K.3.9.3.1 Restartable multibyte/wide character conversion functions</a></h5>
32739 Unlike wcrtomb, wcrtomb_s does not permit the ps parameter (the pointer to the
32740 conversion state) to be a null pointer.
32746 <pre>
32748 errno_t wcrtomb_s(size_t * restrict retval,
32749 char * restrict s, rsize_t smax,
32750 wchar_t wc, mbstate_t * restrict ps);
32751 </pre>
32752 Runtime-constraints
32754 Neither retval nor ps shall be a null pointer. If s is not a null pointer, then smax
32755 shall not equal zero and shall not be greater than RSIZE_MAX. If s is not a null pointer,
32756 then smax shall be not be less than the number of bytes to be stored in the array pointed
32757 to by s. If s is a null pointer, then smax shall equal zero.
32759 If there is a runtime-constraint violation, then wcrtomb_s does the following. If s is
32760 not a null pointer and smax is greater than zero and not greater than RSIZE_MAX, then
32761 wcrtomb_s sets s[0] to the null character. If retval is not a null pointer, then
32762 wcrtomb_s sets *retval to (size_t)(-1).
32765 If s is a null pointer, the wcrtomb_s function is equivalent to the call
32766 <pre>
32768 </pre>
32769 where retval and buf are internal variables of the appropriate types, and the size of
32770 buf is greater than MB_CUR_MAX.
32772 If s is not a null pointer, the wcrtomb_s function determines the number of bytes
32773 needed to represent the multibyte character that corresponds to the wide character given
32774 by wc (including any shift sequences), and stores the multibyte character representation
32775 in the array whose first element is pointed to by s. At most MB_CUR_MAX bytes are
32776 stored. If wc is a null wide character, a null byte is stored, preceded by any shift
32777 sequence needed to restore the initial shift state; the resulting state described is the initial
32778 conversion state.
32780 <!--page 666 -->
32782 If wc does not correspond to a valid multibyte character, an encoding error occurs: the
32783 wcrtomb_s function stores the value (size_t)(-1) into *retval and the
32784 conversion state is unspecified. Otherwise, the wcrtomb_s function stores into
32785 *retval the number of bytes (including any shift sequences) stored in the array pointed
32786 to by s.
32789 The wcrtomb_s function returns zero if no runtime-constraint violation and no
32790 encoding error occurred. Otherwise, a nonzero value is returned.
32793 <h5><a name="K.3.9.3.2" href="#K.3.9.3.2">K.3.9.3.2 Restartable multibyte/wide string conversion functions</a></h5>
32795 Unlike mbsrtowcs and wcsrtombs, mbsrtowcs_s and wcsrtombs_s do not
32796 permit the ps parameter (the pointer to the conversion state) to be a null pointer.
32802 <pre>
32804 errno_t mbsrtowcs_s(size_t * restrict retval,
32805 wchar_t * restrict dst, rsize_t dstmax,
32806 const char ** restrict src, rsize_t len,
32807 mbstate_t * restrict ps);
32808 </pre>
32809 Runtime-constraints
32811 None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
32812 then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
32813 pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
32814 not equal zero. If dst is not a null pointer and len is not less than dstmax, then a null
32815 character shall occur within the first dstmax multibyte characters of the array pointed to
32816 by *src.
32818 If there is a runtime-constraint violation, then mbsrtowcs_s does the following. If
32819 retval is not a null pointer, then mbsrtowcs_s sets *retval to (size_t)(-1).
32820 If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
32821 then mbsrtowcs_s sets dst[0] to the null wide character.
32824 The mbsrtowcs_s function converts a sequence of multibyte characters that begins in
32825 the conversion state described by the object pointed to by ps, from the array indirectly
32826 pointed to by src into a sequence of corresponding wide characters. If dst is not a null
32827 pointer, the converted characters are stored into the array pointed to by dst. Conversion
32828 continues up to and including a terminating null character, which is also stored.
32829 Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
32830 not form a valid multibyte character, or (if dst is not a null pointer) when len wide
32831 <!--page 667 -->
32832 characters have been stored into the array pointed to by dst.<sup><a href="#note453"><b>453)</b></a></sup> If dst is not a null
32833 pointer and no null wide character was stored into the array pointed to by dst, then
32834 dst[len] is set to the null wide character. Each conversion takes place as if by a call
32835 to the mbrtowc function.
32837 If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
32838 pointer (if conversion stopped due to reaching a terminating null character) or the address
32839 just past the last multibyte character converted (if any). If conversion stopped due to
32840 reaching a terminating null character and if dst is not a null pointer, the resulting state
32841 described is the initial conversion state.
32843 Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
32844 sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
32845 the mbsrtowcs_s function stores the value (size_t)(-1) into *retval and the
32846 conversion state is unspecified. Otherwise, the mbsrtowcs_s function stores into
32847 *retval the number of multibyte characters successfully converted, not including the
32848 terminating null character (if any).
32850 All elements following the terminating null wide character (if any) written by
32851 mbsrtowcs_s in the array of dstmax wide characters pointed to by dst take
32854 If copying takes place between objects that overlap, the objects take on unspecified
32855 values.
32858 The mbsrtowcs_s function returns zero if no runtime-constraint violation and no
32859 encoding error occurred. Otherwise, a nonzero value is returned.
32862 <p><small><a name="note453" href="#note453">453)</a> Thus, the value of len is ignored if dst is a null pointer.
32863 </small>
32864 <p><small><a name="note454" href="#note454">454)</a> This allows an implementation to attempt converting the multibyte string before discovering a
32865 terminating null character did not occur where required.
32866 </small>
32872 <pre>
32874 errno_t wcsrtombs_s(size_t * restrict retval,
32875 char * restrict dst, rsize_t dstmax,
32876 const wchar_t ** restrict src, rsize_t len,
32877 mbstate_t * restrict ps);
32878 </pre>
32883 <!--page 668 -->
32884 Runtime-constraints
32886 None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
32887 then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
32888 pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
32889 not equal zero. If dst is not a null pointer and len is not less than dstmax, then the
32890 conversion shall have been stopped (see below) because a terminating null wide character
32891 was reached or because an encoding error occurred.
32893 If there is a runtime-constraint violation, then wcsrtombs_s does the following. If
32894 retval is not a null pointer, then wcsrtombs_s sets *retval to (size_t)(-1).
32895 If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
32896 then wcsrtombs_s sets dst[0] to the null character.
32899 The wcsrtombs_s function converts a sequence of wide characters from the array
32900 indirectly pointed to by src into a sequence of corresponding multibyte characters that
32901 begins in the conversion state described by the object pointed to by ps. If dst is not a
32902 null pointer, the converted characters are then stored into the array pointed to by dst.
32903 Conversion continues up to and including a terminating null wide character, which is also
32904 stored. Conversion stops earlier in two cases:
32905 <ul>
32906 <li> when a wide character is reached that does not correspond to a valid multibyte
32907 character;
32908 <li> (if dst is not a null pointer) when the next multibyte character would exceed the
32909 limit of n total bytes to be stored into the array pointed to by dst. If the wide
32910 character being converted is the null wide character, then n is the lesser of len or
32911 dstmax. Otherwise, n is the lesser of len or dstmax-1.
32912 </ul>
32913 If the conversion stops without converting a null wide character and dst is not a null
32914 pointer, then a null character is stored into the array pointed to by dst immediately
32915 following any multibyte characters already stored. Each conversion takes place as if by a
32918 If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
32919 pointer (if conversion stopped due to reaching a terminating null wide character) or the
32920 address just past the last wide character converted (if any). If conversion stopped due to
32921 reaching a terminating null wide character, the resulting state described is the initial
32922 conversion state.
32925 <!--page 669 -->
32927 Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
32928 wide character that does not correspond to a valid multibyte character, an encoding error
32929 occurs: the wcsrtombs_s function stores the value (size_t)(-1) into *retval
32930 and the conversion state is unspecified. Otherwise, the wcsrtombs_s function stores
32931 into *retval the number of bytes in the resulting multibyte character sequence, not
32932 including the terminating null character (if any).
32934 All elements following the terminating null character (if any) written by wcsrtombs_s
32935 in the array of dstmax elements pointed to by dst take unspecified values when
32938 If copying takes place between objects that overlap, the objects take on unspecified
32939 values.
32942 The wcsrtombs_s function returns zero if no runtime-constraint violation and no
32943 encoding error occurred. Otherwise, a nonzero value is returned.
32948 <!--page 670 -->
32951 <p><small><a name="note455" href="#note455">455)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
32952 include those necessary to reach the initial shift state immediately before the null byte. However, if
32953 the conversion stops before a terminating null wide character has been reached, the result will be null
32954 terminated, but might not end in the initial shift state.
32955 </small>
32956 <p><small><a name="note456" href="#note456">456)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
32957 runtime-constraint violation.
32958 </small>
32962 <pre>
32963 (normative)
32964 Analyzability
32965 </pre>
32970 This annex specifies optional behavior that can aid in the analyzability of C programs.
32972 An implementation that defines __STDC_ANALYZABLE__ shall conform to the
32976 <p><small><a name="note457" href="#note457">457)</a> Implementations that do not define __STDC_ANALYZABLE__ are not required to conform to these
32977 specifications.
32978 </small>
32986 out-of-bounds store
32987 an (attempted) access (<a href="#3.1">3.1</a>) that, at run time, for a given computational state, would
32988 modify (or, for an object declared volatile, fetch) one or more bytes that lie outside
32989 the bounds permitted by this Standard.
32994 bounded undefined behavior
32997 NOTE 1 The behavior might perform a trap.
33000 NOTE 2 Any values produced or stored might be indeterminate values.
33006 critical undefined behavior
33007 undefined behavior that is not bounded undefined behavior.
33009 NOTE The behavior might perform an out-of-bounds store or perform a trap.
33014 <!--page 671 -->
33019 If the program performs a trap (<a href="#3.19.5">3.19.5</a>), the implementation is permitted to invoke a
33020 runtime-constraint handler. Any such semantics are implementation-defined.
33022 All undefined behavior shall be limited to bounded undefined behavior, except for the
33023 following which are permitted to result in critical undefined behavior:
33024 <ul>
33026 <li> A store is performed to an object that has two incompatible declarations (<a href="#6.2.7">6.2.7</a>),
33027 <li> A pointer is used to call a function whose type is not compatible with the referenced
33028 type (<a href="#6.2.7">6.2.7</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>).
33031 <li> The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
33032 <li> Addition or subtraction of a pointer into, or just beyond, an array object and an
33033 integer type produces a result that points just beyond the array object and is used as
33035 <li> An attempt is made to modify an object defined with a const-qualified type through
33037 <li> An argument to a function or macro defined in the standard library has an invalid
33038 value or a type not expected by a function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
33039 <li> The longjmp function is called with a jmp_buf argument where the most recent
33040 invocation of the setjmp macro in the same invocation of the program with the
33041 corresponding jmp_buf argument is nonexistent, or the invocation was from another
33042 thread of execution, or the function containing the invocation has terminated
33043 execution in the interim, or the invocation was within the scope of an identifier with
33044 variably modified type and execution has left that scope in the interim (<a href="#7.13.2.1">7.13.2.1</a>).
33045 <li> The value of a pointer that refers to space deallocated by a call to the free or realloc
33047 <li> A string or wide string utility function accesses an array beyond the end of an object
33049 <!--page 672 -->
33050 </ul>
33054 <ol>
33055 <li> ''The C Reference Manual'' by Dennis M. Ritchie, a version of which was
33056 published in The C Programming Language by Brian W. Kernighan and Dennis
33059 California, USA, November 1984.
33061 Processing Systems, Information Processing Systems Technical Report.
33063 Arithmetic.
33065 Floating-Point Arithmetic.
33069 symbols for use in the physical sciences and technology.
33071 information interchange.
33073 Fundamental terms.
33076 interchange -- Representation of dates and times.
33085 <!--page 673 -->
33087 Interface (POSIX) -- Part 2: Shell and Utilities.
33089 preparation of programming language standards.
33091 Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.
33103 syllables.
33105 Tibetan.
33107 additional characters.
33110 Identifiers for characters.
33112 Ethiopic.
33114 Unified Canadian Aboriginal Syllabics.
33116 Cherokee.
33118 arithmetic -- Part 1: Integer and floating point arithmetic.
33119 <!--page 674 -->
33121 their environments and system software interfaces -- Extensions for the
33122 programming language C to support new character data types.
33124 their environments and system software interfaces -- Extensions to the C library
33125 -- Part 1: Bounds-checking interfaces.
33126 <!--page 675 -->
33127 </ol>
33131 <pre>
33132 [^ x ^], <a href="#3.20">3.20</a> , (comma operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a>
33133 , (comma punctuator), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,
33135 ! (logical negation operator), <a href="#6.5.3.3">6.5.3.3</a> - (subtraction operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
33136 != (inequality operator), <a href="#6.5.9">6.5.9</a> - (unary minus operator), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
33137 # operator, <a href="#6.10.3.2">6.10.3.2</a> -- (postfix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
33138 # preprocessing directive, <a href="#6.10.7">6.10.7</a> -- (prefix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
33139 # punctuator, <a href="#6.10">6.10</a> -= (subtraction assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
33140 ## operator, <a href="#6.10.3.3">6.10.3.3</a> -> (structure/union pointer operator), <a href="#6.5.2.3">6.5.2.3</a>
33141 #define preprocessing directive, <a href="#6.10.3">6.10.3</a> . (structure/union member operator), <a href="#6.3.2.1">6.3.2.1</a>,
33143 #else preprocessing directive, <a href="#6.10.1">6.10.1</a> . punctuator, <a href="#6.7.9">6.7.9</a>
33144 #endif preprocessing directive, <a href="#6.10.1">6.10.1</a> ... (ellipsis punctuator), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
33145 #error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a> / (division operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
33146 #if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, /* */ (comment delimiters), <a href="#6.4.9">6.4.9</a>
33147 <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a> // (comment delimiter), <a href="#6.4.9">6.4.9</a>
33148 #ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a> /= (division assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
33149 #ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a> : (colon punctuator), <a href="#6.7.2.1">6.7.2.1</a>
33150 #include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, :> (alternative spelling of ]), <a href="#6.4.6">6.4.6</a>
33151 <a href="#6.10.2">6.10.2</a> ; (semicolon punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
33152 #line preprocessing directive, <a href="#6.10.4">6.10.4</a> <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
33153 #pragma preprocessing directive, <a href="#6.10.6">6.10.6</a> < (less-than operator), <a href="#6.5.8">6.5.8</a>
33154 #undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>, <% (alternative spelling of {), <a href="#6.4.6">6.4.6</a>
33156 % (remainder operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a> << (left-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
33157 %: (alternative spelling of #), <a href="#6.4.6">6.4.6</a> <<= (left-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
33158 %:%: (alternative spelling of ##), <a href="#6.4.6">6.4.6</a> <= (less-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>
33159 %= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a> <a href="#7.2"><assert.h></a> header, <a href="#7.2">7.2</a>
33160 %> (alternative spelling of }), <a href="#6.4.6">6.4.6</a> <a href="#7.3"><complex.h></a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,
33161 & (address operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a> <a href="#7.3">7.3</a>, <a href="#7.25">7.25</a>, <a href="#7.31.1">7.31.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
33162 & (bitwise AND operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a> <a href="#7.4"><ctype.h></a> header, <a href="#7.4">7.4</a>, <a href="#7.31.2">7.31.2</a>
33163 && (logical AND operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a> <a href="#7.5"><errno.h></a> header, <a href="#7.5">7.5</a>, <a href="#7.31.3">7.31.3</a>, <a href="#K.3.2">K.3.2</a>
33164 &= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a> <a href="#7.6"><fenv.h></a> header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>,
33165 ' ' (space character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.31.4">7.31.4</a>, <a href="#F">F</a>, <a href="#H">H</a>
33166 <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.30.2.1.3">7.30.2.1.3</a> <a href="#7.7"><float.h></a> header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
33168 ( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a> <a href="#7.8"><inttypes.h></a> header, <a href="#7.8">7.8</a>, <a href="#7.31.5">7.31.5</a>
33169 ( ) (parentheses punctuator), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a> <a href="#7.9"><iso646.h></a> header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
33170 ( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a> <a href="#7.10"><limits.h></a> header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
33171 * (asterisk punctuator), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a> <a href="#7.11"><locale.h></a> header, <a href="#7.11">7.11</a>, <a href="#7.31.6">7.31.6</a>
33172 * (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a> <a href="#7.12"><math.h></a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.25">7.25</a>, <a href="#F">F</a>,
33173 * (multiplication operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a>
33174 <a href="#G.5.1">G.5.1</a> <a href="#7.13"><setjmp.h></a> header, <a href="#7.13">7.13</a>
33175 *= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a> <a href="#7.14"><signal.h></a> header, <a href="#7.14">7.14</a>, <a href="#7.31.7">7.31.7</a>
33176 + (addition operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, <a href="#7.15"><stdalign.h></a> header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
33177 <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a> <a href="#7.16"><stdarg.h></a> header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
33178 + (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a> <a href="#7.17"><stdatomic.h></a> header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>,
33179 ++ (postfix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a> <a href="#7.31.8">7.31.8</a>
33180 ++ (prefix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a> <a href="#7.18"><stdbool.h></a> header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.31.9">7.31.9</a>, <a href="#H">H</a>
33182 <!--page 676 -->
33183 <a href="#7.19"><stddef.h></a> header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>, \u (universal character names), <a href="#6.4.3">6.4.3</a>
33184 <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a> \v (vertical-tab escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
33185 <a href="#7.20"><stdint.h></a> header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.4.1.10">7.4.1.10</a>
33186 <a href="#7.20">7.20</a>, <a href="#7.31.10">7.31.10</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a> \x hexadecimal digits (hexadecimal-character
33187 <a href="#7.21"><stdio.h></a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.31.11">7.31.11</a>, <a href="#F">F</a>, escape sequence), <a href="#6.4.4.4">6.4.4.4</a>
33188 <a href="#K.3.5">K.3.5</a> ^ (bitwise exclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
33189 <a href="#7.22"><stdlib.h></a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.31.12">7.31.12</a>, <a href="#F">F</a>, ^= (bitwise exclusive OR assignment operator),
33191 <a href="#7.23"><stdnoreturn.h></a> header, <a href="#4">4</a>, <a href="#7.23">7.23</a> __alignas_is_defined macro, <a href="#7.15">7.15</a>
33192 <a href="#7.24"><string.h></a> header, <a href="#7.24">7.24</a>, <a href="#7.31.13">7.31.13</a>, <a href="#K.3.7">K.3.7</a> __alignof_is_defined macro, <a href="#7.15">7.15</a>
33193 <a href="#7.25"><tgmath.h></a> header, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> __bool_true_false_are_defined
33194 <a href="#7.26"><threads.h></a> header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.26">7.26</a>, macro, <a href="#7.18">7.18</a>
33196 <a href="#7.27"><time.h></a> header, <a href="#7.26.1">7.26.1</a>, <a href="#7.27">7.27</a>, <a href="#7.31.14">7.31.14</a>, <a href="#K.3.8">K.3.8</a> __DATE__ macro, <a href="#6.10.8.1">6.10.8.1</a>
33197 <a href="#7.28"><uchar.h></a> header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.28">7.28</a> __FILE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
33198 <a href="#7.29"><wchar.h></a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.29">7.29</a>, __func__ identifier, <a href="#6.4.2.2">6.4.2.2</a>, <a href="#7.2.1.1">7.2.1.1</a>
33199 <a href="#7.31.16">7.31.16</a>, <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a> __LINE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
33200 <a href="#7.30"><wctype.h></a> header, <a href="#7.30">7.30</a>, <a href="#7.31.17">7.31.17</a> __STDC_, <a href="#6.11.9">6.11.9</a>
33201 = (equal-sign punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a> __STDC__ macro, <a href="#6.10.8.1">6.10.8.1</a>
33202 = (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a> __STDC_ANALYZABLE__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#L.1">L.1</a>
33203 == (equality operator), <a href="#6.5.9">6.5.9</a> __STDC_HOSTED__ macro, <a href="#6.10.8.1">6.10.8.1</a>
33204 > (greater-than operator), <a href="#6.5.8">6.5.8</a> __STDC_IEC_559__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#F.1">F.1</a>
33205 >= (greater-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a> __STDC_IEC_559_COMPLEX__ macro,
33206 >> (right-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a> <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G.1">G.1</a>
33207 >>= (right-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a> __STDC_ISO_10646__ macro, <a href="#6.10.8.2">6.10.8.2</a>
33208 ? : (conditional operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a> __STDC_LIB_EXT1__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#K.2">K.2</a>
33210 [ ] (array subscript operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a> <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>
33211 [ ] (brackets punctuator), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a> __STDC_NO_ATOMICS__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
33212 \ (backslash character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a> <a href="#7.17.1">7.17.1</a>
33213 \ (escape character), <a href="#6.4.4.4">6.4.4.4</a> __STDC_NO_COMPLEX__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
33215 <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a> __STDC_NO_THREADS__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
33216 \\ (backslash escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a> <a href="#7.26.1">7.26.1</a>
33217 \' (single-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a> __STDC_NO_VLA__ macro, <a href="#6.10.8.3">6.10.8.3</a>
33218 \0 (null character), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a> __STDC_UTF_16__ macro, <a href="#6.10.8.2">6.10.8.2</a>
33219 padding of binary stream, <a href="#7.21.2">7.21.2</a> __STDC_UTF_32__ macro, <a href="#6.10.8.2">6.10.8.2</a>
33220 \? (question-mark escape sequence), <a href="#6.4.4.4">6.4.4.4</a> __STDC_VERSION__ macro, <a href="#6.10.8.1">6.10.8.1</a>
33221 \a (alert escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a> __STDC_WANT_LIB_EXT1__ macro, <a href="#K.3.1.1">K.3.1.1</a>
33222 \b (backspace escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a> __TIME__ macro, <a href="#6.10.8.1">6.10.8.1</a>
33223 \f (form-feed escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, __VA_ARGS__ identifier, <a href="#6.10.3">6.10.3</a>, <a href="#6.10.3.1">6.10.3.1</a>
33225 \n (new-line escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, _Alignof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>
33227 \octal digits (octal-character escape sequence), _Atomic type specifier, <a href="#6.7.2.4">6.7.2.4</a>
33228 <a href="#6.4.4.4">6.4.4.4</a> _Bool type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.4">F.4</a>
33229 \r (carriage-return escape sequence), <a href="#5.2.2">5.2.2</a>, _Bool type conversions, <a href="#6.3.1.2">6.3.1.2</a>
33230 <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a> _Complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
33231 \t (horizontal-tab escape sequence), <a href="#5.2.2">5.2.2</a>, _Complex_I macro, <a href="#7.3.1">7.3.1</a>
33232 <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.30.2.1.3">7.30.2.1.3</a> _Exit function, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
33233 \U (universal character names), <a href="#6.4.3">6.4.3</a> _Imaginary keyword, <a href="#G.2">G.2</a>
33234 <!--page 677 -->
33235 _Imaginary types, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a> aliasing, <a href="#6.5">6.5</a>
33236 _Imaginary_I macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a> alignas macro, <a href="#7.15">7.15</a>
33237 _IOFBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a> aligned_alloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.1">7.22.3.1</a>
33238 _IOLBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.6">7.21.5.6</a> alignment, <a href="#3.2">3.2</a>, <a href="#6.2.8">6.2.8</a>, <a href="#7.22.3.1">7.22.3.1</a>
33239 _IONBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a> pointer, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.3">6.3.2.3</a>
33242 _Pragma operator, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a> alignment specifier, <a href="#6.7.5">6.7.5</a>
33243 _Static_assert, <a href="#6.7.10">6.7.10</a>, <a href="#7.2">7.2</a> alignof macro, <a href="#7.15">7.15</a>
33244 _Thread_local storage-class specifier, <a href="#6.2.4">6.2.4</a>, allocated storage, order and contiguity, <a href="#7.22.3">7.22.3</a>
33245 <a href="#6.7.1">6.7.1</a>, <a href="#7.26.1">7.26.1</a> alternative spellings header, <a href="#7.9">7.9</a>
33246 { } (braces punctuator), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>, and macro, <a href="#7.9">7.9</a>
33248 { } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a> bitwise (&), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
33249 | (bitwise inclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a> bitwise assignment (&=), <a href="#6.5.16.2">6.5.16.2</a>
33250 |= (bitwise inclusive OR assignment operator), logical (&&), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>
33252 || (logical OR operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a> anonymous structure, <a href="#6.7.2.1">6.7.2.1</a>
33253 ~ (bitwise complement operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a> anonymous union, <a href="#6.7.2.1">6.7.2.1</a>
33255 abort function, <a href="#7.2.1.1">7.2.1.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>, ANSI/IEEE 854, <a href="#F.1">F.1</a>
33256 <a href="#7.22.4.1">7.22.4.1</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a> argc (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
33260 complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a> function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
33261 integer, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.22.6.1">7.22.6.1</a> macro, substitution, <a href="#6.10.3.1">6.10.3.1</a>
33262 real, <a href="#7.12.7">7.12.7</a>, <a href="#F.10.4">F.10.4</a> argument, complex, <a href="#7.3.9.1">7.3.9.1</a>
33263 abstract declarator, <a href="#6.7.7">6.7.7</a> argv (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
33264 abstract machine, <a href="#5.1.2.3">5.1.2.3</a> arithmetic constant expression, <a href="#6.6">6.6</a>
33265 access, <a href="#3.1">3.1</a>, <a href="#6.7.3">6.7.3</a>, <a href="#L.2.1">L.2.1</a> arithmetic conversions, usual, see usual arithmetic
33266 accuracy, see floating-point accuracy conversions
33267 acos functions, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#F.10.1.1">F.10.1.1</a> arithmetic operators
33268 acos type-generic macro, <a href="#7.25">7.25</a> additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>
33269 acosh functions, <a href="#7.12.5.1">7.12.5.1</a>, <a href="#F.10.2.1">F.10.2.1</a> bitwise, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>
33270 acosh type-generic macro, <a href="#7.25">7.25</a> increment and decrement, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>
33271 acquire fence, <a href="#7.17.4">7.17.4</a> multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
33272 acquire operation, <a href="#5.1.2.4">5.1.2.4</a> shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
33275 actual parameter (deprecated), <a href="#3.3">3.3</a> arithmetic, pointer, <a href="#6.5.6">6.5.6</a>
33277 addition operator (+), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, argument, <a href="#6.9.1">6.9.1</a>
33278 <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a> declarator, <a href="#6.7.6.2">6.7.6.2</a>
33279 additive expressions, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a> initialization, <a href="#6.7.9">6.7.9</a>
33281 address operator (&), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a> parameter, <a href="#6.9.1">6.9.1</a>
33283 aggregate initialization, <a href="#6.7.9">6.7.9</a> subscript operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
33285 alert escape sequence (\a), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a> type, <a href="#6.2.5">6.2.5</a>
33286 <!--page 678 -->
33288 variable length, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a> atomic_flag type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>
33289 arrow operator (->), <a href="#6.5.2.3">6.5.2.3</a> atomic_flag_clear functions, <a href="#7.17.8.2">7.17.8.2</a>
33290 as-if rule, <a href="#5.1.2.3">5.1.2.3</a> ATOMIC_FLAG_INIT macro, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>
33293 asctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a> atomic_init generic function, <a href="#7.17.2.2">7.17.2.2</a>
33294 asin functions, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#F.10.1.2">F.10.1.2</a> ATOMIC_INT_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
33295 asin type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> atomic_is_lock_free generic function,
33296 asinh functions, <a href="#7.12.5.2">7.12.5.2</a>, <a href="#F.10.2.2">F.10.2.2</a> <a href="#7.17.5.1">7.17.5.1</a>
33297 asinh type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> ATOMIC_LLONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
33298 asm keyword, <a href="#J.5.10">J.5.10</a> atomic_load generic functions, <a href="#7.17.7.2">7.17.7.2</a>
33299 assert macro, <a href="#7.2.1.1">7.2.1.1</a> ATOMIC_LONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
33300 assert.h header, <a href="#7.2">7.2</a> ATOMIC_LLONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
33302 compound, <a href="#6.5.16.2">6.5.16.2</a> atomic_signal_fence function, <a href="#7.17.4.2">7.17.4.2</a>
33303 conversion, <a href="#6.5.16.1">6.5.16.1</a> atomic_store generic functions, <a href="#7.17.7.1">7.17.7.1</a>
33304 expression, <a href="#6.5.16">6.5.16</a> atomic_thread_fence function, <a href="#7.17.4.1">7.17.4.1</a>
33305 operators, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a> ATOMIC_VAR_INIT macro, <a href="#7.17.2.1">7.17.2.1</a>
33306 simple, <a href="#6.5.16.1">6.5.16.1</a> ATOMIC_WCHAR_T_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
33307 associativity of operators, <a href="#6.5">6.5</a> atomics header, <a href="#7.17">7.17</a>, <a href="#7.31.8">7.31.8</a>
33308 asterisk punctuator (*), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a> auto storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
33309 at_quick_exit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>, automatic storage duration, <a href="#5.2.3">5.2.3</a>, <a href="#6.2.4">6.2.4</a>
33310 <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
33311 atan functions, <a href="#7.12.4.3">7.12.4.3</a>, <a href="#F.10.1.3">F.10.1.3</a> backslash character (\), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
33312 atan type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> backslash escape sequence (\\), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>
33313 atan2 functions, <a href="#7.12.4.4">7.12.4.4</a>, <a href="#F.10.1.4">F.10.1.4</a> backspace escape sequence (\b), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
33314 atan2 type-generic macro, <a href="#7.25">7.25</a> basic character set, <a href="#3.6">3.6</a>, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>
33315 atanh functions, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#F.10.2.3">F.10.2.3</a> basic types, <a href="#6.2.5">6.2.5</a>
33316 atanh type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> behavior, <a href="#3.4">3.4</a>
33317 atexit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>, binary streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
33318 <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>, <a href="#J.5.13">J.5.13</a> <a href="#7.21.9.4">7.21.9.4</a>
33319 atof function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.1">7.22.1.1</a> bit, <a href="#3.5">3.5</a>
33320 atoi function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a> high order, <a href="#3.6">3.6</a>
33321 atol function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a> low order, <a href="#3.6">3.6</a>
33322 atoll function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a> bit-field, <a href="#6.7.2.1">6.7.2.1</a>
33323 atomic lock-free macros, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.5">7.17.5</a> bitand macro, <a href="#7.9">7.9</a>
33325 atomic types, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, bitwise operators, <a href="#6.5">6.5</a>
33326 <a href="#6.5.2.3">6.5.2.3</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>, AND, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
33328 ATOMIC_CHAR_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a> complement (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>
33329 ATOMIC_CHAR16_T_LOCK_FREE macro, exclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
33331 ATOMIC_CHAR32_T_LOCK_FREE macro, inclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
33333 ATOMIC_CHAR_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a> shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
33335 functions, <a href="#7.17.7.4">7.17.7.4</a> block, <a href="#6.8">6.8</a>, <a href="#6.8.2">6.8.2</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
33336 atomic_exchange generic functions, <a href="#7.17.7.3">7.17.7.3</a> block scope, <a href="#6.2.1">6.2.1</a>
33338 <!--page 679 -->
33342 boolean type and values header, <a href="#7.18">7.18</a>, <a href="#7.31.9">7.31.9</a> catan functions, <a href="#7.3.5.3">7.3.5.3</a>, <a href="#G.6">G.6</a>
33343 boolean type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a> type-generic macro for, <a href="#7.25">7.25</a>
33344 bounded undefined behavior, <a href="#L.2.2">L.2.2</a> catanh functions, <a href="#7.3.6.3">7.3.6.3</a>, <a href="#G.6.2.3">G.6.2.3</a>
33345 braces punctuator ({ }), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>, type-generic macro for, <a href="#7.25">7.25</a>
33346 <a href="#6.8.2">6.8.2</a> cbrt functions, <a href="#7.12.7.1">7.12.7.1</a>, <a href="#F.10.4.1">F.10.4.1</a>
33347 brackets operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a> cbrt type-generic macro, <a href="#7.25">7.25</a>
33348 brackets punctuator ([ ]), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a> ccos functions, <a href="#7.3.5.4">7.3.5.4</a>, <a href="#G.6">G.6</a>
33350 break statement, <a href="#6.8.6.3">6.8.6.3</a> ccosh functions, <a href="#7.3.6.4">7.3.6.4</a>, <a href="#G.6.2.4">G.6.2.4</a>
33351 broken-down time, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.3">7.27.2.3</a>, <a href="#7.27.3">7.27.3</a>, type-generic macro for, <a href="#7.25">7.25</a>
33352 <a href="#7.27.3.1">7.27.3.1</a>, <a href="#7.27.3.3">7.27.3.3</a>, <a href="#7.27.3.4">7.27.3.4</a>, <a href="#7.27.3.5">7.27.3.5</a>, ceil functions, <a href="#7.12.9.1">7.12.9.1</a>, <a href="#F.10.6.1">F.10.6.1</a>
33353 <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a> ceil type-generic macro, <a href="#7.25">7.25</a>
33354 bsearch function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a> cerf function, <a href="#7.31.1">7.31.1</a>
33355 bsearch_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a> cerfc function, <a href="#7.31.1">7.31.1</a>
33356 btowc function, <a href="#7.29.6.1.1">7.29.6.1.1</a> cexp functions, <a href="#7.3.7.1">7.3.7.1</a>, <a href="#G.6.3.1">G.6.3.1</a>
33357 BUFSIZ macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.5">7.21.5.5</a> type-generic macro for, <a href="#7.25">7.25</a>
33358 byte, <a href="#3.6">3.6</a>, <a href="#6.5.3.4">6.5.3.4</a> cexp2 function, <a href="#7.31.1">7.31.1</a>
33359 byte input/output functions, <a href="#7.21.1">7.21.1</a> cexpm1 function, <a href="#7.31.1">7.31.1</a>
33360 byte-oriented stream, <a href="#7.21.2">7.21.2</a> char type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
33362 <a href="#C">C</a> program, <a href="#5.1.1.1">5.1.1.1</a> char type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
33364 c32rtomb function, <a href="#7.28.1.4">7.28.1.4</a> char16_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.10.8.2">6.10.8.2</a>,
33365 cabs functions, <a href="#7.3.8.1">7.3.8.1</a>, <a href="#G.6">G.6</a> <a href="#7.28">7.28</a>
33366 type-generic macro for, <a href="#7.25">7.25</a> char32_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.10.8.2">6.10.8.2</a>,
33367 cacos functions, <a href="#7.3.5.1">7.3.5.1</a>, <a href="#G.6.1.1">G.6.1.1</a> <a href="#7.28">7.28</a>
33368 type-generic macro for, <a href="#7.25">7.25</a> CHAR_BIT macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
33369 cacosh functions, <a href="#7.3.6.1">7.3.6.1</a>, <a href="#G.6.2.1">G.6.2.1</a> CHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
33370 type-generic macro for, <a href="#7.25">7.25</a> CHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
33371 calendar time, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.2">7.27.2.2</a>, <a href="#7.27.2.3">7.27.2.3</a>, <a href="#7.27.2.4">7.27.2.4</a>, character, <a href="#3.7">3.7</a>, <a href="#3.7.1">3.7.1</a>
33372 <a href="#7.27.3.2">7.27.3.2</a>, <a href="#7.27.3.3">7.27.3.3</a>, <a href="#7.27.3.4">7.27.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>, character array initialization, <a href="#6.7.9">6.7.9</a>
33373 <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a> character case mapping functions, <a href="#7.4.2">7.4.2</a>
33374 call by value, <a href="#6.5.2.2">6.5.2.2</a> wide character, <a href="#7.30.3.1">7.30.3.1</a>
33375 call_once function, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.1">7.26.2.1</a> extensible, <a href="#7.30.3.2">7.30.3.2</a>
33376 calloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.2">7.22.3.2</a> character classification functions, <a href="#7.4.1">7.4.1</a>
33377 carg functions, <a href="#7.3.9.1">7.3.9.1</a>, <a href="#G.6">G.6</a> wide character, <a href="#7.30.2.1">7.30.2.1</a>
33378 carg type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> extensible, <a href="#7.30.2.2">7.30.2.2</a>
33379 carriage-return escape sequence (\r), <a href="#5.2.2">5.2.2</a>, character constant, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
33380 <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a> character display semantics, <a href="#5.2.2">5.2.2</a>
33381 carries a dependency, <a href="#5.1.2.4">5.1.2.4</a> character handling header, <a href="#7.4">7.4</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.31.2">7.31.2</a>
33382 case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a> character input/output functions, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a>
33386 extensible, <a href="#7.30.3.2">7.30.3.2</a> character type conversion, <a href="#6.3.1.1">6.3.1.1</a>
33387 casin functions, <a href="#7.3.5.2">7.3.5.2</a>, <a href="#G.6">G.6</a> character types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.9">6.7.9</a>
33388 type-generic macro for, <a href="#7.25">7.25</a> characteristics of floating types header, <a href="#7.7">7.7</a>
33389 casinh functions, <a href="#7.3.6.2">7.3.6.2</a>, <a href="#G.6.2.2">G.6.2.2</a> cimag functions, <a href="#7.3.9.2">7.3.9.2</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>
33390 <!--page 680 -->
33391 cimag type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> complex macro, <a href="#7.3.1">7.3.1</a>
33392 cis function, <a href="#G.6">G.6</a> complex numbers, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>
33393 classification functions complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>
33395 floating-point, <a href="#7.12.3">7.12.3</a> complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G">G</a>
33396 wide character, <a href="#7.30.2.1">7.30.2.1</a> complex.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,
33397 extensible, <a href="#7.30.2.2">7.30.2.2</a> <a href="#7.3">7.3</a>, <a href="#7.25">7.25</a>, <a href="#7.31.1">7.31.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
33399 clgamma function, <a href="#7.31.1">7.31.1</a> components of time, <a href="#7.27.1">7.27.1</a>, <a href="#K.3.8.1">K.3.8.1</a>
33401 clock_t type, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.1">7.27.2.1</a> compound assignment, <a href="#6.5.16.2">6.5.16.2</a>
33402 CLOCKS_PER_SEC macro, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.1">7.27.2.1</a> compound literals, <a href="#6.5.2.5">6.5.2.5</a>
33403 clog functions, <a href="#7.3.7.2">7.3.7.2</a>, <a href="#G.6.3.2">G.6.3.2</a> compound statement, <a href="#6.8.2">6.8.2</a>
33404 type-generic macro for, <a href="#7.25">7.25</a> compound-literal operator (( ){ }), <a href="#6.5.2.5">6.5.2.5</a>
33406 clog1p function, <a href="#7.31.1">7.31.1</a> string, <a href="#7.24.3">7.24.3</a>, <a href="#K.3.7.2">K.3.7.2</a>
33407 clog2 function, <a href="#7.31.1">7.31.1</a> wide string, <a href="#7.29.4.3">7.29.4.3</a>, <a href="#K.3.9.2.2">K.3.9.2.2</a>
33409 cnd_broadcast function, <a href="#7.26.3.1">7.26.3.1</a>, <a href="#7.26.3.5">7.26.3.5</a>, concatenation
33411 cnd_destroy function, <a href="#7.26.3.2">7.26.3.2</a> conditional features, <a href="#4">4</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>,
33412 cnd_init function, <a href="#7.26.3.3">7.26.3.3</a> <a href="#7.1.2">7.1.2</a>, <a href="#F.1">F.1</a>, <a href="#G.1">G.1</a>, <a href="#K.2">K.2</a>, <a href="#L.1">L.1</a>
33413 cnd_signal function, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#7.26.3.5">7.26.3.5</a>, conditional inclusion, <a href="#6.10.1">6.10.1</a>
33414 <a href="#7.26.3.6">7.26.3.6</a> conditional operator (? :), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a>
33417 cnd_wait function, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.6">7.26.3.6</a> conj functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>
33418 collating sequences, <a href="#5.2.1">5.2.1</a> conj type-generic macro, <a href="#7.25">7.25</a>
33419 colon punctuator (:), <a href="#6.7.2.1">6.7.2.1</a> const type qualifier, <a href="#6.7.3">6.7.3</a>
33420 comma operator (,), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a> const-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.7.3">6.7.3</a>
33421 comma punctuator (,), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>, constant expression, <a href="#6.6">6.6</a>, <a href="#F.8.4">F.8.4</a>
33422 <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a> constants, <a href="#6.4.4">6.4.4</a>
33423 command processor, <a href="#7.22.4.8">7.22.4.8</a> as primary expression, <a href="#6.5.1">6.5.1</a>
33424 comment delimiters (/* */ and //), <a href="#6.4.9">6.4.9</a> character, <a href="#6.4.4.4">6.4.4.4</a>
33425 comments, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.4.9">6.4.9</a> enumeration, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
33428 common initial sequence, <a href="#6.5.2.3">6.5.2.3</a> integer, <a href="#6.4.4.1">6.4.4.1</a>
33431 comparison functions, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a>, <a href="#7.22.5.2">7.22.5.2</a>, constraint_handler_t type, <a href="#K.3.6">K.3.6</a>
33432 <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a> consume operation, <a href="#5.1.2.4">5.1.2.4</a>
33433 string, <a href="#7.24.4">7.24.4</a> content of structure/union/enumeration, <a href="#6.7.2.3">6.7.2.3</a>
33434 wide string, <a href="#7.29.4.4">7.29.4.4</a> contiguity of allocated storage, <a href="#7.22.3">7.22.3</a>
33435 comparison macros, <a href="#7.12.14">7.12.14</a> continue statement, <a href="#6.8.6.2">6.8.6.2</a>
33436 comparison, pointer, <a href="#6.5.8">6.5.8</a> contracted expression, <a href="#6.5">6.5</a>, <a href="#7.12.2">7.12.2</a>, <a href="#F.7">F.7</a>
33437 compatible type, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a> control character, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
33439 complement operator (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a> conversion, <a href="#6.3">6.3</a>
33441 complex arithmetic header, <a href="#7.3">7.3</a>, <a href="#7.31.1">7.31.1</a> array argument, <a href="#6.9.1">6.9.1</a>
33442 <!--page 681 -->
33445 boolean, <a href="#6.3.1.2">6.3.1.2</a> cos functions, <a href="#7.12.4.5">7.12.4.5</a>, <a href="#F.10.1.5">F.10.1.5</a>
33446 boolean, characters, and integers, <a href="#6.3.1.1">6.3.1.1</a> cos type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a>
33447 by assignment, <a href="#6.5.16.1">6.5.16.1</a> cosh functions, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#F.10.2.4">F.10.2.4</a>
33448 by return statement, <a href="#6.8.6.4">6.8.6.4</a> cosh type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a>
33449 complex types, <a href="#6.3.1.6">6.3.1.6</a> cpow functions, <a href="#7.3.8.2">7.3.8.2</a>, <a href="#G.6.4.1">G.6.4.1</a>
33451 function, <a href="#6.3.2.1">6.3.2.1</a> cproj functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>
33452 function argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a> cproj type-generic macro, <a href="#7.25">7.25</a>
33453 function designators, <a href="#6.3.2.1">6.3.2.1</a> creal functions, <a href="#7.3.9.6">7.3.9.6</a>, <a href="#G.6">G.6</a>
33454 function parameter, <a href="#6.9.1">6.9.1</a> creal type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a>
33456 imaginary and complex, <a href="#G.4.3">G.4.3</a> csin functions, <a href="#7.3.5.5">7.3.5.5</a>, <a href="#G.6">G.6</a>
33458 lvalues, <a href="#6.3.2.1">6.3.2.1</a> csinh functions, <a href="#7.3.6.5">7.3.6.5</a>, <a href="#G.6.2.5">G.6.2.5</a>
33459 pointer, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a> type-generic macro for, <a href="#7.25">7.25</a>
33460 real and complex, <a href="#6.3.1.7">6.3.1.7</a> csqrt functions, <a href="#7.3.8.3">7.3.8.3</a>, <a href="#G.6.4.2">G.6.4.2</a>
33461 real and imaginary, <a href="#G.4.2">G.4.2</a> type-generic macro for, <a href="#7.25">7.25</a>
33462 real floating and integer, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a> ctan functions, <a href="#7.3.5.6">7.3.5.6</a>, <a href="#G.6">G.6</a>
33463 real floating types, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#F.3">F.3</a> type-generic macro for, <a href="#7.25">7.25</a>
33464 signed and unsigned integers, <a href="#6.3.1.3">6.3.1.3</a> ctanh functions, <a href="#7.3.6.6">7.3.6.6</a>, <a href="#G.6.2.6">G.6.2.6</a>
33468 conversion functions ctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>
33469 multibyte/wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a> ctype.h header, <a href="#7.4">7.4</a>, <a href="#7.31.2">7.31.2</a>
33470 extended, <a href="#7.29.6">7.29.6</a>, <a href="#K.3.9.3">K.3.9.3</a> current object, <a href="#6.7.9">6.7.9</a>
33471 restartable, <a href="#7.28.1">7.28.1</a>, <a href="#7.29.6.3">7.29.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a> CX_LIMITED_RANGE pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.3.4">7.3.4</a>
33473 restartable, <a href="#7.29.6.4">7.29.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a> data race, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.2.2">7.22.2.2</a>, <a href="#7.22.3">7.22.3</a>,
33474 numeric, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a> <a href="#7.22.4.6">7.22.4.6</a>, <a href="#7.24.5.8">7.24.5.8</a>, <a href="#7.24.6.2">7.24.6.2</a>, <a href="#7.27.3">7.27.3</a>, <a href="#7.28.1">7.28.1</a>,
33475 wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.29.4.1">7.29.4.1</a> <a href="#7.29.6.3">7.29.6.3</a>, <a href="#7.29.6.4">7.29.6.4</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>
33477 time, <a href="#7.27.3">7.27.3</a>, <a href="#K.3.8.2">K.3.8.2</a> date and time header, <a href="#7.26.1">7.26.1</a>, <a href="#7.27">7.27</a>, <a href="#7.31.14">7.31.14</a>, <a href="#K.3.8">K.3.8</a>
33478 wide character, <a href="#7.29.5">7.29.5</a> Daylight Saving Time, <a href="#7.27.1">7.27.1</a>
33479 conversion specifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, DBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33481 conversion state, <a href="#7.22.7">7.22.7</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.1.1">7.28.1.1</a>, DBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33482 <a href="#7.28.1.2">7.28.1.2</a>, <a href="#7.28.1.3">7.28.1.3</a>, <a href="#7.28.1.4">7.28.1.4</a>, <a href="#7.29.6">7.29.6</a>, DBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33483 <a href="#7.29.6.2.1">7.29.6.2.1</a>, <a href="#7.29.6.3">7.29.6.3</a>, <a href="#7.29.6.3.2">7.29.6.3.2</a>, <a href="#7.29.6.3.3">7.29.6.3.3</a>, DBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33484 <a href="#7.29.6.4">7.29.6.4</a>, <a href="#7.29.6.4.1">7.29.6.4.1</a>, <a href="#7.29.6.4.2">7.29.6.4.2</a>, <a href="#K.3.6.4">K.3.6.4</a>, DBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33485 <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>, DBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33487 conversion state functions, <a href="#7.29.6.2">7.29.6.2</a> DBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33489 string, <a href="#7.24.2">7.24.2</a>, <a href="#K.3.7.1">K.3.7.1</a> DBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33490 wide string, <a href="#7.29.4.2">7.29.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a> DBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33491 copysign functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12.11.1">7.12.11.1</a>, <a href="#F.3">F.3</a>, decimal constant, <a href="#6.4.4.1">6.4.4.1</a>
33493 copysign type-generic macro, <a href="#7.25">7.25</a> decimal-point character, <a href="#7.1.1">7.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
33494 <!--page 682 -->
33495 DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#F.2">F.2</a>
33496 <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.4.1.1">7.29.4.1.1</a>, <a href="#F.5">F.5</a> double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
33498 declarations, <a href="#6.7">6.7</a> double-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>
33499 function, <a href="#6.7.6.3">6.7.6.3</a> double-quote escape sequence (\"), <a href="#6.4.4.4">6.4.4.4</a>,
33500 pointer, <a href="#6.7.6.1">6.7.6.1</a> <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>
33503 declarator, <a href="#6.7.6">6.7.6</a> EDOM macro, <a href="#7.5">7.5</a>, <a href="#7.12.1">7.12.1</a>, see also domain error
33505 declarator type derivation, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6">6.7.6</a> EILSEQ macro, <a href="#7.5">7.5</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.28.1.1">7.28.1.1</a>, <a href="#7.28.1.2">7.28.1.2</a>,
33506 decrement operators, see arithmetic operators, <a href="#7.28.1.3">7.28.1.3</a>, <a href="#7.28.1.4">7.28.1.4</a>, <a href="#7.29.3.1">7.29.3.1</a>, <a href="#7.29.3.3">7.29.3.3</a>,
33507 increment and decrement <a href="#7.29.6.3.2">7.29.6.3.2</a>, <a href="#7.29.6.3.3">7.29.6.3.3</a>, <a href="#7.29.6.4.1">7.29.6.4.1</a>, <a href="#7.29.6.4.2">7.29.6.4.2</a>,
33510 default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a> elif preprocessing directive, <a href="#6.10.1">6.10.1</a>
33511 define preprocessing directive, <a href="#6.10.3">6.10.3</a> ellipsis punctuator (...), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
33512 defined operator, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.8">6.10.8</a> else preprocessing directive, <a href="#6.10.1">6.10.1</a>
33515 dependency-ordered before, <a href="#5.1.2.4">5.1.2.4</a> encoding error, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
33516 derived declarator types, <a href="#6.2.5">6.2.5</a> <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.6">7.21.6.6</a>, <a href="#7.21.6.8">7.21.6.8</a>,
33517 derived types, <a href="#6.2.5">6.2.5</a> <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.28.1.1">7.28.1.1</a>,
33518 designated initializer, <a href="#6.7.9">6.7.9</a> <a href="#7.28.1.2">7.28.1.2</a>, <a href="#7.28.1.3">7.28.1.3</a>, <a href="#7.28.1.4">7.28.1.4</a>, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.1">7.29.2.1</a>,
33519 destringizing, <a href="#6.10.9">6.10.9</a> <a href="#7.29.2.2">7.29.2.2</a>, <a href="#7.29.2.3">7.29.2.3</a>, <a href="#7.29.2.5">7.29.2.5</a>, <a href="#7.29.2.7">7.29.2.7</a>,
33520 device input/output, <a href="#5.1.2.3">5.1.2.3</a> <a href="#7.29.2.9">7.29.2.9</a>, <a href="#7.29.2.11">7.29.2.11</a>, <a href="#7.29.3.1">7.29.3.1</a>, <a href="#7.29.3.2">7.29.3.2</a>,
33521 diagnostic message, <a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a> <a href="#7.29.3.3">7.29.3.3</a>, <a href="#7.29.3.4">7.29.3.4</a>, <a href="#7.29.6.3.2">7.29.6.3.2</a>, <a href="#7.29.6.3.3">7.29.6.3.3</a>,
33522 diagnostics, <a href="#5.1.1.3">5.1.1.3</a> <a href="#7.29.6.4.1">7.29.6.4.1</a>, <a href="#7.29.6.4.2">7.29.6.4.2</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>,
33523 diagnostics header, <a href="#7.2">7.2</a> <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
33525 digit, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a> end-of-file indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,
33526 digraphs, <a href="#6.4.6">6.4.6</a> <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
33527 direct input/output functions, <a href="#7.21.8">7.21.8</a> <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.2">7.21.10.2</a>, <a href="#7.29.3.1">7.29.3.1</a>,
33531 division assignment operator (/=), <a href="#6.5.16.2">6.5.16.2</a> endif preprocessing directive, <a href="#6.10.1">6.10.1</a>
33532 division operator (/), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a> enum type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.2">6.7.2.2</a>
33534 documentation of implementation, <a href="#4">4</a> enumeration, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.2">6.7.2.2</a>
33535 domain error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#7.12.4.4">7.12.4.4</a>, enumeration constant, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
33536 <a href="#7.12.5.1">7.12.5.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.7">7.12.6.7</a>, enumeration content, <a href="#6.7.2.3">6.7.2.3</a>
33537 <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, enumeration members, <a href="#6.7.2.2">6.7.2.2</a>
33538 <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>, enumeration specifiers, <a href="#6.7.2.2">6.7.2.2</a>
33539 <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a> enumeration tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
33542 double _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, environment functions, <a href="#7.22.4">7.22.4</a>, <a href="#K.3.6.2">K.3.6.2</a>
33543 <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a> environment list, <a href="#7.22.4.6">7.22.4.6</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>
33544 double _Imaginary type, <a href="#G.2">G.2</a> environmental considerations, <a href="#5.2">5.2</a>
33545 double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.2">7.21.6.2</a>, environmental limits, <a href="#5.2.4">5.2.4</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.21.2">7.21.2</a>,
33546 <!--page 683 -->
33547 <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.4.2">7.22.4.2</a>, evaluation format, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#7.12">7.12</a>
33548 <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a> evaluation method, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#F.8.5">F.8.5</a>
33549 EOF macro, <a href="#7.4">7.4</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.2">7.21.5.2</a>, evaluation of expression, <a href="#5.1.2.3">5.1.2.3</a>
33550 <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.11">7.21.6.11</a>, evaluation order, see order of evaluation
33551 <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.4">7.21.7.4</a>, exceptional condition, <a href="#6.5">6.5</a>
33552 <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>, excess precision, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>
33553 <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#7.29.2.4">7.29.2.4</a>, excess range, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>
33554 <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.2.8">7.29.2.8</a>, <a href="#7.29.2.10">7.29.2.10</a>, <a href="#7.29.2.12">7.29.2.12</a>, exclusive OR operators
33555 <a href="#7.29.3.4">7.29.3.4</a>, <a href="#7.29.6.1.1">7.29.6.1.1</a>, <a href="#7.29.6.1.2">7.29.6.1.2</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>, bitwise (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
33556 <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>, bitwise assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
33557 <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>, executable program, <a href="#5.1.1.1">5.1.1.1</a>
33559 epoch, <a href="#7.27.2.5">7.27.2.5</a> execution environment, <a href="#5">5</a>, <a href="#5.1.2">5.1.2</a>, see also
33560 equal-sign punctuator (=), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a> environmental limits
33561 equal-to operator, see equality operator execution sequence, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.8">6.8</a>
33562 equality expressions, <a href="#6.5.9">6.5.9</a> exit function, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>,
33563 equality operator (==), <a href="#6.5.9">6.5.9</a> <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>, <a href="#7.26.5.5">7.26.5.5</a>
33564 ERANGE macro, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.12.1">7.12.1</a>, EXIT_FAILURE macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>
33565 <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.29.4.1.1">7.29.4.1.1</a>, <a href="#7.29.4.1.2">7.29.4.1.2</a>, see EXIT_SUCCESS macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.26.5.5">7.26.5.5</a>
33566 also range error, pole error exp functions, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#F.10.3.1">F.10.3.1</a>
33567 erf functions, <a href="#7.12.8.1">7.12.8.1</a>, <a href="#F.10.5.1">F.10.5.1</a> exp type-generic macro, <a href="#7.25">7.25</a>
33568 erf type-generic macro, <a href="#7.25">7.25</a> exp2 functions, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#F.10.3.2">F.10.3.2</a>
33569 erfc functions, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#F.10.5.2">F.10.5.2</a> exp2 type-generic macro, <a href="#7.25">7.25</a>
33571 errno macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.3.2">7.3.2</a>, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, expm1 functions, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#F.10.3.3">F.10.3.3</a>
33572 <a href="#7.12.1">7.12.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.4">7.21.10.4</a>, expm1 type-generic macro, <a href="#7.25">7.25</a>
33573 <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.24.6.2">7.24.6.2</a>, <a href="#7.28.1.1">7.28.1.1</a>, exponent part, <a href="#6.4.4.2">6.4.4.2</a>
33574 <a href="#7.28.1.2">7.28.1.2</a>, <a href="#7.28.1.3">7.28.1.3</a>, <a href="#7.28.1.4">7.28.1.4</a>, <a href="#7.29.3.1">7.29.3.1</a>, exponential functions
33575 <a href="#7.29.3.3">7.29.3.3</a>, <a href="#7.29.4.1.1">7.29.4.1.1</a>, <a href="#7.29.4.1.2">7.29.4.1.2</a>, <a href="#7.29.6.3.2">7.29.6.3.2</a>, complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
33576 <a href="#7.29.6.3.3">7.29.6.3.3</a>, <a href="#7.29.6.4.1">7.29.6.4.1</a>, <a href="#7.29.6.4.2">7.29.6.4.2</a>, <a href="#J.5.17">J.5.17</a>, real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>
33577 <a href="#K.3.1.3">K.3.1.3</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a> expression, <a href="#6.5">6.5</a>
33578 errno.h header, <a href="#7.5">7.5</a>, <a href="#7.31.3">7.31.3</a>, <a href="#K.3.2">K.3.2</a> assignment, <a href="#6.5.16">6.5.16</a>
33579 errno_t type, <a href="#K.3.2">K.3.2</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>, cast, <a href="#6.5.4">6.5.4</a>
33580 <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a> constant, <a href="#6.6">6.6</a>
33583 encoding, see encoding error order of evaluation, see order of evaluation
33587 error functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a> expression statement, <a href="#6.8.3">6.8.3</a>
33588 error indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>, extended alignment, <a href="#6.2.8">6.2.8</a>
33589 <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.7">7.21.7.7</a>, extended character set, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.1.2">5.2.1.2</a>
33590 <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.3">7.21.10.3</a>, extended characters, <a href="#5.2.1">5.2.1</a>
33591 <a href="#7.29.3.1">7.29.3.1</a>, <a href="#7.29.3.3">7.29.3.3</a> extended integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>,
33592 error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a> <a href="#7.20">7.20</a>
33593 error-handling functions, <a href="#7.21.10">7.21.10</a>, <a href="#7.24.6.2">7.24.6.2</a>, extended multibyte and wide character utilities
33594 <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a> header, <a href="#7.29">7.29</a>, <a href="#7.31.16">7.31.16</a>
33595 errors header, <a href="#7.5">7.5</a>, <a href="#7.31.3">7.31.3</a> extended multibyte/wide character conversion
33596 escape character (\), <a href="#6.4.4.4">6.4.4.4</a> utilities, <a href="#7.29.6">7.29.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
33597 escape sequences, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.11.4">6.11.4</a> extensible wide character case mapping functions,
33598 <!--page 684 -->
33599 <a href="#7.30.3.2">7.30.3.2</a> <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.8.1">7.21.8.1</a>
33600 extensible wide character classification functions, fgetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>
33601 <a href="#7.30.2.2">7.30.2.2</a> fgets function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.2">7.21.7.2</a>, <a href="#K.3.5.4.1">K.3.5.4.1</a>
33602 extern storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.7.1">6.7.1</a> fgetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.29.3.1">7.29.3.1</a>,
33604 external identifiers, underscore, <a href="#7.1.3">7.1.3</a> fgetws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3.2">7.29.3.2</a>
33605 external linkage, <a href="#6.2.2">6.2.2</a> field width, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>
33607 external object definitions, <a href="#6.9.2">6.9.2</a> access functions, <a href="#7.21.5">7.21.5</a>, <a href="#K.3.5.2">K.3.5.2</a>
33609 fabs functions, <a href="#7.12.7.2">7.12.7.2</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.2">F.10.4.2</a> operations, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>
33610 fabs type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> position indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>,
33611 false macro, <a href="#7.18">7.18</a> <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
33612 fclose function, <a href="#7.21.5.1">7.21.5.1</a> <a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.2">7.21.9.2</a>,
33613 fdim functions, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#F.10.9.1">F.10.9.1</a> <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.29.3.1">7.29.3.1</a>,
33614 fdim type-generic macro, <a href="#7.25">7.25</a> <a href="#7.29.3.3">7.29.3.3</a>, <a href="#7.29.3.10">7.29.3.10</a>
33615 FE_ALL_EXCEPT macro, <a href="#7.6">7.6</a> positioning functions, <a href="#7.21.9">7.21.9</a>
33616 FE_DFL_ENV macro, <a href="#7.6">7.6</a> file scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.9">6.9</a>
33617 FE_DIVBYZERO macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a> FILE type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>
33618 FE_DOWNWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> FILENAME_MAX macro, <a href="#7.21.1">7.21.1</a>
33619 FE_INEXACT macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> flags, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>, see also floating-point
33620 FE_INVALID macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a> status flag
33621 FE_OVERFLOW macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a> flexible array member, <a href="#6.7.2.1">6.7.2.1</a>
33622 FE_TONEAREST macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> float _Complex type, <a href="#6.2.5">6.2.5</a>
33623 FE_TOWARDZERO macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> float _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,
33624 FE_UNDERFLOW macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
33625 FE_UPWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> float _Imaginary type, <a href="#G.2">G.2</a>
33626 feclearexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.1">7.6.2.1</a>, <a href="#F.3">F.3</a> float type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.2">F.2</a>
33627 fegetenv function, <a href="#7.6.4.1">7.6.4.1</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a> float type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
33628 fegetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.2">7.6.2.2</a>, <a href="#F.3">F.3</a> <a href="#6.3.1.8">6.3.1.8</a>
33629 fegetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.1">7.6.3.1</a>, <a href="#F.3">F.3</a> float.h header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
33630 feholdexcept function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.29.4.1.1">7.29.4.1.1</a>
33633 fences, <a href="#7.17.4">7.17.4</a> floating suffix, f or <a href="#F">F</a>, <a href="#6.4.4.2">6.4.4.2</a>
33634 fenv.h header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
33635 <a href="#7.31.4">7.31.4</a>, <a href="#F">F</a>, <a href="#H">H</a> <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
33636 FENV_ACCESS pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#F.8">F.8</a>, <a href="#F.9">F.9</a>, floating types, <a href="#6.2.5">6.2.5</a>, <a href="#6.11.1">6.11.1</a>
33637 <a href="#F.10">F.10</a> floating-point accuracy, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.5">6.5</a>,
33638 fenv_t type, <a href="#7.6">7.6</a> <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.5">F.5</a>, see also contracted expression
33639 feof function, <a href="#7.21.10.2">7.21.10.2</a> floating-point arithmetic functions, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>
33640 feraiseexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.3">7.6.2.3</a>, <a href="#F.3">F.3</a> floating-point classification functions, <a href="#7.12.3">7.12.3</a>
33641 ferror function, <a href="#7.21.10.3">7.21.10.3</a> floating-point control mode, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
33642 fesetenv function, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#F.3">F.3</a> floating-point environment, <a href="#7.6">7.6</a>, <a href="#F.8">F.8</a>, <a href="#F.8.6">F.8.6</a>
33643 fesetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.4">7.6.2.4</a>, <a href="#F.3">F.3</a> floating-point environment header, <a href="#7.6">7.6</a>, <a href="#7.31.4">7.31.4</a>
33644 fesetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.2">7.6.3.2</a>, <a href="#F.3">F.3</a> floating-point exception, <a href="#7.6">7.6</a>, <a href="#7.6.2">7.6.2</a>, <a href="#F.10">F.10</a>
33645 fetestexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.5">7.6.2.5</a>, <a href="#F.3">F.3</a> floating-point number, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.2.5">6.2.5</a>
33646 feupdateenv function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a> floating-point rounding mode, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33647 fexcept_t type, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> floating-point status flag, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
33648 fflush function, <a href="#7.21.5.2">7.21.5.2</a>, <a href="#7.21.5.3">7.21.5.3</a> floor functions, <a href="#7.12.9.2">7.12.9.2</a>, <a href="#F.10.6.2">F.10.6.2</a>
33649 fgetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.1">7.21.7.1</a>, floor type-generic macro, <a href="#7.25">7.25</a>
33650 <!--page 685 -->
33651 FLT_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> FP_NAN macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
33652 FLT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> FP_NORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
33653 FLT_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> FP_SUBNORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
33654 FLT_EVAL_METHOD macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.6">6.6</a>, <a href="#7.12">7.12</a>, FP_ZERO macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
33655 <a href="#F.10.11">F.10.11</a> fpclassify macro, <a href="#7.12.3.1">7.12.3.1</a>, <a href="#F.3">F.3</a>
33656 FLT_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> fpos_t type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>
33657 FLT_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> fprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.1">7.21.6.1</a>,
33658 FLT_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.6">7.21.6.6</a>,
33659 FLT_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.1">K.3.5.3.1</a>
33660 FLT_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> fprintf_s function, <a href="#K.3.5.3.1">K.3.5.3.1</a>
33661 FLT_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> fputc function, <a href="#5.2.2">5.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.3">7.21.7.3</a>,
33662 FLT_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.8.2">7.21.8.2</a>
33663 FLT_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> fputs function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.4">7.21.7.4</a>
33664 FLT_RADIX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.1.3">7.22.1.3</a>, fputwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.29.3.3">7.29.3.3</a>,
33665 <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.4.1.1">7.29.4.1.1</a> <a href="#7.29.3.8">7.29.3.8</a>
33666 FLT_ROUNDS macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a> fputws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3.4">7.29.3.4</a>
33667 FLT_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> fread function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.1">7.21.8.1</a>
33668 fma functions, <a href="#7.12">7.12</a>, <a href="#7.12.13.1">7.12.13.1</a>, <a href="#F.10.10.1">F.10.10.1</a> free function, <a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>
33669 fma type-generic macro, <a href="#7.25">7.25</a> freestanding execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>,
33670 fmax functions, <a href="#7.12.12.2">7.12.12.2</a>, <a href="#F.10.9.2">F.10.9.2</a> <a href="#5.1.2.1">5.1.2.1</a>
33671 fmax type-generic macro, <a href="#7.25">7.25</a> freopen function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.4">7.21.5.4</a>
33672 fmin functions, <a href="#7.12.12.3">7.12.12.3</a>, <a href="#F.10.9.3">F.10.9.3</a> freopen_s function, <a href="#K.3.5.2.2">K.3.5.2.2</a>
33673 fmin type-generic macro, <a href="#7.25">7.25</a> frexp functions, <a href="#7.12.6.4">7.12.6.4</a>, <a href="#F.10.3.4">F.10.3.4</a>
33674 fmod functions, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#F.10.7.1">F.10.7.1</a> frexp type-generic macro, <a href="#7.25">7.25</a>
33675 fmod type-generic macro, <a href="#7.25">7.25</a> fscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
33676 fopen function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.5.4">7.21.5.4</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a> <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>
33677 FOPEN_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.3">7.21.4.3</a>, fscanf_s function, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
33678 <a href="#K.3.5.1.1">K.3.5.1.1</a> <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>
33679 fopen_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a>, fseek function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
33680 <a href="#K.3.5.2.2">K.3.5.2.2</a> <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.29.3.10">7.29.3.10</a>
33681 for statement, <a href="#6.8.5">6.8.5</a>, <a href="#6.8.5.3">6.8.5.3</a> fsetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
33682 form-feed character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a> <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.29.3.10">7.29.3.10</a>
33683 form-feed escape sequence (\f), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, ftell function, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>
33685 formal argument (deprecated), <a href="#3.16">3.16</a> full expression, <a href="#6.8">6.8</a>
33686 formal parameter, <a href="#3.16">3.16</a> fully buffered stream, <a href="#7.21.3">7.21.3</a>
33688 <a href="#7.31.5">7.31.5</a> argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
33689 formatted input/output functions, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.6">7.21.6</a>, body, <a href="#6.9.1">6.9.1</a>
33691 wide character, <a href="#7.29.2">7.29.2</a>, <a href="#K.3.9.1">K.3.9.1</a> library, <a href="#7.1.4">7.1.4</a>
33692 fortran keyword, <a href="#J.5.9">J.5.9</a> declarator, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.11.6">6.11.6</a>
33693 forward reference, <a href="#3.11">3.11</a> definition, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.7">6.11.7</a>
33694 FP_CONTRACT pragma, <a href="#6.5">6.5</a>, <a href="#6.10.6">6.10.6</a>, <a href="#7.12.2">7.12.2</a>, see designator, <a href="#6.3.2.1">6.3.2.1</a>
33697 FP_FAST_FMAF macro, <a href="#7.12">7.12</a> library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.4">7.1.4</a>
33698 FP_FAST_FMAL macro, <a href="#7.12">7.12</a> name length, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
33699 FP_ILOGB0 macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a> no-return, <a href="#6.7.4">6.7.4</a>
33700 FP_ILOGBNAN macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a> parameter, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
33701 FP_INFINITE macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a> prototype, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.7">6.2.7</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>,
33702 <!--page 686 -->
33703 <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.6">6.11.6</a>, <a href="#6.11.7">6.11.7</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.12">7.12</a> header, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.2">7.1.2</a>, see also standard headers
33704 prototype scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.7.6.2">6.7.6.2</a> header names, <a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>, <a href="#6.10.2">6.10.2</a>
33705 recursive call, <a href="#6.5.2.2">6.5.2.2</a> hexadecimal constant, <a href="#6.4.4.1">6.4.4.1</a>
33706 return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a> hexadecimal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
33709 type conversion, <a href="#6.3.2.1">6.3.2.1</a> (\x hexadecimal digits), <a href="#6.4.4.4">6.4.4.4</a>
33711 function type, <a href="#6.2.5">6.2.5</a> horizontal-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
33712 function-call operator (( )), <a href="#6.5.2.2">6.5.2.2</a> horizontal-tab escape sequence (\r), <a href="#7.30.2.1.3">7.30.2.1.3</a>
33713 function-like macro, <a href="#6.10.3">6.10.3</a> horizontal-tab escape sequence (\t), <a href="#5.2.2">5.2.2</a>,
33714 fundamental alignment, <a href="#6.2.8">6.2.8</a> <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>
33715 future directions hosted execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.2">5.1.2.2</a>
33716 language, <a href="#6.11">6.11</a> HUGE_VAL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,
33717 library, <a href="#7.31">7.31</a> <a href="#7.29.4.1.1">7.29.4.1.1</a>, <a href="#F.10">F.10</a>
33718 fwide function, <a href="#7.21.2">7.21.2</a>, <a href="#7.29.3.5">7.29.3.5</a> HUGE_VALF macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,
33719 fwprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.4.1.1">7.29.4.1.1</a>, <a href="#F.10">F.10</a>
33720 <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#7.29.2.3">7.29.2.3</a>, <a href="#7.29.2.5">7.29.2.5</a>, HUGE_VALL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,
33721 <a href="#7.29.2.11">7.29.2.11</a>, <a href="#K.3.9.1.1">K.3.9.1.1</a> <a href="#7.29.4.1.1">7.29.4.1.1</a>, <a href="#F.10">F.10</a>
33723 fwrite function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.2">7.21.8.2</a> complex, <a href="#7.3.6">7.3.6</a>, <a href="#G.6.2">G.6.2</a>
33724 fwscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, real, <a href="#7.12.5">7.12.5</a>, <a href="#F.10.2">F.10.2</a>
33725 <a href="#7.29.2.4">7.29.2.4</a>, <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.2.12">7.29.2.12</a>, <a href="#7.29.3.10">7.29.3.10</a>, hypot functions, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#F.10.4.3">F.10.4.3</a>
33728 <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a> <a href="#I">I</a> macro, <a href="#7.3.1">7.3.1</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>
33730 gamma functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a> linkage, see linkage
33732 wide string, <a href="#7.29.4">7.29.4</a>, <a href="#K.3.9.2">K.3.9.2</a> name spaces, <a href="#6.2.3">6.2.3</a>
33733 general utilities header, <a href="#7.22">7.22</a>, <a href="#7.31.12">7.31.12</a> reserved, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>
33734 general wide string utilities, <a href="#7.29.4">7.29.4</a>, <a href="#K.3.9.2">K.3.9.2</a> scope, <a href="#6.2.1">6.2.1</a>
33737 generic selection, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.1.1">6.5.1.1</a> identifier nondigit, <a href="#6.4.2.1">6.4.2.1</a>
33738 getc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a> IEC 559, <a href="#F.1">F.1</a>
33739 getchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.6">7.21.7.6</a> IEC 60559, <a href="#2">2</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.3.3">7.3.3</a>,
33740 getenv function, <a href="#7.22.4.6">7.22.4.6</a> <a href="#7.6">7.6</a>, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.14">7.12.14</a>, <a href="#F">F</a>, <a href="#G">G</a>,
33744 getwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3.6">7.29.3.6</a>, <a href="#7.29.3.7">7.29.3.7</a> IEEE floating-point arithmetic standard, see
33745 getwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3.7">7.29.3.7</a> IEC 60559, ANSI/IEEE 754,
33747 gmtime_s function, <a href="#K.3.8.2.3">K.3.8.2.3</a> if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,
33748 goto statement, <a href="#6.2.1">6.2.1</a>, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.6.1">6.8.6.1</a> <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>
33750 greater-than operator (>), <a href="#6.5.8">6.5.8</a> ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>
33751 greater-than-or-equal-to operator (>=), <a href="#6.5.8">6.5.8</a> ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>
33753 happens before, <a href="#5.1.2.4">5.1.2.4</a> ilogb functions, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>
33754 <!--page 687 -->
33755 ilogb type-generic macro, <a href="#7.25">7.25</a> formatted, <a href="#7.29.2">7.29.2</a>, <a href="#K.3.9.1">K.3.9.1</a>
33756 imaginary macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a> input/output header, <a href="#7.21">7.21</a>, <a href="#7.31.11">7.31.11</a>, <a href="#K.3.5">K.3.5</a>
33758 imaginary type domain, <a href="#G.2">G.2</a> int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.7.2">6.7.2</a>
33759 imaginary types, <a href="#G">G</a> int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
33761 imaxdiv function, <a href="#7.8">7.8</a>, <a href="#7.8.2.2">7.8.2.2</a> INT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>
33764 implementation limit, <a href="#3.13">3.13</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.4.2.1">6.4.2.1</a>, INT_LEASTN_MAX macros, <a href="#7.20.2.2">7.20.2.2</a>
33765 <a href="#6.7.6">6.7.6</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#E">E</a>, see also environmental INT_LEASTN_MIN macros, <a href="#7.20.2.2">7.20.2.2</a>
33767 implementation-defined behavior, <a href="#3.4.1">3.4.1</a>, <a href="#4">4</a>, <a href="#J.3">J.3</a> INT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
33768 implementation-defined value, <a href="#3.19.1">3.19.1</a> INT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>
33769 implicit conversion, <a href="#6.3">6.3</a> integer arithmetic functions, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>,
33771 include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.2">6.10.2</a> integer character constant, <a href="#6.4.4.4">6.4.4.4</a>
33773 bitwise (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a> integer constant expression, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.6">6.6</a>, <a href="#6.7.2.1">6.7.2.1</a>,
33774 bitwise assignment (|=), <a href="#6.5.16.2">6.5.16.2</a> <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.7.10">6.7.10</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#6.10.1">6.10.1</a>,
33776 increment operators, see arithmetic operators, integer conversion rank, <a href="#6.3.1.1">6.3.1.1</a>
33777 increment and decrement integer promotions, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.3.1.1">6.3.1.1</a>,
33778 indeterminate value, <a href="#3.19.2">3.19.2</a> <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.7">6.5.7</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>,
33779 indeterminately sequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>
33780 <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, see also sequenced before, integer suffix, <a href="#6.4.4.1">6.4.4.1</a>
33781 unsequenced integer type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
33782 indirection operator (*), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a> <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
33783 inequality operator (!=), <a href="#6.5.9">6.5.9</a> integer types, <a href="#6.2.5">6.2.5</a>, <a href="#7.20">7.20</a>
33784 infinitary, <a href="#7.12.1">7.12.1</a> extended, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#7.20">7.20</a>
33785 INFINITY macro, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a> integer types header, <a href="#7.20">7.20</a>, <a href="#7.31.10">7.31.10</a>
33786 initial position, <a href="#5.2.2">5.2.2</a> inter-thread happens before, <a href="#5.1.2.4">5.1.2.4</a>
33787 initial shift state, <a href="#5.2.1.2">5.2.1.2</a> interactive device, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a>
33788 initialization, <a href="#5.1.2">5.1.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.5">6.5.2.5</a>, <a href="#6.7.9">6.7.9</a>, internal linkage, <a href="#6.2.2">6.2.2</a>
33792 permitted form, <a href="#6.6">6.6</a> INTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
33793 string literal, <a href="#6.3.2.1">6.3.2.1</a> INTMAX_MIN macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
33794 inline, <a href="#6.7.4">6.7.4</a> intmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
33795 inner scope, <a href="#6.2.1">6.2.1</a> <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>
33796 input failure, <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.2.8">7.29.2.8</a>, <a href="#7.29.2.10">7.29.2.10</a>, INTN_C macros, <a href="#7.20.4.1">7.20.4.1</a>
33797 <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, INTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>
33798 <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>, <a href="#K.3.9.1.5">K.3.9.1.5</a>, INTN_MIN macros, <a href="#7.20.2.1">7.20.2.1</a>
33799 <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a> intN_t types, <a href="#7.20.1.1">7.20.1.1</a>
33801 character, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a> INTPTR_MIN macro, <a href="#7.20.2.4">7.20.2.4</a>
33803 formatted, <a href="#7.21.6">7.21.6</a>, <a href="#K.3.5.3">K.3.5.3</a> inttypes.h header, <a href="#7.8">7.8</a>, <a href="#7.31.5">7.31.5</a>
33804 wide character, <a href="#7.29.2">7.29.2</a>, <a href="#K.3.9.1">K.3.9.1</a> isalnum function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>
33805 wide character, <a href="#7.29.3">7.29.3</a> isalpha function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>
33806 <!--page 688 -->
33807 isblank function, <a href="#7.4.1.3">7.4.1.3</a> iswpunct function, <a href="#7.30.2.1">7.30.2.1</a>, <a href="#7.30.2.1.2">7.30.2.1.2</a>,
33808 iscntrl function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.4">7.4.1.4</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.30.2.1.7">7.30.2.1.7</a>, <a href="#7.30.2.1.9">7.30.2.1.9</a>, <a href="#7.30.2.1.10">7.30.2.1.10</a>,
33809 <a href="#7.4.1.11">7.4.1.11</a> <a href="#7.30.2.1.11">7.30.2.1.11</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a>
33810 isdigit function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.5">7.4.1.5</a>, iswspace function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a>,
33811 <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.11.1.1">7.11.1.1</a> <a href="#7.29.4.1.1">7.29.4.1.1</a>, <a href="#7.29.4.1.2">7.29.4.1.2</a>, <a href="#7.30.2.1.2">7.30.2.1.2</a>, <a href="#7.30.2.1.6">7.30.2.1.6</a>,
33812 isfinite macro, <a href="#7.12.3.2">7.12.3.2</a>, <a href="#F.3">F.3</a> <a href="#7.30.2.1.7">7.30.2.1.7</a>, <a href="#7.30.2.1.9">7.30.2.1.9</a>, <a href="#7.30.2.1.10">7.30.2.1.10</a>,
33813 isgraph function, <a href="#7.4.1.6">7.4.1.6</a> <a href="#7.30.2.1.11">7.30.2.1.11</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a>
33814 isgreater macro, <a href="#7.12.14.1">7.12.14.1</a>, <a href="#F.3">F.3</a> iswupper function, <a href="#7.30.2.1.2">7.30.2.1.2</a>, <a href="#7.30.2.1.11">7.30.2.1.11</a>,
33815 isgreaterequal macro, <a href="#7.12.14.2">7.12.14.2</a>, <a href="#F.3">F.3</a> <a href="#7.30.2.2.1">7.30.2.2.1</a>, <a href="#7.30.3.1.1">7.30.3.1.1</a>, <a href="#7.30.3.1.2">7.30.3.1.2</a>
33816 isinf macro, <a href="#7.12.3.3">7.12.3.3</a> iswxdigit function, <a href="#7.30.2.1.12">7.30.2.1.12</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a>
33817 isless macro, <a href="#7.12.14.3">7.12.14.3</a>, <a href="#F.3">F.3</a> isxdigit function, <a href="#7.4.1.12">7.4.1.12</a>, <a href="#7.11.1.1">7.11.1.1</a>
33818 islessequal macro, <a href="#7.12.14.4">7.12.14.4</a>, <a href="#F.3">F.3</a> italic type convention, <a href="#3">3</a>, <a href="#6.1">6.1</a>
33819 islessgreater macro, <a href="#7.12.14.5">7.12.14.5</a>, <a href="#F.3">F.3</a> iteration statements, <a href="#6.8.5">6.8.5</a>
33820 islower function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.2.1">7.4.2.1</a>,
33822 isnan macro, <a href="#7.12.3.4">7.12.3.4</a>, <a href="#F.3">F.3</a> jump statements, <a href="#6.8.6">6.8.6</a>
33824 ISO 31-11, <a href="#2">2</a>, <a href="#3">3</a> keywords, <a href="#6.4.1">6.4.1</a>, <a href="#G.2">G.2</a>, <a href="#J.5.9">J.5.9</a>, <a href="#J.5.10">J.5.10</a>
33825 ISO 4217, <a href="#2">2</a>, <a href="#7.11.2.1">7.11.2.1</a> kill_dependency macro, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.17.3.1">7.17.3.1</a>
33826 ISO 8601, <a href="#2">2</a>, <a href="#7.27.3.5">7.27.3.5</a> known constant size, <a href="#6.2.5">6.2.5</a>
33827 ISO/IEC 10646, <a href="#2">2</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.4.3">6.4.3</a>, <a href="#6.10.8.2">6.10.8.2</a>
33828 ISO/IEC 10976-1, <a href="#H.1">H.1</a> L_tmpnam macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.4">7.21.4.4</a>
33829 ISO/IEC 2382-1, <a href="#2">2</a>, <a href="#3">3</a> L_tmpnam_s macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
33830 ISO/IEC 646, <a href="#2">2</a>, <a href="#5.2.1.1">5.2.1.1</a> label name, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.3">6.2.3</a>
33832 iso646.h header, <a href="#4">4</a>, <a href="#7.9">7.9</a> labs function, <a href="#7.22.6.1">7.22.6.1</a>
33833 isprint function, <a href="#5.2.2">5.2.2</a>, <a href="#7.4.1.8">7.4.1.8</a> language, <a href="#6">6</a>
33834 ispunct function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, future directions, <a href="#6.11">6.11</a>
33836 isspace function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, Latin alphabet, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
33837 <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, LC_ALL macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
33838 <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.29.2.2">7.29.2.2</a> LC_COLLATE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.24.4.3">7.24.4.3</a>,
33839 isunordered macro, <a href="#7.12.14.6">7.12.14.6</a>, <a href="#F.3">F.3</a> <a href="#7.29.4.4.2">7.29.4.4.2</a>
33840 isupper function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.4.2.1">7.4.2.1</a>, LC_CTYPE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7">7.22.7</a>,
33841 <a href="#7.4.2.2">7.4.2.2</a> <a href="#7.22.8">7.22.8</a>, <a href="#7.29.6">7.29.6</a>, <a href="#7.30.1">7.30.1</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a>, <a href="#7.30.2.2.2">7.30.2.2.2</a>,
33842 iswalnum function, <a href="#7.30.2.1.1">7.30.2.1.1</a>, <a href="#7.30.2.1.9">7.30.2.1.9</a>, <a href="#7.30.3.2.1">7.30.3.2.1</a>, <a href="#7.30.3.2.2">7.30.3.2.2</a>, <a href="#K.3.6.4">K.3.6.4</a>, <a href="#K.3.6.5">K.3.6.5</a>
33843 <a href="#7.30.2.1.10">7.30.2.1.10</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a> LC_MONETARY macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
33844 iswalpha function, <a href="#7.30.2.1.1">7.30.2.1.1</a>, <a href="#7.30.2.1.2">7.30.2.1.2</a>, LC_NUMERIC macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
33845 <a href="#7.30.2.2.1">7.30.2.2.1</a> LC_TIME macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.27.3.5">7.27.3.5</a>
33846 iswblank function, <a href="#7.30.2.1.3">7.30.2.1.3</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a> lconv structure type, <a href="#7.11">7.11</a>
33847 iswcntrl function, <a href="#7.30.2.1.2">7.30.2.1.2</a>, <a href="#7.30.2.1.4">7.30.2.1.4</a>, LDBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33848 <a href="#7.30.2.1.7">7.30.2.1.7</a>, <a href="#7.30.2.1.11">7.30.2.1.11</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a> LDBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33849 iswctype function, <a href="#7.30.2.2.1">7.30.2.2.1</a>, <a href="#7.30.2.2.2">7.30.2.2.2</a> LDBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33850 iswdigit function, <a href="#7.30.2.1.1">7.30.2.1.1</a>, <a href="#7.30.2.1.2">7.30.2.1.2</a>, LDBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33851 <a href="#7.30.2.1.5">7.30.2.1.5</a>, <a href="#7.30.2.1.7">7.30.2.1.7</a>, <a href="#7.30.2.1.11">7.30.2.1.11</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a> LDBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33852 iswgraph function, <a href="#7.30.2.1">7.30.2.1</a>, <a href="#7.30.2.1.6">7.30.2.1.6</a>, LDBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33853 <a href="#7.30.2.1.10">7.30.2.1.10</a>, <a href="#7.30.2.2.1">7.30.2.2.1</a> LDBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33854 iswlower function, <a href="#7.30.2.1.2">7.30.2.1.2</a>, <a href="#7.30.2.1.7">7.30.2.1.7</a>, LDBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33855 <a href="#7.30.2.2.1">7.30.2.2.1</a>, <a href="#7.30.3.1.1">7.30.3.1.1</a>, <a href="#7.30.3.1.2">7.30.3.1.2</a> LDBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33856 iswprint function, <a href="#7.30.2.1.6">7.30.2.1.6</a>, <a href="#7.30.2.1.8">7.30.2.1.8</a>, LDBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
33858 <!--page 689 -->
33859 LDBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a> llround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a>
33860 ldexp functions, <a href="#7.12.6.6">7.12.6.6</a>, <a href="#F.10.3.6">F.10.3.6</a> llround type-generic macro, <a href="#7.25">7.25</a>
33863 ldiv_t type, <a href="#7.22">7.22</a> locale-specific behavior, <a href="#3.4.2">3.4.2</a>, <a href="#J.4">J.4</a>
33864 leading underscore in identifiers, <a href="#7.1.3">7.1.3</a> locale.h header, <a href="#7.11">7.11</a>, <a href="#7.31.6">7.31.6</a>
33865 left-shift assignment operator (<<=), <a href="#6.5.16.2">6.5.16.2</a> localeconv function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
33866 left-shift operator (<<), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a> localization header, <a href="#7.11">7.11</a>, <a href="#7.31.6">7.31.6</a>
33868 external name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a> localtime_s function, <a href="#K.3.8.2.4">K.3.8.2.4</a>
33869 function name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a> log functions, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#F.10.3.7">F.10.3.7</a>
33871 internal name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a> log10 functions, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#F.10.3.8">F.10.3.8</a>
33872 length function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.24.6.3">7.24.6.3</a>, <a href="#7.29.4.6.1">7.29.4.6.1</a>, log10 type-generic macro, <a href="#7.25">7.25</a>
33873 <a href="#7.29.6.3.1">7.29.6.3.1</a>, <a href="#K.3.7.4.4">K.3.7.4.4</a>, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a> log1p functions, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#F.10.3.9">F.10.3.9</a>
33874 length modifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, log1p type-generic macro, <a href="#7.25">7.25</a>
33875 <a href="#7.29.2.2">7.29.2.2</a> log2 functions, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#F.10.3.10">F.10.3.10</a>
33876 less-than operator (<), <a href="#6.5.8">6.5.8</a> log2 type-generic macro, <a href="#7.25">7.25</a>
33878 letter, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a> complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
33879 lexical elements, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a> real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>
33880 lgamma functions, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#F.10.5.3">F.10.5.3</a> logb functions, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.11">F.10.3.11</a>
33881 lgamma type-generic macro, <a href="#7.25">7.25</a> logb type-generic macro, <a href="#7.25">7.25</a>
33882 library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7">7</a>, <a href="#K.3">K.3</a> logical operators
33883 future directions, <a href="#7.31">7.31</a> AND (&&), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>
33885 terms, <a href="#7.1.1">7.1.1</a> OR (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>
33886 use of functions, <a href="#7.1.4">7.1.4</a> logical source lines, <a href="#5.1.1.2">5.1.1.2</a>
33888 limits long double _Complex type conversion,
33889 environmental, see environmental limits <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
33891 numerical, see numerical limits long double suffix, l or <a href="#L">L</a>, <a href="#6.4.4.2">6.4.4.2</a>
33892 translation, see translation limits long double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>,
33893 limits.h header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a> <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#F.2">F.2</a>
33894 line buffered stream, <a href="#7.21.3">7.21.3</a> long double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,
33895 line number, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a> <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
33896 line preprocessing directive, <a href="#6.10.4">6.10.4</a> long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
33897 lines, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#7.21.2">7.21.2</a> <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>
33898 preprocessing directive, <a href="#6.10">6.10</a> long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
33899 linkage, <a href="#6.2.2">6.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.4">6.7.4</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.9">6.9</a>, <a href="#6.9.2">6.9.2</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
33900 <a href="#6.11.2">6.11.2</a> long integer suffix, l or <a href="#L">L</a>, <a href="#6.4.4.1">6.4.4.1</a>
33901 llabs function, <a href="#7.22.6.1">7.22.6.1</a> long long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>,
33902 lldiv function, <a href="#7.22.6.2">7.22.6.2</a> <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>
33903 lldiv_t type, <a href="#7.22">7.22</a> long long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>,
33904 LLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
33905 <a href="#7.29.4.1.2">7.29.4.1.2</a> long long integer suffix, ll or LL, <a href="#6.4.4.1">6.4.4.1</a>
33906 LLONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, LONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.29.4.1.2">7.29.4.1.2</a>
33907 <a href="#7.29.4.1.2">7.29.4.1.2</a> LONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.29.4.1.2">7.29.4.1.2</a>
33908 llrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a> longjmp function, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>, <a href="#7.22.4.4">7.22.4.4</a>,
33910 <!--page 690 -->
33911 loop body, <a href="#6.8.5">6.8.5</a> <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#7.29.6.3.1">7.29.6.3.1</a>, <a href="#7.29.6.3.2">7.29.6.3.2</a>,
33912 low-order bit, <a href="#3.6">3.6</a> <a href="#7.29.6.4.1">7.29.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>
33913 lowercase letter, <a href="#5.2.1">5.2.1</a> mbsinit function, <a href="#7.29.6.2.1">7.29.6.2.1</a>
33914 lrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a> mbsrtowcs function, <a href="#7.29.6.4.1">7.29.6.4.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
33915 lrint type-generic macro, <a href="#7.25">7.25</a> mbsrtowcs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>
33916 lround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a> mbstate_t type, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>,
33917 lround type-generic macro, <a href="#7.25">7.25</a> <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28">7.28</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.1">7.29.2.1</a>,
33918 lvalue, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>, <a href="#6.5.16">6.5.16</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#7.29.6">7.29.6</a>, <a href="#7.29.6.2.1">7.29.6.2.1</a>, <a href="#7.29.6.3">7.29.6.3</a>,
33919 <a href="#6.7.2.4">6.7.2.4</a> <a href="#7.29.6.3.1">7.29.6.3.1</a>, <a href="#7.29.6.4">7.29.6.4</a>
33920 lvalue conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.5.16.1">6.5.16.1</a>, mbstowcs function, <a href="#6.4.5">6.4.5</a>, <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.29.6.4">7.29.6.4</a>
33922 mbtowc function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.22.7.2">7.22.7.2</a>,
33923 macro argument substitution, <a href="#6.10.3.1">6.10.3.1</a> <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.29.6.3">7.29.6.3</a>
33926 macro invocation, <a href="#6.10.3">6.10.3</a> memchr function, <a href="#7.24.5.1">7.24.5.1</a>
33927 macro name, <a href="#6.10.3">6.10.3</a> memcmp function, <a href="#7.24.4">7.24.4</a>, <a href="#7.24.4.1">7.24.4.1</a>
33929 predefined, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a> memcpy_s function, <a href="#K.3.7.1.1">K.3.7.1.1</a>
33931 scope, <a href="#6.10.3.5">6.10.3.5</a> memmove_s function, <a href="#K.3.7.1.2">K.3.7.1.2</a>
33933 macro preprocessor, <a href="#6.10">6.10</a> memory management functions, <a href="#7.22.3">7.22.3</a>
33934 macro replacement, <a href="#6.10.3">6.10.3</a> memory_order type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.3">7.17.3</a>
33935 magnitude, complex, <a href="#7.3.8.1">7.3.8.1</a> memset function, <a href="#7.24.6.1">7.24.6.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>
33936 main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.4">6.7.4</a>, memset_s function, <a href="#K.3.7.4.1">K.3.7.4.1</a>
33937 <a href="#7.21.3">7.21.3</a> minimum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>
33938 malloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.4">7.22.3.4</a>, <a href="#7.22.3.5">7.22.3.5</a> minus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>
33939 manipulation functions miscellaneous functions
33940 complex, <a href="#7.3.9">7.3.9</a> string, <a href="#7.24.6">7.24.6</a>, <a href="#K.3.7.4">K.3.7.4</a>
33941 real, <a href="#7.12.11">7.12.11</a>, <a href="#F.10.8">F.10.8</a> wide string, <a href="#7.29.4.6">7.29.4.6</a>, <a href="#K.3.9.2.4">K.3.9.2.4</a>
33942 matching failure, <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.2.8">7.29.2.8</a>, <a href="#7.29.2.10">7.29.2.10</a>, mktime function, <a href="#7.27.2.3">7.27.2.3</a>
33943 <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a> modf functions, <a href="#7.12.6.12">7.12.6.12</a>, <a href="#F.10.3.12">F.10.3.12</a>
33944 math.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.25">7.25</a>, <a href="#F">F</a>, modifiable lvalue, <a href="#6.3.2.1">6.3.2.1</a>
33945 <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a> modification order, <a href="#5.1.2.4">5.1.2.4</a>
33946 MATH_ERREXCEPT macro, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a> modulus functions, <a href="#7.12.6.12">7.12.6.12</a>
33947 math_errhandling macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a> modulus, complex, <a href="#7.3.8.1">7.3.8.1</a>
33948 MATH_ERRNO macro, <a href="#7.12">7.12</a> mtx_destroy function, <a href="#7.26.4.1">7.26.4.1</a>
33949 mathematics header, <a href="#7.12">7.12</a> mtx_init function, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.4.2">7.26.4.2</a>
33950 max_align_t type, <a href="#7.19">7.19</a> mtx_lock function, <a href="#7.26.4.3">7.26.4.3</a>
33952 maximum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a> mtx_timedlock function, <a href="#7.26.4.4">7.26.4.4</a>
33953 MB_CUR_MAX macro, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7.2">7.22.7.2</a>, mtx_trylock function, <a href="#7.26.4.5">7.26.4.5</a>
33954 <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.28.1.2">7.28.1.2</a>, <a href="#7.28.1.4">7.28.1.4</a>, <a href="#7.29.6.3.3">7.29.6.3.3</a>, mtx_unlock function, <a href="#7.26.4.3">7.26.4.3</a>, <a href="#7.26.4.4">7.26.4.4</a>,
33955 <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a> <a href="#7.26.4.5">7.26.4.5</a>, <a href="#7.26.4.6">7.26.4.6</a>
33956 MB_LEN_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a> multibyte character, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
33957 mblen function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.29.6.3">7.29.6.3</a> multibyte conversion functions
33958 mbrlen function, <a href="#7.29.6.3.1">7.29.6.3.1</a> wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
33959 mbrtoc16 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.28.1.1">7.28.1.1</a> extended, <a href="#7.29.6">7.29.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
33960 mbrtoc32 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.28.1.3">7.28.1.3</a> restartable, <a href="#7.28.1">7.28.1</a>, <a href="#7.29.6.3">7.29.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
33961 mbrtowc function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, wide string, <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
33962 <!--page 691 -->
33963 restartable, <a href="#7.29.6.4">7.29.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a> not macro, <a href="#7.9">7.9</a>
33966 <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a> null character (\0), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>
33967 extended, <a href="#7.29.6">7.29.6</a>, <a href="#K.3.9.3">K.3.9.3</a> padding of binary stream, <a href="#7.21.2">7.21.2</a>
33968 restartable, <a href="#7.28.1">7.28.1</a>, <a href="#7.29.6.3">7.29.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a> NULL macro, <a href="#7.11">7.11</a>, <a href="#7.19">7.19</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.22">7.22</a>, <a href="#7.24.1">7.24.1</a>,
33969 multibyte/wide string conversion functions, <a href="#7.27.1">7.27.1</a>, <a href="#7.29.1">7.29.1</a>
33970 <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a> null pointer, <a href="#6.3.2.3">6.3.2.3</a>
33971 restartable, <a href="#7.29.6.4">7.29.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a> null pointer constant, <a href="#6.3.2.3">6.3.2.3</a>
33972 multidimensional array, <a href="#6.5.2.1">6.5.2.1</a> null preprocessing directive, <a href="#6.10.7">6.10.7</a>
33973 multiplication assignment operator (*=), <a href="#6.5.16.2">6.5.16.2</a> null statement, <a href="#6.8.3">6.8.3</a>
33974 multiplication operator (*), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, null wide character, <a href="#7.1.1">7.1.1</a>
33975 <a href="#G.5.1">G.5.1</a> number classification macros, <a href="#7.12">7.12</a>, <a href="#7.12.3.1">7.12.3.1</a>
33976 multiplicative expressions, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a> numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>
33978 n-char sequence, <a href="#7.22.1.3">7.22.1.3</a> numerical limits, <a href="#5.2.4.2">5.2.4.2</a>
33981 external, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a> object representation, <a href="#6.2.6.1">6.2.6.1</a>
33983 internal, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a> object-like macro, <a href="#6.10.3">6.10.3</a>
33985 structure/union member, <a href="#6.2.3">6.2.3</a> obsolescence, <a href="#6.11">6.11</a>, <a href="#7.31">7.31</a>
33987 named label, <a href="#6.8.1">6.8.1</a> octal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
33989 nan functions, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#F.2.1">F.2.1</a>, <a href="#F.10.8.2">F.10.8.2</a> <a href="#6.4.4.4">6.4.4.4</a>
33990 NAN macro, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a> offsetof macro, <a href="#7.19">7.19</a>
33992 nearbyint functions, <a href="#7.12.9.3">7.12.9.3</a>, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, once_flag type, <a href="#7.26.1">7.26.1</a>
33994 nearbyint type-generic macro, <a href="#7.25">7.25</a> ones' complement, <a href="#6.2.6.2">6.2.6.2</a>
33995 nearest integer functions, <a href="#7.12.9">7.12.9</a>, <a href="#F.10.6">F.10.6</a> operand, <a href="#6.4.6">6.4.6</a>, <a href="#6.5">6.5</a>
33996 negation operator (!), <a href="#6.5.3.3">6.5.3.3</a> operating system, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#7.22.4.8">7.22.4.8</a>
33997 negative zero, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.12.11.1">7.12.11.1</a> operations on files, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>
33998 new-line character, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#6.10.4">6.10.4</a> operator, <a href="#6.4.6">6.4.6</a>
33999 new-line escape sequence (\n), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, operators, <a href="#6.5">6.5</a>
34001 nextafter functions, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>
34004 nexttoward functions, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.8.4">F.10.8.4</a> equality, <a href="#6.5.9">6.5.9</a>
34005 nexttoward type-generic macro, <a href="#7.25">7.25</a> multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
34008 non-stop floating-point control mode, <a href="#7.6.4.2">7.6.4.2</a> preprocessing, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, <a href="#6.10.9">6.10.9</a>
34009 nongraphic characters, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a> relational, <a href="#6.5.8">6.5.8</a>
34013 normalized broken-down time, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a> unary arithmetic, <a href="#6.5.3.3">6.5.3.3</a>
34014 <!--page 692 -->
34015 optional features, see conditional features portability, <a href="#4">4</a>, <a href="#J">J</a>
34018 bitwise exclusive (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a> positive difference functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>
34019 bitwise exclusive assignment (^=), <a href="#6.5.16.2">6.5.16.2</a> postfix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
34020 bitwise inclusive (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a> postfix expressions, <a href="#6.5.2">6.5.2</a>
34021 bitwise inclusive assignment (|=), <a href="#6.5.16.2">6.5.16.2</a> postfix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
34022 logical (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a> pow functions, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#F.10.4.4">F.10.4.4</a>
34025 order of evaluation, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>
34027 ordinary identifier name space, <a href="#6.2.3">6.2.3</a> pp-number, <a href="#6.4.8">6.4.8</a>
34028 orientation of stream, <a href="#7.21.2">7.21.2</a>, <a href="#7.29.3.5">7.29.3.5</a> pragma operator, <a href="#6.10.9">6.10.9</a>
34029 out-of-bounds store, <a href="#L.2.1">L.2.1</a> pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>
34031 over-aligned, <a href="#6.2.8">6.2.8</a> precedence of syntax rules, <a href="#5.1.1.2">5.1.1.2</a>
34032 precision, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.2.1">7.29.2.1</a>
34033 padding excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>
34034 binary stream, <a href="#7.21.2">7.21.2</a> predefined macro names, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>
34035 bits, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a> prefix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
34036 structure/union, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a> prefix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
34037 parameter, <a href="#3.16">3.16</a> preprocessing concatenation, <a href="#6.10.3.3">6.10.3.3</a>
34038 array, <a href="#6.9.1">6.9.1</a> preprocessing directives, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10">6.10</a>
34039 ellipsis, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a> preprocessing file, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.10">6.10</a>
34040 function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a> preprocessing numbers, <a href="#6.4">6.4</a>, <a href="#6.4.8">6.4.8</a>
34044 parameter type list, <a href="#6.7.6.3">6.7.6.3</a> _Pragma, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>
34045 parentheses punctuator (( )), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a> defined, <a href="#6.10.1">6.10.1</a>
34046 parenthesized expression, <a href="#6.5.1">6.5.1</a> preprocessing tokens, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>
34047 parse state, <a href="#7.21.2">7.21.2</a> preprocessing translation unit, <a href="#5.1.1.1">5.1.1.1</a>
34049 permitted form of initializer, <a href="#6.6">6.6</a> PRIcFASTN macros, <a href="#7.8.1">7.8.1</a>
34050 perror function, <a href="#7.21.10.4">7.21.10.4</a> PRIcLEASTN macros, <a href="#7.8.1">7.8.1</a>
34051 phase angle, complex, <a href="#7.3.9.1">7.3.9.1</a> PRIcMAX macros, <a href="#7.8.1">7.8.1</a>
34052 physical source lines, <a href="#5.1.1.2">5.1.1.2</a> PRIcN macros, <a href="#7.8.1">7.8.1</a>
34054 plus operator, unary, <a href="#6.5.3.3">6.5.3.3</a> primary expression, <a href="#6.5.1">6.5.1</a>
34055 pointer arithmetic, <a href="#6.5.6">6.5.6</a> printf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.10">7.21.6.10</a>,
34057 pointer declarator, <a href="#6.7.6.1">6.7.6.1</a> printf_s function, <a href="#K.3.5.3.3">K.3.5.3.3</a>
34058 pointer operator (->), <a href="#6.5.2.3">6.5.2.3</a> printing character, <a href="#5.2.2">5.2.2</a>, <a href="#7.4">7.4</a>, <a href="#7.4.1.8">7.4.1.8</a>
34059 pointer to function, <a href="#6.5.2.2">6.5.2.2</a> printing wide character, <a href="#7.30.2">7.30.2</a>
34061 pointer type conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a> program execution, <a href="#5.1.2.2.2">5.1.2.2.2</a>, <a href="#5.1.2.3">5.1.2.3</a>
34063 pole error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#7.12.6.8">7.12.6.8</a>, program image, <a href="#5.1.1.2">5.1.1.2</a>
34064 <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#7.12.7.4">7.12.7.4</a>, program name (argv[0]), <a href="#5.1.2.2.1">5.1.2.2.1</a>
34065 <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a> program parameters, <a href="#5.1.2.2.1">5.1.2.2.1</a>
34066 <!--page 693 -->
34067 program startup, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.1">5.1.2.2.1</a> recursion, <a href="#6.5.2.2">6.5.2.2</a>
34068 program structure, <a href="#5.1.1.1">5.1.1.1</a> recursive function call, <a href="#6.5.2.2">6.5.2.2</a>
34069 program termination, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, redefinition of macro, <a href="#6.10.3">6.10.3</a>
34070 <a href="#5.1.2.3">5.1.2.3</a> reentrancy, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>
34073 promotions register storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
34074 default argument, <a href="#6.5.2.2">6.5.2.2</a> relational expressions, <a href="#6.5.8">6.5.8</a>
34075 integer, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.3.1.1">6.3.1.1</a> relaxed atomic operations, <a href="#5.1.2.4">5.1.2.4</a>
34077 pseudo-random sequence functions, <a href="#7.22.2">7.22.2</a> release operation, <a href="#5.1.2.4">5.1.2.4</a>
34078 PTRDIFF_MAX macro, <a href="#7.20.3">7.20.3</a> release sequence, <a href="#5.1.2.4">5.1.2.4</a>
34079 PTRDIFF_MIN macro, <a href="#7.20.3">7.20.3</a> reliability of data, interrupted, <a href="#5.1.2.3">5.1.2.3</a>
34080 ptrdiff_t type, <a href="#7.17.1">7.17.1</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, remainder assignment operator (%=), <a href="#6.5.16.2">6.5.16.2</a>
34081 <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a> remainder functions, <a href="#7.12.10">7.12.10</a>, <a href="#F.10.7">F.10.7</a>
34082 punctuators, <a href="#6.4.6">6.4.6</a> remainder functions, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>,
34083 putc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.7.8">7.21.7.8</a> <a href="#F.10.7.2">F.10.7.2</a>
34084 putchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.8">7.21.7.8</a> remainder operator (%), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>
34085 puts function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.9">7.21.7.9</a> remainder type-generic macro, <a href="#7.25">7.25</a>
34086 putwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3.8">7.29.3.8</a>, <a href="#7.29.3.9">7.29.3.9</a> remove function, <a href="#7.21.4.1">7.21.4.1</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
34087 putwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3.9">7.29.3.9</a> remquo functions, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>, <a href="#F.10.7.3">F.10.7.3</a>
34089 qsort function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.2">7.22.5.2</a> rename function, <a href="#7.21.4.2">7.21.4.2</a>
34090 qsort_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a> representations of types, <a href="#6.2.6">6.2.6</a>
34092 qualified version of type, <a href="#6.2.5">6.2.5</a> rescanning and replacement, <a href="#6.10.3.4">6.10.3.4</a>
34093 question-mark escape sequence (\?), <a href="#6.4.4.4">6.4.4.4</a> reserved identifiers, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>
34094 quick_exit function, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>, restartable multibyte/wide character conversion
34095 <a href="#7.22.4.7">7.22.4.7</a> functions, <a href="#7.28.1">7.28.1</a>, <a href="#7.29.6.3">7.29.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
34098 raise function, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>, <a href="#7.22.4.1">7.22.4.1</a> restore calling environment function, <a href="#7.13.2">7.13.2</a>
34099 rand function, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.2.2">7.22.2.2</a> restrict type qualifier, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>
34100 RAND_MAX macro, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a> restrict-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
34102 excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a> rewind function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.5">7.21.9.5</a>,
34103 range error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#7.29.3.10">7.29.3.10</a>
34104 <a href="#7.12.6.2">7.12.6.2</a>, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.6">7.12.6.6</a>, right-shift assignment operator (>>=), <a href="#6.5.16.2">6.5.16.2</a>
34105 <a href="#7.12.6.13">7.12.6.13</a>, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.8.2">7.12.8.2</a>, right-shift operator (>>), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
34106 <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, rint functions, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.4">F.10.6.4</a>
34107 <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#7.12.13.1">7.12.13.1</a> rint type-generic macro, <a href="#7.25">7.25</a>
34108 rank, see integer conversion rank round functions, <a href="#7.12.9.6">7.12.9.6</a>, <a href="#F.10.6.6">F.10.6.6</a>
34109 read-modify-write operations, <a href="#5.1.2.4">5.1.2.4</a> round type-generic macro, <a href="#7.25">7.25</a>
34110 real floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, rounding mode, floating point, <a href="#5.2.4.2.2">5.2.4.2.2</a>
34111 <a href="#6.3.1.7">6.3.1.7</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a> RSIZE_MAX macro, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>,
34112 real floating types, <a href="#6.2.5">6.2.5</a> <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>, <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>,
34113 real type domain, <a href="#6.2.5">6.2.5</a> <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>,
34114 real types, <a href="#6.2.5">6.2.5</a> <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.7.1.1">K.3.7.1.1</a>,
34115 real-floating, <a href="#7.12.3">7.12.3</a> <a href="#K.3.7.1.2">K.3.7.1.2</a>, <a href="#K.3.7.1.3">K.3.7.1.3</a>, <a href="#K.3.7.1.4">K.3.7.1.4</a>, <a href="#K.3.7.2.1">K.3.7.2.1</a>,
34116 realloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.5">7.22.3.5</a> <a href="#K.3.7.2.2">K.3.7.2.2</a>, <a href="#K.3.7.3.1">K.3.7.3.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a>,
34117 recommended practice, <a href="#3.17">3.17</a> <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>,
34118 <!--page 694 -->
34119 <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a>, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a>, <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a>, <a href="#K.3.6.1.3">K.3.6.1.3</a>
34120 <a href="#K.3.9.2.1.3">K.3.9.2.1.3</a>, <a href="#K.3.9.2.1.4">K.3.9.2.1.4</a>, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a>, setbuf function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.5">7.21.5.5</a>
34121 <a href="#K.3.9.2.2.2">K.3.9.2.2.2</a>, <a href="#K.3.9.2.3.1">K.3.9.2.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, setjmp macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>
34122 <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a> setjmp.h header, <a href="#7.13">7.13</a>
34123 rsize_t type, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>, setlocale function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
34124 <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a> setvbuf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>,
34125 runtime-constraint, <a href="#3.18">3.18</a> <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>
34126 Runtime-constraint handling functions, <a href="#K.3.6.1">K.3.6.1</a> shall, <a href="#4">4</a>
34130 save calling environment function, <a href="#7.13.1">7.13.1</a> short identifier, character, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.3">6.4.3</a>
34131 scalar types, <a href="#6.2.5">6.2.5</a> short int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
34132 scalbln function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a> <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>
34133 scalbln type-generic macro, <a href="#7.25">7.25</a> short int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
34134 scalbn function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a> <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
34135 scalbn type-generic macro, <a href="#7.25">7.25</a> SHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
34136 scanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.11">7.21.6.11</a> SHRT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
34137 scanf_s function, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a> side effects, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.4">6.5.2.4</a>,
34138 scanlist, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a> <a href="#6.5.16">6.5.16</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8.3">6.8.3</a>, <a href="#7.6">7.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.21.7.5">7.21.7.5</a>,
34139 scanset, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a> <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.29.3.6">7.29.3.6</a>, <a href="#7.29.3.8">7.29.3.8</a>, <a href="#F.8.1">F.8.1</a>, <a href="#F.9.1">F.9.1</a>,
34141 SCHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a> SIG_ATOMIC_MAX macro, <a href="#7.20.3">7.20.3</a>
34142 SCNcFASTN macros, <a href="#7.8.1">7.8.1</a> SIG_ATOMIC_MIN macro, <a href="#7.20.3">7.20.3</a>
34143 SCNcLEASTN macros, <a href="#7.8.1">7.8.1</a> sig_atomic_t type, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>,
34145 SCNcN macros, <a href="#7.8.1">7.8.1</a> SIG_DFL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>
34146 SCNcPTR macros, <a href="#7.8.1">7.8.1</a> SIG_ERR macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>
34147 scope of identifier, <a href="#6.2.1">6.2.1</a>, <a href="#6.9.2">6.9.2</a> SIG_IGN macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>
34149 string, <a href="#7.24.5">7.24.5</a>, <a href="#K.3.7.3">K.3.7.3</a> SIGFPE macro, <a href="#7.12.1">7.12.1</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.2">J.2</a>, <a href="#J.5.17">J.5.17</a>
34150 utility, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a> SIGILL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.2">J.2</a>
34151 wide string, <a href="#7.29.4.5">7.29.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a> SIGINT macro, <a href="#7.14">7.14</a>
34152 SEEK_CUR macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a> sign and magnitude, <a href="#6.2.6.2">6.2.6.2</a>
34153 SEEK_END macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a> sign bit, <a href="#6.2.6.2">6.2.6.2</a>
34154 SEEK_SET macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a> signal function, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
34155 selection statements, <a href="#6.8.4">6.8.4</a> signal handler, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>
34156 self-referential structure, <a href="#6.7.2.3">6.7.2.3</a> signal handling functions, <a href="#7.14.1">7.14.1</a>
34157 semicolon punctuator (;), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>, signal handling header, <a href="#7.14">7.14</a>, <a href="#7.31.7">7.31.7</a>
34158 <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a> signal.h header, <a href="#7.14">7.14</a>, <a href="#7.31.7">7.31.7</a>
34159 separate compilation, <a href="#5.1.1.1">5.1.1.1</a> signaling NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#F.2.1">F.2.1</a>
34160 separate translation, <a href="#5.1.1.1">5.1.1.1</a> signals, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1">7.14.1</a>
34161 sequence points, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.13">6.5.13</a>, <a href="#6.5.14">6.5.14</a>, signbit macro, <a href="#7.12.3.6">7.12.3.6</a>, <a href="#F.3">F.3</a>
34162 <a href="#6.5.15">6.5.15</a>, <a href="#6.5.17">6.5.17</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.6">6.7.6</a>, <a href="#6.8">6.8</a>, signed char type, <a href="#6.2.5">6.2.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
34163 <a href="#7.1.4">7.1.4</a>, <a href="#7.21.6">7.21.6</a>, <a href="#7.22.5">7.22.5</a>, <a href="#7.29.2">7.29.2</a>, <a href="#C">C</a>, <a href="#K.3.6.3">K.3.6.3</a> <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
34165 sequenced before, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.2.4">6.5.2.4</a>, signed integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>
34166 <a href="#6.5.16">6.5.16</a>, see also indeterminately sequenced, signed type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
34168 sequencing of statements, <a href="#6.8">6.8</a> signed types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>
34170 <!--page 695 -->
34171 SIGSEGV macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.2">J.2</a> <a href="#7.8"><inttypes.h></a>, <a href="#7.8">7.8</a>, <a href="#7.31.5">7.31.5</a>
34172 SIGTERM macro, <a href="#7.14">7.14</a> <a href="#7.9"><iso646.h></a>, <a href="#4">4</a>, <a href="#7.9">7.9</a>
34173 simple assignment operator (=), <a href="#6.5.16.1">6.5.16.1</a> <a href="#7.10"><limits.h></a>, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
34174 sin functions, <a href="#7.12.4.6">7.12.4.6</a>, <a href="#F.10.1.6">F.10.1.6</a> <a href="#7.11"><locale.h></a>, <a href="#7.11">7.11</a>, <a href="#7.31.6">7.31.6</a>
34175 sin type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> <a href="#7.12"><math.h></a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.25">7.25</a>, <a href="#F">F</a>, <a href="#F.10">F.10</a>,
34176 single-byte character, <a href="#3.7.1">3.7.1</a>, <a href="#5.2.1.2">5.2.1.2</a> <a href="#J.5.17">J.5.17</a>
34177 single-byte/wide character conversion functions, <a href="#7.13"><setjmp.h></a>, <a href="#7.13">7.13</a>
34178 <a href="#7.29.6.1">7.29.6.1</a> <a href="#7.14"><signal.h></a>, <a href="#7.14">7.14</a>, <a href="#7.31.7">7.31.7</a>
34179 single-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a> <a href="#7.15"><stdalign.h></a>, <a href="#4">4</a>, <a href="#7.15">7.15</a>
34180 single-quote escape sequence (\'), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a> <a href="#7.16"><stdarg.h></a>, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
34181 singularity, <a href="#7.12.1">7.12.1</a> <a href="#7.17"><stdatomic.h></a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>,
34182 sinh functions, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#F.10.2.5">F.10.2.5</a> <a href="#7.31.8">7.31.8</a>
34183 sinh type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> <a href="#7.18"><stdbool.h></a>, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.31.9">7.31.9</a>, <a href="#H">H</a>
34184 SIZE_MAX macro, <a href="#7.20.3">7.20.3</a> <a href="#7.19"><stddef.h></a>, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
34185 size_t type, <a href="#6.2.8">6.2.8</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.1">7.21.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>
34186 <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.28">7.28</a>, <a href="#7.20"><stdint.h></a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>,
34187 <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#7.31.10">7.31.10</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>
34188 <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a> <a href="#7.21"><stdio.h></a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.31.11">7.31.11</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>
34189 sizeof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a> <a href="#7.22"><stdlib.h></a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.31.12">7.31.12</a>, <a href="#F">F</a>,
34190 sizes of integer types header, <a href="#7.10">7.10</a> <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>
34191 snprintf function, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.23"><stdnoreturn.h></a>, <a href="#4">4</a>, <a href="#7.23">7.23</a>
34192 <a href="#K.3.5.3.5">K.3.5.3.5</a> <a href="#7.24"><string.h></a>, <a href="#7.24">7.24</a>, <a href="#7.31.13">7.31.13</a>, <a href="#K.3.7">K.3.7</a>
34193 snprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a> <a href="#7.25"><tgmath.h></a>, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a>
34194 snwprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a> <a href="#7.26"><threads.h></a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.26">7.26</a>, <a href="#7.31.15">7.31.15</a>
34195 sorting utility functions, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a> <a href="#7.27"><time.h></a>, <a href="#7.26.1">7.26.1</a>, <a href="#7.27">7.27</a>, <a href="#7.31.14">7.31.14</a>, <a href="#K.3.8">K.3.8</a>
34196 source character set, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a> <a href="#7.28"><uchar.h></a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.28">7.28</a>
34197 source file, <a href="#5.1.1.1">5.1.1.1</a> <a href="#7.29"><wchar.h></a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.29">7.29</a>, <a href="#7.31.16">7.31.16</a>,
34198 name, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a> <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>
34199 source file inclusion, <a href="#6.10.2">6.10.2</a> <a href="#7.30"><wctype.h></a>, <a href="#7.30">7.30</a>, <a href="#7.31.17">7.31.17</a>
34200 source lines, <a href="#5.1.1.2">5.1.1.2</a> standard input stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>
34201 source text, <a href="#5.1.1.2">5.1.1.2</a> standard integer types, <a href="#6.2.5">6.2.5</a>
34202 space character (' '), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, standard output stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>
34203 <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.30.2.1.3">7.30.2.1.3</a> standard signed integer types, <a href="#6.2.5">6.2.5</a>
34204 sprintf function, <a href="#7.21.6.6">7.21.6.6</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a> state-dependent encoding, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
34205 sprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a> statements, <a href="#6.8">6.8</a>
34206 sqrt functions, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.5">F.10.4.5</a> break, <a href="#6.8.6.3">6.8.6.3</a>
34209 sscanf function, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.14">7.21.6.14</a> do, <a href="#6.8.5.2">6.8.5.2</a>
34210 sscanf_s function, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a> else, <a href="#6.8.4.1">6.8.4.1</a>
34211 standard error stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.10.4">7.21.10.4</a> expression, <a href="#6.8.3">6.8.3</a>
34212 standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a> for, <a href="#6.8.5.3">6.8.5.3</a>
34213 <a href="#7.2"><assert.h></a>, <a href="#7.2">7.2</a> goto, <a href="#6.8.6.1">6.8.6.1</a>
34214 <a href="#7.3"><complex.h></a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.3">7.3</a>, if, <a href="#6.8.4.1">6.8.4.1</a>
34215 <a href="#7.25">7.25</a>, <a href="#7.31.1">7.31.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a> iteration, <a href="#6.8.5">6.8.5</a>
34216 <a href="#7.4"><ctype.h></a>, <a href="#7.4">7.4</a>, <a href="#7.31.2">7.31.2</a> jump, <a href="#6.8.6">6.8.6</a>
34217 <a href="#7.5"><errno.h></a>, <a href="#7.5">7.5</a>, <a href="#7.31.3">7.31.3</a>, <a href="#K.3.2">K.3.2</a> labeled, <a href="#6.8.1">6.8.1</a>
34218 <a href="#7.6"><fenv.h></a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, null, <a href="#6.8.3">6.8.3</a>
34219 <a href="#7.31.4">7.31.4</a>, <a href="#F">F</a>, <a href="#H">H</a> return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
34220 <a href="#7.7"><float.h></a>, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>, selection, <a href="#6.8.4">6.8.4</a>
34222 <!--page 696 -->
34223 switch, <a href="#6.8.4.2">6.8.4.2</a> strerrorlen_s function, <a href="#K.3.7.4.3">K.3.7.4.3</a>
34224 while, <a href="#6.8.5.1">6.8.5.1</a> strftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.27.3">7.27.3</a>, <a href="#7.27.3.5">7.27.3.5</a>,
34225 static assertions, <a href="#6.7.10">6.7.10</a> <a href="#7.29.5.1">7.29.5.1</a>, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>
34227 static storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.7.1">6.7.1</a> strictly conforming program, <a href="#4">4</a>
34228 static, in array declarators, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.6.3">6.7.6.3</a> string, <a href="#7.1.1">7.1.1</a>
34229 static_assert declaration, <a href="#6.7.10">6.7.10</a> comparison functions, <a href="#7.24.4">7.24.4</a>
34230 static_assert macro, <a href="#7.2">7.2</a> concatenation functions, <a href="#7.24.3">7.24.3</a>, <a href="#K.3.7.2">K.3.7.2</a>
34231 stdalign.h header, <a href="#4">4</a>, <a href="#7.15">7.15</a> conversion functions, <a href="#7.11.1.1">7.11.1.1</a>
34232 stdarg.h header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a> copying functions, <a href="#7.24.2">7.24.2</a>, <a href="#K.3.7.1">K.3.7.1</a>
34233 stdatomic.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>, library function conventions, <a href="#7.24.1">7.24.1</a>
34234 <a href="#7.31.8">7.31.8</a> literal, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.7.9">6.7.9</a>
34235 stdbool.h header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.31.9">7.31.9</a>, <a href="#H">H</a> miscellaneous functions, <a href="#7.24.6">7.24.6</a>, <a href="#K.3.7.4">K.3.7.4</a>
34236 STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a> numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>
34237 stddef.h header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>, search functions, <a href="#7.24.5">7.24.5</a>, <a href="#K.3.7.3">K.3.7.3</a>
34238 <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a> string handling header, <a href="#7.24">7.24</a>, <a href="#7.31.13">7.31.13</a>, <a href="#K.3.7">K.3.7</a>
34239 stderr macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a> string.h header, <a href="#7.24">7.24</a>, <a href="#7.31.13">7.31.13</a>, <a href="#K.3.7">K.3.7</a>
34240 stdin macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.4">7.21.6.4</a>, stringizing, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.9">6.10.9</a>
34241 <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.29.2.12">7.29.2.12</a>, <a href="#7.29.3.7">7.29.3.7</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>, strlen function, <a href="#7.24.6.3">7.24.6.3</a>
34242 <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a> strncat function, <a href="#7.24.3.2">7.24.3.2</a>
34243 stdint.h header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>, strncat_s function, <a href="#K.3.7.2.2">K.3.7.2.2</a>
34244 <a href="#7.31.10">7.31.10</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a> strncmp function, <a href="#7.24.4">7.24.4</a>, <a href="#7.24.4.4">7.24.4.4</a>
34245 stdio.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.31.11">7.31.11</a>, <a href="#F">F</a>, strncpy function, <a href="#7.24.2.4">7.24.2.4</a>
34247 stdlib.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.31.12">7.31.12</a>, <a href="#F">F</a>, strnlen_s function, <a href="#K.3.7.4.4">K.3.7.4.4</a>
34248 <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a> stronger, <a href="#6.2.8">6.2.8</a>
34249 stdnoreturn.h header, <a href="#4">4</a>, <a href="#7.23">7.23</a> strpbrk function, <a href="#7.24.5.4">7.24.5.4</a>
34250 stdout macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.3">7.21.6.3</a>, strrchr function, <a href="#7.24.5.5">7.24.5.5</a>
34251 <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>, <a href="#7.29.2.11">7.29.2.11</a>, <a href="#7.29.3.9">7.29.3.9</a> strspn function, <a href="#7.24.5.6">7.24.5.6</a>
34252 storage duration, <a href="#6.2.4">6.2.4</a> strstr function, <a href="#7.24.5.7">7.24.5.7</a>
34253 storage order of array, <a href="#6.5.2.1">6.5.2.1</a> strtod function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>,
34254 storage unit (bit-field), <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a> <a href="#7.29.2.2">7.29.2.2</a>, <a href="#F.3">F.3</a>
34255 storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a> strtof function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>
34256 strcat function, <a href="#7.24.3.1">7.24.3.1</a> strtoimax function, <a href="#7.8.2.3">7.8.2.3</a>
34257 strcat_s function, <a href="#K.3.7.2.1">K.3.7.2.1</a> strtok function, <a href="#7.24.5.8">7.24.5.8</a>
34258 strchr function, <a href="#7.24.5.2">7.24.5.2</a> strtok_s function, <a href="#K.3.7.3.1">K.3.7.3.1</a>
34259 strcmp function, <a href="#7.24.4">7.24.4</a>, <a href="#7.24.4.2">7.24.4.2</a> strtol function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,
34260 strcoll function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.24.4.3">7.24.4.3</a>, <a href="#7.24.4.5">7.24.4.5</a> <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.29.2.2">7.29.2.2</a>
34261 strcpy function, <a href="#7.24.2.3">7.24.2.3</a> strtold function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>
34262 strcpy_s function, <a href="#K.3.7.1.3">K.3.7.1.3</a> strtoll function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>
34263 strcspn function, <a href="#7.24.5.3">7.24.5.3</a> strtoul function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,
34264 streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.22.4.4">7.22.4.4</a> <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.29.2.2">7.29.2.2</a>
34265 fully buffered, <a href="#7.21.3">7.21.3</a> strtoull function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>
34266 line buffered, <a href="#7.21.3">7.21.3</a> strtoumax function, <a href="#7.8.2.3">7.8.2.3</a>
34268 standard error, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a> struct lconv, <a href="#7.11">7.11</a>
34269 standard input, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a> struct timespec, <a href="#7.27.1">7.27.1</a>
34270 standard output, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a> struct tm, <a href="#7.27.1">7.27.1</a>
34272 strerror function, <a href="#7.21.10.4">7.21.10.4</a>, <a href="#7.24.6.2">7.24.6.2</a> arrow operator (->), <a href="#6.5.2.3">6.5.2.3</a>
34273 strerror_s function, <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a> content, <a href="#6.7.2.3">6.7.2.3</a>
34274 <!--page 697 -->
34275 dot operator (.), <a href="#6.5.2.3">6.5.2.3</a> thrd_current function, <a href="#7.26.5.2">7.26.5.2</a>
34276 initialization, <a href="#6.7.9">6.7.9</a> thrd_detach function, <a href="#7.26.5.3">7.26.5.3</a>
34277 member alignment, <a href="#6.7.2.1">6.7.2.1</a> thrd_equal function, <a href="#7.26.5.4">7.26.5.4</a>
34278 member name space, <a href="#6.2.3">6.2.3</a> thrd_exit function, <a href="#7.26.5.5">7.26.5.5</a>
34279 member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a> thrd_join function, <a href="#7.26.5.6">7.26.5.6</a>
34280 pointer operator (->), <a href="#6.5.2.3">6.5.2.3</a> thrd_sleep function, <a href="#7.26.5.7">7.26.5.7</a>
34282 tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a> thrd_t type, <a href="#7.26.1">7.26.1</a>
34283 type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a> thrd_yield function, <a href="#7.26.5.8">7.26.5.8</a>
34284 strxfrm function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.24.4.5">7.24.4.5</a> thread of execution, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.6">7.6</a>, <a href="#7.22.4.6">7.22.4.6</a>,
34285 subnormal floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a> <a href="#K.3.6.2.1">K.3.6.2.1</a>
34286 subscripting, <a href="#6.5.2.1">6.5.2.1</a> thread storage duration, <a href="#6.2.4">6.2.4</a>, <a href="#7.6">7.6</a>
34287 subtraction assignment operator (-=), <a href="#6.5.16.2">6.5.16.2</a> threads header, <a href="#7.26">7.26</a>, <a href="#7.31.15">7.31.15</a>
34288 subtraction operator (-), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a> threads.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.26">7.26</a>,
34291 integer constant, <a href="#6.4.4.1">6.4.4.1</a> broken down, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.3">7.27.2.3</a>, <a href="#7.27.3">7.27.3</a>, <a href="#7.27.3.1">7.27.3.1</a>,
34292 switch body, <a href="#6.8.4.2">6.8.4.2</a> <a href="#7.27.3.3">7.27.3.3</a>, <a href="#7.27.3.4">7.27.3.4</a>, <a href="#7.27.3.5">7.27.3.5</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>,
34293 switch case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a> <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>
34294 switch default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a> calendar, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.2">7.27.2.2</a>, <a href="#7.27.2.3">7.27.2.3</a>, <a href="#7.27.2.4">7.27.2.4</a>,
34295 switch statement, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a> <a href="#7.27.3.2">7.27.3.2</a>, <a href="#7.27.3.3">7.27.3.3</a>, <a href="#7.27.3.4">7.27.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>,
34296 swprintf function, <a href="#7.29.2.3">7.29.2.3</a>, <a href="#7.29.2.7">7.29.2.7</a>, <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>
34297 <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a> components, <a href="#7.27.1">7.27.1</a>, <a href="#K.3.8.1">K.3.8.1</a>
34298 swprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a> conversion functions, <a href="#7.27.3">7.27.3</a>, <a href="#K.3.8.2">K.3.8.2</a>
34299 swscanf function, <a href="#7.29.2.4">7.29.2.4</a>, <a href="#7.29.2.8">7.29.2.8</a> wide character, <a href="#7.29.5">7.29.5</a>
34300 swscanf_s function, <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a> local, <a href="#7.27.1">7.27.1</a>
34302 synchronization operation, <a href="#5.1.2.4">5.1.2.4</a> normalized broken down, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>
34303 synchronize with, <a href="#5.1.2.4">5.1.2.4</a> time base, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.5">7.27.2.5</a>
34305 syntax notation, <a href="#6.1">6.1</a> time.h header, <a href="#7.26.1">7.26.1</a>, <a href="#7.27">7.27</a>, <a href="#7.31.14">7.31.14</a>, <a href="#K.3.8">K.3.8</a>
34306 syntax rule precedence, <a href="#5.1.1.2">5.1.1.2</a> time_t type, <a href="#7.27.1">7.27.1</a>
34307 syntax summary, language, <a href="#A">A</a> TIME_UTC macro, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.26.4.4">7.26.4.4</a>, <a href="#7.26.5.7">7.26.5.7</a>,
34308 system function, <a href="#7.22.4.8">7.22.4.8</a> <a href="#7.27.1">7.27.1</a>, <a href="#7.27.2.5">7.27.2.5</a>
34310 tab characters, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a> timespec_get function, <a href="#7.27.2.5">7.27.2.5</a>
34311 tag compatibility, <a href="#6.2.7">6.2.7</a> tm structure type, <a href="#7.27.1">7.27.1</a>, <a href="#7.29.1">7.29.1</a>, <a href="#K.3.8.1">K.3.8.1</a>
34312 tag name space, <a href="#6.2.3">6.2.3</a> TMP_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>
34313 tags, <a href="#6.7.2.3">6.7.2.3</a> TMP_MAX_S macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
34314 tan functions, <a href="#7.12.4.7">7.12.4.7</a>, <a href="#F.10.1.7">F.10.1.7</a> tmpfile function, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>
34315 tan type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> tmpfile_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
34316 tanh functions, <a href="#7.12.5.6">7.12.5.6</a>, <a href="#F.10.2.6">F.10.2.6</a> tmpnam function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>,
34317 tanh type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> <a href="#K.3.5.1.2">K.3.5.1.2</a>
34318 temporary lifetime, <a href="#6.2.4">6.2.4</a> tmpnam_s function, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
34319 tentative definition, <a href="#6.9.2">6.9.2</a> token, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, see also preprocessing tokens
34321 text streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a> token pasting, <a href="#6.10.3.3">6.10.3.3</a>
34322 tgamma functions, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#F.10.5.4">F.10.5.4</a> tolower function, <a href="#7.4.2.1">7.4.2.1</a>
34323 tgamma type-generic macro, <a href="#7.25">7.25</a> toupper function, <a href="#7.4.2.2">7.4.2.2</a>
34324 tgmath.h header, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> towctrans function, <a href="#7.30.3.2.1">7.30.3.2.1</a>, <a href="#7.30.3.2.2">7.30.3.2.2</a>
34325 thrd_create function, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.5.1">7.26.5.1</a> towlower function, <a href="#7.30.3.1.1">7.30.3.1.1</a>, <a href="#7.30.3.2.1">7.30.3.2.1</a>
34326 <!--page 698 -->
34327 towupper function, <a href="#7.30.3.1.2">7.30.3.1.2</a>, <a href="#7.30.3.2.1">7.30.3.2.1</a> UCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
34328 translation environment, <a href="#5">5</a>, <a href="#5.1.1">5.1.1</a> UINT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>
34329 translation limits, <a href="#5.2.4.1">5.2.4.1</a> uint_fastN_t types, <a href="#7.20.1.3">7.20.1.3</a>
34330 translation phases, <a href="#5.1.1.2">5.1.1.2</a> uint_least16_t type, <a href="#7.28">7.28</a>
34331 translation unit, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.9">6.9</a> uint_least32_t type, <a href="#7.28">7.28</a>
34333 trap representation, <a href="#3.19.4">3.19.4</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.2.6.2">6.2.6.2</a>, uint_leastN_t types, <a href="#7.20.1.2">7.20.1.2</a>
34334 <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.5.2.3">6.5.2.3</a> UINT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
34336 complex, <a href="#7.3.5">7.3.5</a>, <a href="#G.6.1">G.6.1</a> UINTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
34337 real, <a href="#7.12.4">7.12.4</a>, <a href="#F.10.1">F.10.1</a> uintmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
34338 trigraph sequences, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1.1">5.2.1.1</a> <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a>
34340 trunc functions, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#F.10.6.8">F.10.6.8</a> UINTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>
34341 trunc type-generic macro, <a href="#7.25">7.25</a> uintN_t types, <a href="#7.20.1.1">7.20.1.1</a>
34342 truncation, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a> UINTPTR_MAX macro, <a href="#7.20.2.4">7.20.2.4</a>
34343 truncation toward zero, <a href="#6.5.5">6.5.5</a> uintptr_t type, <a href="#7.20.1.4">7.20.1.4</a>
34344 tss_create function, <a href="#7.26.6.1">7.26.6.1</a> ULLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,
34346 TSS_DTOR_ITERATIONS macro, <a href="#7.26.1">7.26.1</a> ULONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,
34348 tss_get function, <a href="#7.26.6.3">7.26.6.3</a> unary arithmetic operators, <a href="#6.5.3.3">6.5.3.3</a>
34349 tss_set function, <a href="#7.26.6.4">7.26.6.4</a> unary expression, <a href="#6.5.3">6.5.3</a>
34350 tss_t type, <a href="#7.26.1">7.26.1</a> unary minus operator (-), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
34351 two's complement, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a> unary operators, <a href="#6.5.3">6.5.3</a>
34352 type category, <a href="#6.2.5">6.2.5</a> unary plus operator (+), <a href="#6.5.3.3">6.5.3.3</a>
34354 type definitions, <a href="#6.7.8">6.7.8</a> undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,
34356 type names, <a href="#6.7.7">6.7.7</a> undefined behavior, <a href="#3.4.3">3.4.3</a>, <a href="#4">4</a>, <a href="#J.2">J.2</a>
34357 type punning, <a href="#6.5.2.3">6.5.2.3</a> underscore character, <a href="#6.4.2.1">6.4.2.1</a>
34358 type qualifiers, <a href="#6.7.3">6.7.3</a> underscore, leading, in identifier, <a href="#7.1.3">7.1.3</a>
34359 type specifiers, <a href="#6.7.2">6.7.2</a> ungetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
34360 type-generic macro, <a href="#7.25">7.25</a>, <a href="#G.7">G.7</a> <a href="#7.21.9.3">7.21.9.3</a>
34361 type-generic math header, <a href="#7.25">7.25</a> ungetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3.10">7.29.3.10</a>
34362 typedef declaration, <a href="#6.7.8">6.7.8</a> Unicode, <a href="#7.28">7.28</a>, see also char16_t type,
34363 typedef storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.7.8">6.7.8</a> char32_t type, wchar_t type
34365 atomic, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>, unicode utilities header, <a href="#7.28">7.28</a>
34366 <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.17.6">7.17.6</a> union
34368 compatible, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a> content, <a href="#6.7.2.3">6.7.2.3</a>
34369 complex, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a> dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>
34373 imaginary, <a href="#G">G</a> member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>
34374 restrict qualified, <a href="#6.7.3">6.7.3</a> pointer operator (->), <a href="#6.5.2.3">6.5.2.3</a>
34377 uchar.h header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.28">7.28</a> type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>
34378 <!--page 699 -->
34379 universal character name, <a href="#6.4.3">6.4.3</a> value bits, <a href="#6.2.6.2">6.2.6.2</a>
34380 unnormalized floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a> variable arguments, <a href="#6.10.3">6.10.3</a>
34381 unqualified type, <a href="#6.2.5">6.2.5</a> variable arguments header, <a href="#7.16">7.16</a>
34382 unqualified version of type, <a href="#6.2.5">6.2.5</a> variable length array, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>
34383 unsequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, see also variably modified type, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>
34384 indeterminately sequenced, sequenced vertical-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
34385 before vertical-tab escape sequence (\v), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
34386 unsigned char type, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a> <a href="#7.4.1.10">7.4.1.10</a>
34387 unsigned integer suffix, u or <a href="#U">U</a>, <a href="#6.4.4.1">6.4.4.1</a> vfprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#K.3.5.3.8">K.3.5.3.8</a>
34388 unsigned integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a> vfprintf_s function, <a href="#K.3.5.3.8">K.3.5.3.8</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>,
34389 unsigned type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>
34390 <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a> vfscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>
34391 unsigned types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, vfscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
34392 <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a> <a href="#K.3.5.3.14">K.3.5.3.14</a>
34393 unspecified behavior, <a href="#3.4.4">3.4.4</a>, <a href="#4">4</a>, <a href="#J.1">J.1</a> vfwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.2.5">7.29.2.5</a>, <a href="#K.3.9.1.6">K.3.9.1.6</a>
34394 unspecified value, <a href="#3.19.3">3.19.3</a> vfwprintf_s function, <a href="#K.3.9.1.6">K.3.9.1.6</a>
34395 uppercase letter, <a href="#5.2.1">5.2.1</a> vfwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.3.10">7.29.3.10</a>
34396 use of library functions, <a href="#7.1.4">7.1.4</a> vfwscanf_s function, <a href="#K.3.9.1.7">K.3.9.1.7</a>
34397 USHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a> visibility of identifier, <a href="#6.2.1">6.2.1</a>
34398 usual arithmetic conversions, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.5.5">6.5.5</a>, <a href="#6.5.6">6.5.6</a>, visible sequence of side effects, <a href="#5.1.2.4">5.1.2.4</a>
34399 <a href="#6.5.8">6.5.8</a>, <a href="#6.5.9">6.5.9</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>, <a href="#6.5.15">6.5.15</a> visible side effect, <a href="#5.1.2.4">5.1.2.4</a>
34402 UTF-8 string literal, see string literal void function parameter, <a href="#6.7.6.3">6.7.6.3</a>
34403 utilities, general, <a href="#7.22">7.22</a>, <a href="#7.31.12">7.31.12</a>, <a href="#K.3.6">K.3.6</a> void type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
34404 wide string, <a href="#7.29.4">7.29.4</a>, <a href="#K.3.9.2">K.3.9.2</a> <a href="#K.3.9.1.2">K.3.9.1.2</a>
34405 utilities, unicode, <a href="#7.28">7.28</a> void type conversion, <a href="#6.3.2.2">6.3.2.2</a>
34407 va_arg macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.2">7.16.1.2</a>, volatile type qualifier, <a href="#6.7.3">6.7.3</a>
34408 <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, volatile-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
34409 <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>, vprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.10">7.21.6.10</a>,
34410 <a href="#7.29.2.5">7.29.2.5</a>, <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.2.7">7.29.2.7</a>, <a href="#7.29.2.8">7.29.2.8</a>, <a href="#K.3.5.3.10">K.3.5.3.10</a>
34411 <a href="#7.29.2.9">7.29.2.9</a>, <a href="#7.29.2.10">7.29.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, vprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.10">K.3.5.3.10</a>,
34412 <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a> <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>
34413 va_copy macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>, vscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.11">7.21.6.11</a>
34414 <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a> vscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
34415 va_end macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.3">7.16.1.3</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>
34416 <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, vsnprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.12">7.21.6.12</a>,
34417 <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>, <a href="#K.3.5.3.12">K.3.5.3.12</a>
34418 <a href="#7.29.2.5">7.29.2.5</a>, <a href="#7.29.2.6">7.29.2.6</a>, <a href="#7.29.2.7">7.29.2.7</a>, <a href="#7.29.2.8">7.29.2.8</a>, vsnprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
34419 <a href="#7.29.2.9">7.29.2.9</a>, <a href="#7.29.2.10">7.29.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>
34420 <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a> vsnwprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>
34421 va_list type, <a href="#7.16">7.16</a>, <a href="#7.16.1.3">7.16.1.3</a> vsprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.13">7.21.6.13</a>,
34422 va_start macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>
34423 <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>, <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, vsprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
34424 <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>
34425 <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.29.2.5">7.29.2.5</a>, <a href="#7.29.2.6">7.29.2.6</a>, vsscanf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.14">7.21.6.14</a>
34426 <a href="#7.29.2.7">7.29.2.7</a>, <a href="#7.29.2.8">7.29.2.8</a>, <a href="#7.29.2.9">7.29.2.9</a>, <a href="#7.29.2.10">7.29.2.10</a>, vsscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
34427 <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>
34428 <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a> vswprintf function, <a href="#7.29.2.7">7.29.2.7</a>, <a href="#K.3.9.1.8">K.3.9.1.8</a>,
34430 <!--page 700 -->
34431 vswprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a> wcstoll function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.29.4.1.2">7.29.4.1.2</a>
34432 vswscanf function, <a href="#7.29.2.8">7.29.2.8</a> wcstombs function, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.29.6.4">7.29.6.4</a>
34433 vswscanf_s function, <a href="#K.3.9.1.10">K.3.9.1.10</a> wcstombs_s function, <a href="#K.3.6.5.2">K.3.6.5.2</a>
34434 vwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.2.9">7.29.2.9</a>, <a href="#K.3.9.1.11">K.3.9.1.11</a> wcstoul function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a>,
34435 vwprintf_s function, <a href="#K.3.9.1.11">K.3.9.1.11</a> <a href="#7.29.4.1.2">7.29.4.1.2</a>
34436 vwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.2.10">7.29.2.10</a>, <a href="#7.29.3.10">7.29.3.10</a> wcstoull function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.29.4.1.2">7.29.4.1.2</a>
34437 vwscanf_s function, <a href="#K.3.9.1.12">K.3.9.1.12</a> wcstoumax function, <a href="#7.8.2.4">7.8.2.4</a>
34439 warnings, <a href="#I">I</a> wctob function, <a href="#7.29.6.1.2">7.29.6.1.2</a>, <a href="#7.30.2.1">7.30.2.1</a>
34440 wchar.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.29">7.29</a>, <a href="#7.31.16">7.31.16</a>, wctomb function, <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.29.6.3">7.29.6.3</a>
34441 <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a> wctomb_s function, <a href="#K.3.6.4.1">K.3.6.4.1</a>
34442 WCHAR_MAX macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.29.1">7.29.1</a> wctrans function, <a href="#7.30.3.2.1">7.30.3.2.1</a>, <a href="#7.30.3.2.2">7.30.3.2.2</a>
34443 WCHAR_MIN macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.29.1">7.29.1</a> wctrans_t type, <a href="#7.30.1">7.30.1</a>, <a href="#7.30.3.2.2">7.30.3.2.2</a>
34444 wchar_t type, <a href="#3.7.3">3.7.3</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>, wctype function, <a href="#7.30.2.2.1">7.30.2.2.1</a>, <a href="#7.30.2.2.2">7.30.2.2.2</a>
34445 <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.29.1">7.29.1</a>, wctype.h header, <a href="#7.30">7.30</a>, <a href="#7.31.17">7.31.17</a>
34446 <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.2">7.29.2.2</a> wctype_t type, <a href="#7.30.1">7.30.1</a>, <a href="#7.30.2.2.2">7.30.2.2.2</a>
34447 wcrtomb function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.1">7.29.1</a>, weaker, <a href="#6.2.8">6.2.8</a>
34448 <a href="#7.29.2.2">7.29.2.2</a>, <a href="#7.29.6.3.3">7.29.6.3.3</a>, <a href="#7.29.6.4.2">7.29.6.4.2</a>, <a href="#J.1">J.1</a>, WEOF macro, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.3.1">7.29.3.1</a>, <a href="#7.29.3.3">7.29.3.3</a>, <a href="#7.29.3.6">7.29.3.6</a>,
34449 <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a> <a href="#7.29.3.7">7.29.3.7</a>, <a href="#7.29.3.8">7.29.3.8</a>, <a href="#7.29.3.9">7.29.3.9</a>, <a href="#7.29.3.10">7.29.3.10</a>,
34450 wcrtomb_s function, <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a> <a href="#7.29.6.1.1">7.29.6.1.1</a>, <a href="#7.30.1">7.30.1</a>
34451 wcscat function, <a href="#7.29.4.3.1">7.29.4.3.1</a> while statement, <a href="#6.8.5.1">6.8.5.1</a>
34452 wcscat_s function, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a> white space, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#7.4.1.10">7.4.1.10</a>,
34454 wcscmp function, <a href="#7.29.4.4.1">7.29.4.4.1</a>, <a href="#7.29.4.4.4">7.29.4.4.4</a> white-space characters, <a href="#6.4">6.4</a>
34455 wcscoll function, <a href="#7.29.4.4.2">7.29.4.4.2</a>, <a href="#7.29.4.4.4">7.29.4.4.4</a> wide character, <a href="#3.7.3">3.7.3</a>
34456 wcscpy function, <a href="#7.29.4.2.1">7.29.4.2.1</a> case mapping functions, <a href="#7.30.3.1">7.30.3.1</a>
34457 wcscpy_s function, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a> extensible, <a href="#7.30.3.2">7.30.3.2</a>
34458 wcscspn function, <a href="#7.29.4.5.2">7.29.4.5.2</a> classification functions, <a href="#7.30.2.1">7.30.2.1</a>
34459 wcsftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.29.5.1">7.29.5.1</a> extensible, <a href="#7.30.2.2">7.30.2.2</a>
34460 wcslen function, <a href="#7.29.4.6.1">7.29.4.6.1</a> constant, <a href="#6.4.4.4">6.4.4.4</a>
34461 wcsncat function, <a href="#7.29.4.3.2">7.29.4.3.2</a> formatted input/output functions, <a href="#7.29.2">7.29.2</a>,
34463 wcsncmp function, <a href="#7.29.4.4.3">7.29.4.4.3</a> input functions, <a href="#7.21.1">7.21.1</a>
34464 wcsncpy function, <a href="#7.29.4.2.2">7.29.4.2.2</a> input/output functions, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.3">7.29.3</a>
34465 wcsncpy_s function, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a> output functions, <a href="#7.21.1">7.21.1</a>
34466 wcsnlen_s function, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a> single-byte conversion functions, <a href="#7.29.6.1">7.29.6.1</a>
34467 wcspbrk function, <a href="#7.29.4.5.3">7.29.4.5.3</a> wide character classification and mapping utilities
34468 wcsrchr function, <a href="#7.29.4.5.4">7.29.4.5.4</a> header, <a href="#7.30">7.30</a>, <a href="#7.31.17">7.31.17</a>
34469 wcsrtombs function, <a href="#7.29.6.4.2">7.29.6.4.2</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a> wide string, <a href="#7.1.1">7.1.1</a>
34470 wcsrtombs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a> wide string comparison functions, <a href="#7.29.4.4">7.29.4.4</a>
34471 wcsspn function, <a href="#7.29.4.5.5">7.29.4.5.5</a> wide string concatenation functions, <a href="#7.29.4.3">7.29.4.3</a>,
34473 wcstod function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a> wide string copying functions, <a href="#7.29.4.2">7.29.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a>
34475 wcstof function, <a href="#7.29.4.1.1">7.29.4.1.1</a> wide string miscellaneous functions, <a href="#7.29.4.6">7.29.4.6</a>,
34477 wcstok function, <a href="#7.29.4.5.7">7.29.4.5.7</a> wide string numeric conversion functions, <a href="#7.8.2.4">7.8.2.4</a>,
34479 wcstol function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.29.2.2">7.29.2.2</a>, wide string search functions, <a href="#7.29.4.5">7.29.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a>
34482 <!--page 701 -->
34485 wint_t type, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.1">7.29.2.1</a>,
34494 wprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.2.9">7.29.2.9</a>, <a href="#7.29.2.11">7.29.2.11</a>,
34497 wscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.29.2.10">7.29.2.10</a>, <a href="#7.29.2.12">7.29.2.12</a>,
34503 </pre>
34505 </body></html>