</pre>
<a name="Contents" href="#Contents"><h2>Contents</h2></a>
-<pre>
-Foreword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xiii
-Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii
-1. Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
-2. Normative references . . . . . . . . . . . . . . . . . . . . . . . 2
-3. Terms, definitions, and symbols . . . . . . . . . . . . . . . . . . . 3
-4. Conformance . . . . . . . . . . . . . . . . . . . . . . . . . . 8
-5. Environment . . . . . . . . . . . . . . . . . . . . . . . . . . 10
- 5.1 Conceptual models . . . . . . . . . . . . . . . . . . . . . 10
- 5.1.1 Translation environment . . . . . . . . . . . . . . . . 10
- 5.1.2 Execution environments . . . . . . . . . . . . . . . . 12
- 5.2 Environmental considerations . . . . . . . . . . . . . . . . . 22
- 5.2.1 Character sets . . . . . . . . . . . . . . . . . . . . 22
- 5.2.2 Character display semantics . . . . . . . . . . . . . . 24
- 5.2.3 Signals and interrupts . . . . . . . . . . . . . . . . . 25
- 5.2.4 Environmental limits . . . . . . . . . . . . . . . . . 25
-6. Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
- 6.1 Notation . . . . . . . . . . . . . . . . . . . . . . . . . . 35
- 6.2 Concepts . . . . . . . . . . . . . . . . . . . . . . . . . 35
- 6.2.1 Scopes of identifiers . . . . . . . . . . . . . . . . . 35
- 6.2.2 Linkages of identifiers . . . . . . . . . . . . . . . . . 36
- 6.2.3 Name spaces of identifiers . . . . . . . . . . . . . . . 37
- 6.2.4 Storage durations of objects . . . . . . . . . . . . . . 38
- 6.2.5 Types . . . . . . . . . . . . . . . . . . . . . . . 39
- 6.2.6 Representations of types . . . . . . . . . . . . . . . . 44
- 6.2.7 Compatible type and composite type . . . . . . . . . . . 47
- 6.2.8 Alignment of objects . . . . . . . . . . . . . . . . . 48
- 6.3 Conversions . . . . . . . . . . . . . . . . . . . . . . . . 50
- 6.3.1 Arithmetic operands . . . . . . . . . . . . . . . . . 50
- 6.3.2 Other operands . . . . . . . . . . . . . . . . . . . 54
- 6.4 Lexical elements . . . . . . . . . . . . . . . . . . . . . . 57
- 6.4.1 Keywords . . . . . . . . . . . . . . . . . . . . . . 58
- 6.4.2 Identifiers . . . . . . . . . . . . . . . . . . . . . . 59
- 6.4.3 Universal character names . . . . . . . . . . . . . . . 61
- 6.4.4 Constants . . . . . . . . . . . . . . . . . . . . . . 62
- 6.4.5 String literals . . . . . . . . . . . . . . . . . . . . 70
- 6.4.6 Punctuators . . . . . . . . . . . . . . . . . . . . . 72
- 6.4.7 Header names . . . . . . . . . . . . . . . . . . . . 73
- 6.4.8 Preprocessing numbers . . . . . . . . . . . . . . . . 74
- 6.4.9 Comments . . . . . . . . . . . . . . . . . . . . . 75
+<ul>
+<li><a href="#Foreword">Foreword</a>
+<li><a href="#Introduction">Introduction</a>
+<li><a href="#1">1. Scope</a>
+<li><a href="#2">2. Normative references</a>
+<li><a href="#3">3. Terms, definitions, and symbols</a>
+<li><a href="#4">4. Conformance</a>
+<li><a href="#5">5. Environment</a>
+<ul>
+<li><a href="#5.1"> 5.1 Conceptual models</a>
+<ul>
+<li><a href="#5.1.1"> 5.1.1 Translation environment</a>
+<li><a href="#5.1.2"> 5.1.2 Execution environments</a>
+</ul>
+<li><a href="#5.2"> 5.2 Environmental considerations</a>
+<ul>
+<li><a href="#5.2.1"> 5.2.1 Character sets</a>
+<li><a href="#5.2.2"> 5.2.2 Character display semantics</a>
+<li><a href="#5.2.3"> 5.2.3 Signals and interrupts</a>
+<li><a href="#5.2.4"> 5.2.4 Environmental limits</a>
+</ul>
+</ul>
+<li><a href="#6">6. Language</a>
+<ul>
+<li><a href="#6.1"> 6.1 Notation</a>
+<li><a href="#6.2"> 6.2 Concepts</a>
+<ul>
+<li><a href="#6.2.1"> 6.2.1 Scopes of identifiers</a>
+<li><a href="#6.2.2"> 6.2.2 Linkages of identifiers</a>
+<li><a href="#6.2.3"> 6.2.3 Name spaces of identifiers</a>
+<li><a href="#6.2.4"> 6.2.4 Storage durations of objects</a>
+<li><a href="#6.2.5"> 6.2.5 Types</a>
+<li><a href="#6.2.6"> 6.2.6 Representations of types</a>
+<li><a href="#6.2.7"> 6.2.7 Compatible type and composite type</a>
+<li><a href="#6.2.8"> 6.2.8 Alignment of objects</a>
+</ul>
+<li><a href="#6.3"> 6.3 Conversions</a>
+<ul>
+<li><a href="#6.3.1"> 6.3.1 Arithmetic operands</a>
+<li><a href="#6.3.2"> 6.3.2 Other operands</a>
+</ul>
+<li><a href="#6.4"> 6.4 Lexical elements</a>
+<ul>
+<li><a href="#6.4.1"> 6.4.1 Keywords</a>
+<li><a href="#6.4.2"> 6.4.2 Identifiers</a>
+<li><a href="#6.4.3"> 6.4.3 Universal character names</a>
+<li><a href="#6.4.4"> 6.4.4 Constants</a>
+<li><a href="#6.4.5"> 6.4.5 String literals</a>
+<li><a href="#6.4.6"> 6.4.6 Punctuators</a>
+<li><a href="#6.4.7"> 6.4.7 Header names</a>
+<li><a href="#6.4.8"> 6.4.8 Preprocessing numbers</a>
+<li><a href="#6.4.9"> 6.4.9 Comments</a>
<!--page 4 indent -1-->
- 6.5 Expressions . . . . . . . . . . . . . . . . . . . . . . . . 76
- 6.5.1 Primary expressions . . . . . . . . . . . . . . . . . 78
- 6.5.2 Postfix operators . . . . . . . . . . . . . . . . . . . 79
- 6.5.3 Unary operators . . . . . . . . . . . . . . . . . . . 88
- 6.5.4 Cast operators . . . . . . . . . . . . . . . . . . . . 91
- 6.5.5 Multiplicative operators . . . . . . . . . . . . . . . . 92
- 6.5.6 Additive operators . . . . . . . . . . . . . . . . . . 92
- 6.5.7 Bitwise shift operators . . . . . . . . . . . . . . . . . 94
- 6.5.8 Relational operators . . . . . . . . . . . . . . . . . . 95
- 6.5.9 Equality operators . . . . . . . . . . . . . . . . . . 96
- 6.5.10 Bitwise AND operator . . . . . . . . . . . . . . . . . 97
- 6.5.11 Bitwise exclusive OR operator . . . . . . . . . . . . . 98
- 6.5.12 Bitwise inclusive OR operator . . . . . . . . . . . . . . 98
- 6.5.13 Logical AND operator . . . . . . . . . . . . . . . . . 99
- 6.5.14 Logical OR operator . . . . . . . . . . . . . . . . . 99
- 6.5.15 Conditional operator . . . . . . . . . . . . . . . . . 100
- 6.5.16 Assignment operators . . . . . . . . . . . . . . . . . 101
- 6.5.17 Comma operator . . . . . . . . . . . . . . . . . . . 104
- 6.6 Constant expressions . . . . . . . . . . . . . . . . . . . . . 105
- 6.7 Declarations . . . . . . . . . . . . . . . . . . . . . . . . 107
- 6.7.1 Storage-class specifiers . . . . . . . . . . . . . . . . 108
- 6.7.2 Type specifiers . . . . . . . . . . . . . . . . . . . . 109
- 6.7.3 Type qualifiers . . . . . . . . . . . . . . . . . . . . 120
- 6.7.4 Function specifiers . . . . . . . . . . . . . . . . . . 124
- 6.7.5 Alignment specifier . . . . . . . . . . . . . . . . . . 126
- 6.7.6 Declarators . . . . . . . . . . . . . . . . . . . . . 127
- 6.7.7 Type names . . . . . . . . . . . . . . . . . . . . . 135
- 6.7.8 Type definitions . . . . . . . . . . . . . . . . . . . 136
- 6.7.9 Initialization . . . . . . . . . . . . . . . . . . . . 138
- 6.7.10 Static assertions . . . . . . . . . . . . . . . . . . . 144
- 6.8 Statements and blocks . . . . . . . . . . . . . . . . . . . . 145
- 6.8.1 Labeled statements . . . . . . . . . . . . . . . . . . 145
- 6.8.2 Compound statement . . . . . . . . . . . . . . . . . 146
- 6.8.3 Expression and null statements . . . . . . . . . . . . . 146
- 6.8.4 Selection statements . . . . . . . . . . . . . . . . . 147
- 6.8.5 Iteration statements . . . . . . . . . . . . . . . . . . 149
- 6.8.6 Jump statements . . . . . . . . . . . . . . . . . . . 150
- 6.9 External definitions . . . . . . . . . . . . . . . . . . . . . 154
- 6.9.1 Function definitions . . . . . . . . . . . . . . . . . . 155
- 6.9.2 External object definitions . . . . . . . . . . . . . . . 157
- 6.10 Preprocessing directives . . . . . . . . . . . . . . . . . . . 159
- 6.10.1 Conditional inclusion . . . . . . . . . . . . . . . . . 161
- 6.10.2 Source file inclusion . . . . . . . . . . . . . . . . . 163
- 6.10.3 Macro replacement . . . . . . . . . . . . . . . . . . 165
+</ul>
+<li><a href="#6.5"> 6.5 Expressions</a>
+<ul>
+<li><a href="#6.5.1"> 6.5.1 Primary expressions</a>
+<li><a href="#6.5.2"> 6.5.2 Postfix operators</a>
+<li><a href="#6.5.3"> 6.5.3 Unary operators</a>
+<li><a href="#6.5.4"> 6.5.4 Cast operators</a>
+<li><a href="#6.5.5"> 6.5.5 Multiplicative operators</a>
+<li><a href="#6.5.6"> 6.5.6 Additive operators</a>
+<li><a href="#6.5.7"> 6.5.7 Bitwise shift operators</a>
+<li><a href="#6.5.8"> 6.5.8 Relational operators</a>
+<li><a href="#6.5.9"> 6.5.9 Equality operators</a>
+<li><a href="#6.5.10"> 6.5.10 Bitwise AND operator</a>
+<li><a href="#6.5.11"> 6.5.11 Bitwise exclusive OR operator</a>
+<li><a href="#6.5.12"> 6.5.12 Bitwise inclusive OR operator</a>
+<li><a href="#6.5.13"> 6.5.13 Logical AND operator</a>
+<li><a href="#6.5.14"> 6.5.14 Logical OR operator</a>
+<li><a href="#6.5.15"> 6.5.15 Conditional operator</a>
+<li><a href="#6.5.16"> 6.5.16 Assignment operators</a>
+<li><a href="#6.5.17"> 6.5.17 Comma operator</a>
+</ul>
+<li><a href="#6.6"> 6.6 Constant expressions</a>
+<li><a href="#6.7"> 6.7 Declarations</a>
+<ul>
+<li><a href="#6.7.1"> 6.7.1 Storage-class specifiers</a>
+<li><a href="#6.7.2"> 6.7.2 Type specifiers</a>
+<li><a href="#6.7.3"> 6.7.3 Type qualifiers</a>
+<li><a href="#6.7.4"> 6.7.4 Function specifiers</a>
+<li><a href="#6.7.5"> 6.7.5 Alignment specifier</a>
+<li><a href="#6.7.6"> 6.7.6 Declarators</a>
+<li><a href="#6.7.7"> 6.7.7 Type names</a>
+<li><a href="#6.7.8"> 6.7.8 Type definitions</a>
+<li><a href="#6.7.9"> 6.7.9 Initialization</a>
+<li><a href="#6.7.10"> 6.7.10 Static assertions</a>
+</ul>
+<li><a href="#6.8"> 6.8 Statements and blocks</a>
+<ul>
+<li><a href="#6.8.1"> 6.8.1 Labeled statements</a>
+<li><a href="#6.8.2"> 6.8.2 Compound statement</a>
+<li><a href="#6.8.3"> 6.8.3 Expression and null statements</a>
+<li><a href="#6.8.4"> 6.8.4 Selection statements</a>
+<li><a href="#6.8.5"> 6.8.5 Iteration statements</a>
+<li><a href="#6.8.6"> 6.8.6 Jump statements</a>
+</ul>
+<li><a href="#6.9"> 6.9 External definitions</a>
+<ul>
+<li><a href="#6.9.1"> 6.9.1 Function definitions</a>
+<li><a href="#6.9.2"> 6.9.2 External object definitions</a>
+</ul>
+<li><a href="#6.10"> 6.10 Preprocessing directives</a>
+<ul>
+<li><a href="#6.10.1"> 6.10.1 Conditional inclusion</a>
+<li><a href="#6.10.2"> 6.10.2 Source file inclusion</a>
+<li><a href="#6.10.3"> 6.10.3 Macro replacement</a>
<!--page 5 indent 0-->
- 6.10.4 Line control . . . . . . . . . . . . . . . . . . . . . 172
- 6.10.5 Error directive . . . . . . . . . . . . . . . . . . . . 173
- 6.10.6 Pragma directive . . . . . . . . . . . . . . . . . . . 173
- 6.10.7 Null directive . . . . . . . . . . . . . . . . . . . . 174
- 6.10.8 Predefined macro names . . . . . . . . . . . . . . . . 174
- 6.10.9 Pragma operator . . . . . . . . . . . . . . . . . . . 176
- 6.11 Future language directions . . . . . . . . . . . . . . . . . . 178
- 6.11.1 Floating types . . . . . . . . . . . . . . . . . . . . 178
- 6.11.2 Linkages of identifiers . . . . . . . . . . . . . . . . . 178
- 6.11.3 External names . . . . . . . . . . . . . . . . . . . 178
- 6.11.4 Character escape sequences . . . . . . . . . . . . . . 178
- 6.11.5 Storage-class specifiers . . . . . . . . . . . . . . . . 178
- 6.11.6 Function declarators . . . . . . . . . . . . . . . . . 178
- 6.11.7 Function definitions . . . . . . . . . . . . . . . . . . 178
- 6.11.8 Pragma directives . . . . . . . . . . . . . . . . . . 178
- 6.11.9 Predefined macro names . . . . . . . . . . . . . . . . 178
-7. Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
- 7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 179
- 7.1.1 Definitions of terms . . . . . . . . . . . . . . . . . . 179
- 7.1.2 Standard headers . . . . . . . . . . . . . . . . . . . 180
- 7.1.3 Reserved identifiers . . . . . . . . . . . . . . . . . . 181
- 7.1.4 Use of library functions . . . . . . . . . . . . . . . . 182
- 7.2 Diagnostics <assert.h> . . . . . . . . . . . . . . . . . . 185
- 7.2.1 Program diagnostics . . . . . . . . . . . . . . . . . 185
- 7.3 Complex arithmetic <complex.h> . . . . . . . . . . . . . . 187
- 7.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . 187
- 7.3.2 Conventions . . . . . . . . . . . . . . . . . . . . . 188
- 7.3.3 Branch cuts . . . . . . . . . . . . . . . . . . . . . 188
- 7.3.4 The CX_LIMITED_RANGE pragma . . . . . . . . . . . 188
- 7.3.5 Trigonometric functions . . . . . . . . . . . . . . . . 189
- 7.3.6 Hyperbolic functions . . . . . . . . . . . . . . . . . 191
- 7.3.7 Exponential and logarithmic functions . . . . . . . . . . 193
- 7.3.8 Power and absolute-value functions . . . . . . . . . . . 194
- 7.3.9 Manipulation functions . . . . . . . . . . . . . . . . 195
- 7.4 Character handling <ctype.h> . . . . . . . . . . . . . . . . 199
- 7.4.1 Character classification functions . . . . . . . . . . . . 199
- 7.4.2 Character case mapping functions . . . . . . . . . . . . 202
- 7.5 Errors <errno.h> . . . . . . . . . . . . . . . . . . . . . 204
- 7.6 Floating-point environment <fenv.h> . . . . . . . . . . . . . 205
- 7.6.1 The FENV_ACCESS pragma . . . . . . . . . . . . . . 207
- 7.6.2 Floating-point exceptions . . . . . . . . . . . . . . . 208
- 7.6.3 Rounding . . . . . . . . . . . . . . . . . . . . . . 211
- 7.6.4 Environment . . . . . . . . . . . . . . . . . . . . 212
- 7.7 Characteristics of floating types <float.h> . . . . . . . . . . . 215
+<li><a href="#6.10.4"> 6.10.4 Line control</a>
+<li><a href="#6.10.5"> 6.10.5 Error directive</a>
+<li><a href="#6.10.6"> 6.10.6 Pragma directive</a>
+<li><a href="#6.10.7"> 6.10.7 Null directive</a>
+<li><a href="#6.10.8"> 6.10.8 Predefined macro names</a>
+<li><a href="#6.10.9"> 6.10.9 Pragma operator</a>
+</ul>
+<li><a href="#6.11"> 6.11 Future language directions</a>
+<ul>
+<li><a href="#6.11.1"> 6.11.1 Floating types</a>
+<li><a href="#6.11.2"> 6.11.2 Linkages of identifiers</a>
+<li><a href="#6.11.3"> 6.11.3 External names</a>
+<li><a href="#6.11.4"> 6.11.4 Character escape sequences</a>
+<li><a href="#6.11.5"> 6.11.5 Storage-class specifiers</a>
+<li><a href="#6.11.6"> 6.11.6 Function declarators</a>
+<li><a href="#6.11.7"> 6.11.7 Function definitions</a>
+<li><a href="#6.11.8"> 6.11.8 Pragma directives</a>
+<li><a href="#6.11.9"> 6.11.9 Predefined macro names</a>
+</ul>
+</ul>
+<li><a href="#7">7. Library</a>
+<ul>
+<li><a href="#7.1"> 7.1 Introduction</a>
+<ul>
+<li><a href="#7.1.1"> 7.1.1 Definitions of terms</a>
+<li><a href="#7.1.2"> 7.1.2 Standard headers</a>
+<li><a href="#7.1.3"> 7.1.3 Reserved identifiers</a>
+<li><a href="#7.1.4"> 7.1.4 Use of library functions</a>
+</ul>
+<li><a href="#7.2"> 7.2 Diagnostics <assert.h></a>
+<ul>
+<li><a href="#7.2.1"> 7.2.1 Program diagnostics</a>
+</ul>
+<li><a href="#7.3"> 7.3 Complex arithmetic <complex.h></a>
+<ul>
+<li><a href="#7.3.1"> 7.3.1 Introduction</a>
+<li><a href="#7.3.2"> 7.3.2 Conventions</a>
+<li><a href="#7.3.3"> 7.3.3 Branch cuts</a>
+<li><a href="#7.3.4"> 7.3.4 The CX_LIMITED_RANGE pragma</a>
+<li><a href="#7.3.5"> 7.3.5 Trigonometric functions</a>
+<li><a href="#7.3.6"> 7.3.6 Hyperbolic functions</a>
+<li><a href="#7.3.7"> 7.3.7 Exponential and logarithmic functions</a>
+<li><a href="#7.3.8"> 7.3.8 Power and absolute-value functions</a>
+<li><a href="#7.3.9"> 7.3.9 Manipulation functions</a>
+</ul>
+<li><a href="#7.4"> 7.4 Character handling <ctype.h></a>
+<ul>
+<li><a href="#7.4.1"> 7.4.1 Character classification functions</a>
+<li><a href="#7.4.2"> 7.4.2 Character case mapping functions</a>
+</ul>
+<li><a href="#7.5"> 7.5 Errors <errno.h></a>
+<li><a href="#7.6"> 7.6 Floating-point environment <fenv.h></a>
+<ul>
+<li><a href="#7.6.1"> 7.6.1 The FENV_ACCESS pragma</a>
+<li><a href="#7.6.2"> 7.6.2 Floating-point exceptions</a>
+<li><a href="#7.6.3"> 7.6.3 Rounding</a>
+<li><a href="#7.6.4"> 7.6.4 Environment</a>
+</ul>
+<li><a href="#7.7"> 7.7 Characteristics of floating types <float.h></a>
<!--page 6 indent -1-->
- 7.8 Format conversion of integer types <inttypes.h> . . . . . . . . 216
- 7.8.1 Macros for format specifiers . . . . . . . . . . . . . . 216
- 7.8.2 Functions for greatest-width integer types . . . . . . . . . 217
- 7.9 Alternative spellings <iso646.h> . . . . . . . . . . . . . . . 220
- 7.10 Sizes of integer types <limits.h> . . . . . . . . . . . . . . 221
- 7.11 Localization <locale.h> . . . . . . . . . . . . . . . . . . 222
- 7.11.1 Locale control . . . . . . . . . . . . . . . . . . . . 223
- 7.11.2 Numeric formatting convention inquiry . . . . . . . . . . 224
- 7.12 Mathematics <math.h> . . . . . . . . . . . . . . . . . . . 230
- 7.12.1 Treatment of error conditions . . . . . . . . . . . . . . 232
- 7.12.2 The FP_CONTRACT pragma . . . . . . . . . . . . . . 234
- 7.12.3 Classification macros . . . . . . . . . . . . . . . . . 234
- 7.12.4 Trigonometric functions . . . . . . . . . . . . . . . . 237
- 7.12.5 Hyperbolic functions . . . . . . . . . . . . . . . . . 239
- 7.12.6 Exponential and logarithmic functions . . . . . . . . . . 241
- 7.12.7 Power and absolute-value functions . . . . . . . . . . . 246
- 7.12.8 Error and gamma functions . . . . . . . . . . . . . . . 248
- 7.12.9 Nearest integer functions . . . . . . . . . . . . . . . . 250
- 7.12.10 Remainder functions . . . . . . . . . . . . . . . . . 253
- 7.12.11 Manipulation functions . . . . . . . . . . . . . . . . 254
- 7.12.12 Maximum, minimum, and positive difference functions . . . 256
- 7.12.13 Floating multiply-add . . . . . . . . . . . . . . . . . 257
- 7.12.14 Comparison macros . . . . . . . . . . . . . . . . . . 258
- 7.13 Nonlocal jumps <setjmp.h> . . . . . . . . . . . . . . . . 261
- 7.13.1 Save calling environment . . . . . . . . . . . . . . . 261
- 7.13.2 Restore calling environment . . . . . . . . . . . . . . 262
- 7.14 Signal handling <signal.h> . . . . . . . . . . . . . . . . . 264
- 7.14.1 Specify signal handling . . . . . . . . . . . . . . . . 265
- 7.14.2 Send signal . . . . . . . . . . . . . . . . . . . . . 266
- 7.15 Alignment <stdalign.h> . . . . . . . . . . . . . . . . . 267
- 7.16 Variable arguments <stdarg.h> . . . . . . . . . . . . . . . 268
- 7.16.1 Variable argument list access macros . . . . . . . . . . . 268
- 7.17 Atomics <stdatomic.h> . . . . . . . . . . . . . . . . . . 272
- 7.17.1 Introduction . . . . . . . . . . . . . . . . . . . . . 272
- 7.17.2 Initialization . . . . . . . . . . . . . . . . . . . . 273
- 7.17.3 Order and consistency . . . . . . . . . . . . . . . . . 274
- 7.17.4 Fences . . . . . . . . . . . . . . . . . . . . . . . 277
- 7.17.5 Lock-free property . . . . . . . . . . . . . . . . . . 278
- 7.17.6 Atomic integer and address types . . . . . . . . . . . . 279
- 7.17.7 Operations on atomic types . . . . . . . . . . . . . . . 281
- 7.17.8 Atomic flag type and operations . . . . . . . . . . . . . 284
- 7.18 Boolean type and values <stdbool.h> . . . . . . . . . . . . 286
- 7.19 Common definitions <stddef.h> . . . . . . . . . . . . . . . 287
- 7.20 Integer types <stdint.h> . . . . . . . . . . . . . . . . . . 289
+<li><a href="#7.8"> 7.8 Format conversion of integer types <inttypes.h></a>
+<ul>
+<li><a href="#7.8.1"> 7.8.1 Macros for format specifiers</a>
+<li><a href="#7.8.2"> 7.8.2 Functions for greatest-width integer types</a>
+</ul>
+<li><a href="#7.9"> 7.9 Alternative spellings <iso646.h></a>
+<li><a href="#7.10"> 7.10 Sizes of integer types <limits.h></a>
+<li><a href="#7.11"> 7.11 Localization <locale.h></a>
+<ul>
+<li><a href="#7.11.1"> 7.11.1 Locale control</a>
+<li><a href="#7.11.2"> 7.11.2 Numeric formatting convention inquiry</a>
+</ul>
+<li><a href="#7.12"> 7.12 Mathematics <math.h></a>
+<ul>
+<li><a href="#7.12.1"> 7.12.1 Treatment of error conditions</a>
+<li><a href="#7.12.2"> 7.12.2 The FP_CONTRACT pragma</a>
+<li><a href="#7.12.3"> 7.12.3 Classification macros</a>
+<li><a href="#7.12.4"> 7.12.4 Trigonometric functions</a>
+<li><a href="#7.12.5"> 7.12.5 Hyperbolic functions</a>
+<li><a href="#7.12.6"> 7.12.6 Exponential and logarithmic functions</a>
+<li><a href="#7.12.7"> 7.12.7 Power and absolute-value functions</a>
+<li><a href="#7.12.8"> 7.12.8 Error and gamma functions</a>
+<li><a href="#7.12.9"> 7.12.9 Nearest integer functions</a>
+<li><a href="#7.12.10"> 7.12.10 Remainder functions</a>
+<li><a href="#7.12.11"> 7.12.11 Manipulation functions</a>
+<li><a href="#7.12.12"> 7.12.12 Maximum, minimum, and positive difference functions</a>
+<li><a href="#7.12.13"> 7.12.13 Floating multiply-add</a>
+<li><a href="#7.12.14"> 7.12.14 Comparison macros</a>
+</ul>
+<li><a href="#7.13"> 7.13 Nonlocal jumps <setjmp.h></a>
+<ul>
+<li><a href="#7.13.1"> 7.13.1 Save calling environment</a>
+<li><a href="#7.13.2"> 7.13.2 Restore calling environment</a>
+</ul>
+<li><a href="#7.14"> 7.14 Signal handling <signal.h></a>
+<ul>
+<li><a href="#7.14.1"> 7.14.1 Specify signal handling</a>
+<li><a href="#7.14.2"> 7.14.2 Send signal</a>
+</ul>
+<li><a href="#7.15"> 7.15 Alignment <stdalign.h></a>
+<li><a href="#7.16"> 7.16 Variable arguments <stdarg.h></a>
+<ul>
+<li><a href="#7.16.1"> 7.16.1 Variable argument list access macros</a>
+</ul>
+<li><a href="#7.17"> 7.17 Atomics <stdatomic.h></a>
+<ul>
+<li><a href="#7.17.1"> 7.17.1 Introduction</a>
+<li><a href="#7.17.2"> 7.17.2 Initialization</a>
+<li><a href="#7.17.3"> 7.17.3 Order and consistency</a>
+<li><a href="#7.17.4"> 7.17.4 Fences</a>
+<li><a href="#7.17.5"> 7.17.5 Lock-free property</a>
+<li><a href="#7.17.6"> 7.17.6 Atomic integer and address types</a>
+<li><a href="#7.17.7"> 7.17.7 Operations on atomic types</a>
+<li><a href="#7.17.8"> 7.17.8 Atomic flag type and operations</a>
+</ul>
+<li><a href="#7.18"> 7.18 Boolean type and values <stdbool.h></a>
+<li><a href="#7.19"> 7.19 Common definitions <stddef.h></a>
+<li><a href="#7.20"> 7.20 Integer types <stdint.h></a>
<!--page 7 indent -1-->
- 7.20.1 Integer types . . . . . . . . . . . . . . . . . . . . 289
- 7.20.2 Limits of specified-width integer types . . . . . . . . . . 291
- 7.20.3 Limits of other integer types . . . . . . . . . . . . . . 293
- 7.20.4 Macros for integer constants . . . . . . . . . . . . . . 294
- 7.21 Input/output <stdio.h> . . . . . . . . . . . . . . . . . . 296
- 7.21.1 Introduction . . . . . . . . . . . . . . . . . . . . . 296
- 7.21.2 Streams . . . . . . . . . . . . . . . . . . . . . . 298
- 7.21.3 Files . . . . . . . . . . . . . . . . . . . . . . . . 300
- 7.21.4 Operations on files . . . . . . . . . . . . . . . . . . 302
- 7.21.5 File access functions . . . . . . . . . . . . . . . . . 304
- 7.21.6 Formatted input/output functions . . . . . . . . . . . . 309
- 7.21.7 Character input/output functions . . . . . . . . . . . . . 330
- 7.21.8 Direct input/output functions . . . . . . . . . . . . . . 334
- 7.21.9 File positioning functions . . . . . . . . . . . . . . . 335
- 7.21.10 Error-handling functions . . . . . . . . . . . . . . . . 338
- 7.22 General utilities <stdlib.h> . . . . . . . . . . . . . . . . 340
- 7.22.1 Numeric conversion functions . . . . . . . . . . . . . . 341
- 7.22.2 Pseudo-random sequence generation functions . . . . . . . 346
- 7.22.3 Memory management functions . . . . . . . . . . . . . 347
- 7.22.4 Communication with the environment . . . . . . . . . . 349
- 7.22.5 Searching and sorting utilities . . . . . . . . . . . . . . 353
- 7.22.6 Integer arithmetic functions . . . . . . . . . . . . . . 355
- 7.22.7 Multibyte/wide character conversion functions . . . . . . . 356
- 7.22.8 Multibyte/wide string conversion functions . . . . . . . . 358
- 7.23 String handling <string.h> . . . . . . . . . . . . . . . . . 360
- 7.23.1 String function conventions . . . . . . . . . . . . . . . 360
- 7.23.2 Copying functions . . . . . . . . . . . . . . . . . . 360
- 7.23.3 Concatenation functions . . . . . . . . . . . . . . . . 362
- 7.23.4 Comparison functions . . . . . . . . . . . . . . . . . 363
- 7.23.5 Search functions . . . . . . . . . . . . . . . . . . . 365
- 7.23.6 Miscellaneous functions . . . . . . . . . . . . . . . . 368
- 7.24 Type-generic math <tgmath.h> . . . . . . . . . . . . . . . 370
- 7.25 Threads <threads.h> . . . . . . . . . . . . . . . . . . . 373
- 7.25.1 Introduction . . . . . . . . . . . . . . . . . . . . . 373
- 7.25.2 Initialization functions . . . . . . . . . . . . . . . . . 375
- 7.25.3 Condition variable functions . . . . . . . . . . . . . . 375
- 7.25.4 Mutex functions . . . . . . . . . . . . . . . . . . . 377
- 7.25.5 Thread functions . . . . . . . . . . . . . . . . . . . 380
- 7.25.6 Thread-specific storage functions . . . . . . . . . . . . 382
- 7.25.7 Time functions . . . . . . . . . . . . . . . . . . . . 384
- 7.26 Date and time <time.h> . . . . . . . . . . . . . . . . . . 385
- 7.26.1 Components of time . . . . . . . . . . . . . . . . . 385
- 7.26.2 Time manipulation functions . . . . . . . . . . . . . . 386
- 7.26.3 Time conversion functions . . . . . . . . . . . . . . . 388
+<ul>
+<li><a href="#7.20.1"> 7.20.1 Integer types</a>
+<li><a href="#7.20.2"> 7.20.2 Limits of specified-width integer types</a>
+<li><a href="#7.20.3"> 7.20.3 Limits of other integer types</a>
+<li><a href="#7.20.4"> 7.20.4 Macros for integer constants</a>
+</ul>
+<li><a href="#7.21"> 7.21 Input/output <stdio.h></a>
+<ul>
+<li><a href="#7.21.1"> 7.21.1 Introduction</a>
+<li><a href="#7.21.2"> 7.21.2 Streams</a>
+<li><a href="#7.21.3"> 7.21.3 Files</a>
+<li><a href="#7.21.4"> 7.21.4 Operations on files</a>
+<li><a href="#7.21.5"> 7.21.5 File access functions</a>
+<li><a href="#7.21.6"> 7.21.6 Formatted input/output functions</a>
+<li><a href="#7.21.7"> 7.21.7 Character input/output functions</a>
+<li><a href="#7.21.8"> 7.21.8 Direct input/output functions</a>
+<li><a href="#7.21.9"> 7.21.9 File positioning functions</a>
+<li><a href="#7.21.10"> 7.21.10 Error-handling functions</a>
+</ul>
+<li><a href="#7.22"> 7.22 General utilities <stdlib.h></a>
+<ul>
+<li><a href="#7.22.1"> 7.22.1 Numeric conversion functions</a>
+<li><a href="#7.22.2"> 7.22.2 Pseudo-random sequence generation functions</a>
+<li><a href="#7.22.3"> 7.22.3 Memory management functions</a>
+<li><a href="#7.22.4"> 7.22.4 Communication with the environment</a>
+<li><a href="#7.22.5"> 7.22.5 Searching and sorting utilities</a>
+<li><a href="#7.22.6"> 7.22.6 Integer arithmetic functions</a>
+<li><a href="#7.22.7"> 7.22.7 Multibyte/wide character conversion functions</a>
+<li><a href="#7.22.8"> 7.22.8 Multibyte/wide string conversion functions</a>
+</ul>
+<li><a href="#7.23"> 7.23 String handling <string.h></a>
+<ul>
+<li><a href="#7.23.1"> 7.23.1 String function conventions</a>
+<li><a href="#7.23.2"> 7.23.2 Copying functions</a>
+<li><a href="#7.23.3"> 7.23.3 Concatenation functions</a>
+<li><a href="#7.23.4"> 7.23.4 Comparison functions</a>
+<li><a href="#7.23.5"> 7.23.5 Search functions</a>
+<li><a href="#7.23.6"> 7.23.6 Miscellaneous functions</a>
+</ul>
+<li><a href="#7.24"> 7.24 Type-generic math <tgmath.h></a>
+<li><a href="#7.25"> 7.25 Threads <threads.h></a>
+<ul>
+<li><a href="#7.25.1"> 7.25.1 Introduction</a>
+<li><a href="#7.25.2"> 7.25.2 Initialization functions</a>
+<li><a href="#7.25.3"> 7.25.3 Condition variable functions</a>
+<li><a href="#7.25.4"> 7.25.4 Mutex functions</a>
+<li><a href="#7.25.5"> 7.25.5 Thread functions</a>
+<li><a href="#7.25.6"> 7.25.6 Thread-specific storage functions</a>
+<li><a href="#7.25.7"> 7.25.7 Time functions</a>
+</ul>
+<li><a href="#7.26"> 7.26 Date and time <time.h></a>
+<ul>
+<li><a href="#7.26.1"> 7.26.1 Components of time</a>
+<li><a href="#7.26.2"> 7.26.2 Time manipulation functions</a>
+<li><a href="#7.26.3"> 7.26.3 Time conversion functions</a>
<!--page 8 indent -1-->
- 7.27 Unicode utilities <uchar.h> . . . . . . . . . . . . . . . . . 395
- 7.27.1 Restartable multibyte/wide character conversion functions . . 395
- 7.28 Extended multibyte and wide character utilities <wchar.h> . . . . . 399
- 7.28.1 Introduction . . . . . . . . . . . . . . . . . . . . . 399
- 7.28.2 Formatted wide character input/output functions . . . . . . 400
- 7.28.3 Wide character input/output functions . . . . . . . . . . 418
- 7.28.4 General wide string utilities . . . . . . . . . . . . . . 422
- 7.28.4.1 Wide string numeric conversion functions . . . . . 423
- 7.28.4.2 Wide string copying functions . . . . . . . . . . 427
- 7.28.4.3 Wide string concatenation functions . . . . . . . 429
- 7.28.4.4 Wide string comparison functions . . . . . . . . 430
- 7.28.4.5 Wide string search functions . . . . . . . . . . 432
- 7.28.4.6 Miscellaneous functions . . . . . . . . . . . . 436
- 7.28.5 Wide character time conversion functions . . . . . . . . . 436
- 7.28.6 Extended multibyte/wide character conversion utilities . . . . 437
- 7.28.6.1 Single-byte/wide character conversion functions . . . 438
- 7.28.6.2 Conversion state functions . . . . . . . . . . . 438
- 7.28.6.3 Restartable multibyte/wide character conversion
- functions . . . . . . . . . . . . . . . . . . 439
- 7.28.6.4 Restartable multibyte/wide string conversion
- functions . . . . . . . . . . . . . . . . . . 441
- 7.29 Wide character classification and mapping utilities <wctype.h> . . . 444
- 7.29.1 Introduction . . . . . . . . . . . . . . . . . . . . . 444
- 7.29.2 Wide character classification utilities . . . . . . . . . . . 445
- 7.29.2.1 Wide character classification functions . . . . . . 445
- 7.29.2.2 Extensible wide character classification
- functions . . . . . . . . . . . . . . . . . . 448
- 7.29.3 Wide character case mapping utilities . . . . . . . . . . . 450
- 7.29.3.1 Wide character case mapping functions . . . . . . 450
- 7.29.3.2 Extensible wide character case mapping
- functions . . . . . . . . . . . . . . . . . . 450
- 7.30 Future library directions . . . . . . . . . . . . . . . . . . . 452
- 7.30.1 Complex arithmetic <complex.h> . . . . . . . . . . . 452
- 7.30.2 Character handling <ctype.h> . . . . . . . . . . . . 452
- 7.30.3 Errors <errno.h> . . . . . . . . . . . . . . . . . 452
- 7.30.4 Format conversion of integer types <inttypes.h> . . . . 452
- 7.30.5 Localization <locale.h> . . . . . . . . . . . . . . 452
- 7.30.6 Signal handling <signal.h> . . . . . . . . . . . . . 452
- 7.30.7 Boolean type and values <stdbool.h> . . . . . . . . . 452
- 7.30.8 Integer types <stdint.h> . . . . . . . . . . . . . . 452
- 7.30.9 Input/output <stdio.h> . . . . . . . . . . . . . . . 453
- 7.30.10 General utilities <stdlib.h> . . . . . . . . . . . . . 453
- 7.30.11 String handling <string.h> . . . . . . . . . . . . . 453
+</ul>
+<li><a href="#7.27"> 7.27 Unicode utilities <uchar.h></a>
+<ul>
+<li><a href="#7.27.1"> 7.27.1 Restartable multibyte/wide character conversion functions</a>
+</ul>
+<li><a href="#7.28"> 7.28 Extended multibyte and wide character utilities <wchar.h></a>
+<ul>
+<li><a href="#7.28.1"> 7.28.1 Introduction</a>
+<li><a href="#7.28.2"> 7.28.2 Formatted wide character input/output functions</a>
+<li><a href="#7.28.3"> 7.28.3 Wide character input/output functions</a>
+<li><a href="#7.28.4"> 7.28.4 General wide string utilities</a>
+<ul>
+<li><a href="#7.28.4.1"> 7.28.4.1 Wide string numeric conversion functions</a>
+<li><a href="#7.28.4.2"> 7.28.4.2 Wide string copying functions</a>
+<li><a href="#7.28.4.3"> 7.28.4.3 Wide string concatenation functions</a>
+<li><a href="#7.28.4.4"> 7.28.4.4 Wide string comparison functions</a>
+<li><a href="#7.28.4.5"> 7.28.4.5 Wide string search functions</a>
+<li><a href="#7.28.4.6"> 7.28.4.6 Miscellaneous functions</a>
+</ul>
+<li><a href="#7.28.5"> 7.28.5 Wide character time conversion functions</a>
+<li><a href="#7.28.6"> 7.28.6 Extended multibyte/wide character conversion utilities</a>
+<ul>
+<li><a href="#7.28.6.1"> 7.28.6.1 Single-byte/wide character conversion functions</a>
+<li><a href="#7.28.6.2"> 7.28.6.2 Conversion state functions</a>
+<li><a href="#7.28.6.3"> 7.28.6.3 Restartable multibyte/wide character conversion functions</a>
+<li><a href="#7.28.6.4"> 7.28.6.4 Restartable multibyte/wide string conversion functions</a>
+</ul>
+</ul>
+<li><a href="#7.29"> 7.29 Wide character classification and mapping utilities <wctype.h></a>
+<ul>
+<li><a href="#7.29.1"> 7.29.1 Introduction</a>
+<li><a href="#7.29.2"> 7.29.2 Wide character classification utilities</a>
+<ul>
+<li><a href="#7.29.2.1"> 7.29.2.1 Wide character classification functions</a>
+<li><a href="#7.29.2.2"> 7.29.2.2 Extensible wide character classification functions</a>
+</ul>
+<li><a href="#7.29.3"> 7.29.3 Wide character case mapping utilities</a>
+<ul>
+<li><a href="#7.29.3.1"> 7.29.3.1 Wide character case mapping functions</a>
+<li><a href="#7.29.3.2"> 7.29.3.2 Extensible wide character case mapping functions</a>
+</ul>
+</ul>
+<li><a href="#7.30"> 7.30 Future library directions</a>
+<ul>
+<li><a href="#7.30.1"> 7.30.1 Complex arithmetic <complex.h></a>
+<li><a href="#7.30.2"> 7.30.2 Character handling <ctype.h></a>
+<li><a href="#7.30.3"> 7.30.3 Errors <errno.h></a>
+<li><a href="#7.30.4"> 7.30.4 Format conversion of integer types <inttypes.h></a>
+<li><a href="#7.30.5"> 7.30.5 Localization <locale.h></a>
+<li><a href="#7.30.6"> 7.30.6 Signal handling <signal.h></a>
+<li><a href="#7.30.7"> 7.30.7 Boolean type and values <stdbool.h></a>
+<li><a href="#7.30.8"> 7.30.8 Integer types <stdint.h></a>
+<li><a href="#7.30.9"> 7.30.9 Input/output <stdio.h></a>
+<li><a href="#7.30.10"> 7.30.10 General utilities <stdlib.h></a>
+<li><a href="#7.30.11"> 7.30.11 String handling <string.h></a>
<!--page 9 indent 0-->
- 7.30.12 Extended multibyte and wide character utilities
- <wchar.h> . . . . . . . . . . . . . . . . . . . . 453
- 7.30.13 Wide character classification and mapping utilities
- <wctype.h> . . . . . . . . . . . . . . . . . . . . 453
-Annex A (informative) Language syntax summary . . . . . . . . . . . . 454
- A.1 Lexical grammar . . . . . . . . . . . . . . . . . . . . . . 454
- A.2 Phrase structure grammar . . . . . . . . . . . . . . . . . . . 461
- A.3 Preprocessing directives . . . . . . . . . . . . . . . . . . . 469
-Annex B (informative) Library summary . . . . . . . . . . . . . . . . 471
- B.1 Diagnostics <assert.h> . . . . . . . . . . . . . . . . . . 471
- B.2 Complex <complex.h> . . . . . . . . . . . . . . . . . . . 471
- B.3 Character handling <ctype.h> . . . . . . . . . . . . . . . . 473
- B.4 Errors <errno.h> . . . . . . . . . . . . . . . . . . . . . 473
- B.5 Floating-point environment <fenv.h> . . . . . . . . . . . . . 473
- B.6 Characteristics of floating types <float.h> . . . . . . . . . . . 474
- B.7 Format conversion of integer types <inttypes.h> . . . . . . . . 474
- B.8 Alternative spellings <iso646.h> . . . . . . . . . . . . . . . 475
- B.9 Sizes of integer types <limits.h> . . . . . . . . . . . . . . 475
- B.10 Localization <locale.h> . . . . . . . . . . . . . . . . . . 475
- B.11 Mathematics <math.h> . . . . . . . . . . . . . . . . . . . 475
- B.12 Nonlocal jumps <setjmp.h> . . . . . . . . . . . . . . . . 480
- B.13 Signal handling <signal.h> . . . . . . . . . . . . . . . . . 480
- B.14 Alignment <stdalign.h> . . . . . . . . . . . . . . . . . 481
- B.15 Variable arguments <stdarg.h> . . . . . . . . . . . . . . . 481
- B.16 Atomics <stdatomic.h> . . . . . . . . . . . . . . . . . . 481
- B.17 Boolean type and values <stdbool.h> . . . . . . . . . . . . 483
- B.18 Common definitions <stddef.h> . . . . . . . . . . . . . . . 483
- B.19 Integer types <stdint.h> . . . . . . . . . . . . . . . . . . 483
- B.20 Input/output <stdio.h> . . . . . . . . . . . . . . . . . . 484
- B.21 General utilities <stdlib.h> . . . . . . . . . . . . . . . . 487
- B.22 String handling <string.h> . . . . . . . . . . . . . . . . . 489
- B.23 Type-generic math <tgmath.h> . . . . . . . . . . . . . . . 491
- B.24 Threads <threads.h> . . . . . . . . . . . . . . . . . . . 491
- B.25 Date and time <time.h> . . . . . . . . . . . . . . . . . . 492
- B.26 Unicode utilities <uchar.h> . . . . . . . . . . . . . . . . . 493
- B.27 Extended multibyte/wide character utilities <wchar.h> . . . . . . 493
- B.28 Wide character classification and mapping utilities <wctype.h> . . . 498
-Annex C (informative) Sequence points . . . . . . . . . . . . . . . . . 499
-Annex D (normative) Universal character names for identifiers . . . . . . . 500
- D.1 Ranges of characters allowed . . . . . . . . . . . . . . . . . 500
- D.2 Ranges of characters disallowed initially . . . . . . . . . . . . . 500
-Annex E (informative) Implementation limits . . . . . . . . . . . . . . 501
+<li><a href="#7.30.12"> 7.30.12 Extended multibyte and wide character utilities <wchar.h></a>
+<li><a href="#7.30.13"> 7.30.13 Wide character classification and mapping utilities <wctype.h></a>
+</ul>
+</ul>
+<li><a href="#A">Annex A (informative) Language syntax summary</a>
+<ul>
+<li><a href="#A.1"> A.1 Lexical grammar</a>
+<li><a href="#A.2"> A.2 Phrase structure grammar</a>
+<li><a href="#A.3"> A.3 Preprocessing directives</a>
+</ul>
+<li><a href="#B">Annex B (informative) Library summary</a>
+<ul>
+<li><a href="#B.1"> B.1 Diagnostics <assert.h></a>
+<li><a href="#B.2"> B.2 Complex <complex.h></a>
+<li><a href="#B.3"> B.3 Character handling <ctype.h></a>
+<li><a href="#B.4"> B.4 Errors <errno.h></a>
+<li><a href="#B.5"> B.5 Floating-point environment <fenv.h></a>
+<li><a href="#B.6"> B.6 Characteristics of floating types <float.h></a>
+<li><a href="#B.7"> B.7 Format conversion of integer types <inttypes.h></a>
+<li><a href="#B.8"> B.8 Alternative spellings <iso646.h></a>
+<li><a href="#B.9"> B.9 Sizes of integer types <limits.h></a>
+<li><a href="#B.10"> B.10 Localization <locale.h></a>
+<li><a href="#B.11"> B.11 Mathematics <math.h></a>
+<li><a href="#B.12"> B.12 Nonlocal jumps <setjmp.h></a>
+<li><a href="#B.13"> B.13 Signal handling <signal.h></a>
+<li><a href="#B.14"> B.14 Alignment <stdalign.h></a>
+<li><a href="#B.15"> B.15 Variable arguments <stdarg.h></a>
+<li><a href="#B.16"> B.16 Atomics <stdatomic.h></a>
+<li><a href="#B.17"> B.17 Boolean type and values <stdbool.h></a>
+<li><a href="#B.18"> B.18 Common definitions <stddef.h></a>
+<li><a href="#B.19"> B.19 Integer types <stdint.h></a>
+<li><a href="#B.20"> B.20 Input/output <stdio.h></a>
+<li><a href="#B.21"> B.21 General utilities <stdlib.h></a>
+<li><a href="#B.22"> B.22 String handling <string.h></a>
+<li><a href="#B.23"> B.23 Type-generic math <tgmath.h></a>
+<li><a href="#B.24"> B.24 Threads <threads.h></a>
+<li><a href="#B.25"> B.25 Date and time <time.h></a>
+<li><a href="#B.26"> B.26 Unicode utilities <uchar.h></a>
+<li><a href="#B.27"> B.27 Extended multibyte/wide character utilities <wchar.h></a>
+<li><a href="#B.28"> B.28 Wide character classification and mapping utilities <wctype.h></a>
+</ul>
+<li><a href="#C">Annex C (informative) Sequence points</a>
+<li><a href="#D">Annex D (normative) Universal character names for identifiers</a>
+<ul>
+<li><a href="#D.1"> D.1 Ranges of characters allowed</a>
+<li><a href="#D.2"> D.2 Ranges of characters disallowed initially</a>
+</ul>
+<li><a href="#E">Annex E (informative) Implementation limits</a>
<!--page 10 indent 0-->
-Annex F (normative) IEC 60559 floating-point arithmetic . . . . . . . . . . 503
- F.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 503
- F.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
- F.3 Operators and functions . . . . . . . . . . . . . . . . . . . 504
- F.4 Floating to integer conversion . . . . . . . . . . . . . . . . . 506
- F.5 Binary-decimal conversion . . . . . . . . . . . . . . . . . . 506
- F.6 The return statement . . . . . . . . . . . . . . . . . . . . 507
- F.7 Contracted expressions . . . . . . . . . . . . . . . . . . . . 507
- F.8 Floating-point environment . . . . . . . . . . . . . . . . . . 507
- F.9 Optimization . . . . . . . . . . . . . . . . . . . . . . . . 510
- F.10 Mathematics <math.h> . . . . . . . . . . . . . . . . . . . 513
- F.10.1 Trigonometric functions . . . . . . . . . . . . . . . . 514
- F.10.2 Hyperbolic functions . . . . . . . . . . . . . . . . . 516
- F.10.3 Exponential and logarithmic functions . . . . . . . . . . 516
- F.10.4 Power and absolute value functions . . . . . . . . . . . 520
- F.10.5 Error and gamma functions . . . . . . . . . . . . . . . 521
- F.10.6 Nearest integer functions . . . . . . . . . . . . . . . . 522
- F.10.7 Remainder functions . . . . . . . . . . . . . . . . . 524
- F.10.8 Manipulation functions . . . . . . . . . . . . . . . . 525
- F.10.9 Maximum, minimum, and positive difference functions . . . 526
- F.10.10 Floating multiply-add . . . . . . . . . . . . . . . . . 526
- F.10.11 Comparison macros . . . . . . . . . . . . . . . . . . 527
-Annex G (normative) IEC 60559-compatible complex arithmetic . . . . . . . 528
- G.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 528
- G.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
- G.3 Conventions . . . . . . . . . . . . . . . . . . . . . . . . 528
- G.4 Conversions . . . . . . . . . . . . . . . . . . . . . . . . 529
- G.4.1 Imaginary types . . . . . . . . . . . . . . . . . . . 529
- G.4.2 Real and imaginary . . . . . . . . . . . . . . . . . . 529
- G.4.3 Imaginary and complex . . . . . . . . . . . . . . . . 529
- G.5 Binary operators . . . . . . . . . . . . . . . . . . . . . . 529
- G.5.1 Multiplicative operators . . . . . . . . . . . . . . . . 530
- G.5.2 Additive operators . . . . . . . . . . . . . . . . . . 533
- G.6 Complex arithmetic <complex.h> . . . . . . . . . . . . . . 533
- G.6.1 Trigonometric functions . . . . . . . . . . . . . . . . 535
- G.6.2 Hyperbolic functions . . . . . . . . . . . . . . . . . 535
- G.6.3 Exponential and logarithmic functions . . . . . . . . . . 539
- G.6.4 Power and absolute-value functions . . . . . . . . . . . 540
- G.7 Type-generic math <tgmath.h> . . . . . . . . . . . . . . . 541
-Annex H (informative) Language independent arithmetic . . . . . . . . . . 542
- H.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 542
- H.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
- H.3 Notification . . . . . . . . . . . . . . . . . . . . . . . . 546
+<li><a href="#F">Annex F (normative) IEC 60559 floating-point arithmetic</a>
+<ul>
+<li><a href="#F.1"> F.1 Introduction</a>
+<li><a href="#F.2"> F.2 Types</a>
+<li><a href="#F.3"> F.3 Operators and functions</a>
+<li><a href="#F.4"> F.4 Floating to integer conversion</a>
+<li><a href="#F.5"> F.5 Binary-decimal conversion</a>
+<li><a href="#F.6"> F.6 The return statement</a>
+<li><a href="#F.7"> F.7 Contracted expressions</a>
+<li><a href="#F.8"> F.8 Floating-point environment</a>
+<li><a href="#F.9"> F.9 Optimization</a>
+<li><a href="#F.10"> F.10 Mathematics <math.h></a>
+<ul>
+<li><a href="#F.10.1"> F.10.1 Trigonometric functions</a>
+<li><a href="#F.10.2"> F.10.2 Hyperbolic functions</a>
+<li><a href="#F.10.3"> F.10.3 Exponential and logarithmic functions</a>
+<li><a href="#F.10.4"> F.10.4 Power and absolute value functions</a>
+<li><a href="#F.10.5"> F.10.5 Error and gamma functions</a>
+<li><a href="#F.10.6"> F.10.6 Nearest integer functions</a>
+<li><a href="#F.10.7"> F.10.7 Remainder functions</a>
+<li><a href="#F.10.8"> F.10.8 Manipulation functions</a>
+<li><a href="#F.10.9"> F.10.9 Maximum, minimum, and positive difference functions</a>
+<li><a href="#F.10.10"> F.10.10 Floating multiply-add</a>
+<li><a href="#F.10.11"> F.10.11 Comparison macros</a>
+</ul>
+</ul>
+<li><a href="#G">Annex G (normative) IEC 60559-compatible complex arithmetic</a>
+<ul>
+<li><a href="#G.1"> G.1 Introduction</a>
+<li><a href="#G.2"> G.2 Types</a>
+<li><a href="#G.3"> G.3 Conventions</a>
+<li><a href="#G.4"> G.4 Conversions</a>
+<ul>
+<li><a href="#G.4.1"> G.4.1 Imaginary types</a>
+<li><a href="#G.4.2"> G.4.2 Real and imaginary</a>
+<li><a href="#G.4.3"> G.4.3 Imaginary and complex</a>
+</ul>
+<li><a href="#G.5"> G.5 Binary operators</a>
+<ul>
+<li><a href="#G.5.1"> G.5.1 Multiplicative operators</a>
+<li><a href="#G.5.2"> G.5.2 Additive operators</a>
+</ul>
+<li><a href="#G.6"> G.6 Complex arithmetic <complex.h></a>
+<ul>
+<li><a href="#G.6.1"> G.6.1 Trigonometric functions</a>
+<li><a href="#G.6.2"> G.6.2 Hyperbolic functions</a>
+<li><a href="#G.6.3"> G.6.3 Exponential and logarithmic functions</a>
+<li><a href="#G.6.4"> G.6.4 Power and absolute-value functions</a>
+</ul>
+<li><a href="#G.7"> G.7 Type-generic math <tgmath.h></a>
+</ul>
+<li><a href="#H">Annex H (informative) Language independent arithmetic</a>
+<ul>
+<li><a href="#H.1"> H.1 Introduction</a>
+<li><a href="#H.2"> H.2 Types</a>
+<li><a href="#H.3"> H.3 Notification</a>
<!--page 11 indent 0-->
-Annex I (informative) Common warnings . . . . . . . . . . . . . . . . 548
-Annex J (informative) Portability issues . . . . . . . . . . . . . . . . . 550
- J.1 Unspecified behavior . . . . . . . . . . . . . . . . . . . . . 550
- J.2 Undefined behavior . . . . . . . . . . . . . . . . . . . . . 553
- J.3 Implementation-defined behavior . . . . . . . . . . . . . . . . 566
- J.4 Locale-specific behavior . . . . . . . . . . . . . . . . . . . 574
- J.5 Common extensions . . . . . . . . . . . . . . . . . . . . . 575
-Annex K (normative) Bounds-checking interfaces . . . . . . . . . . . . . 578
- K.1 Background . . . . . . . . . . . . . . . . . . . . . . . . 578
- K.2 Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
- K.3 Library . . . . . . . . . . . . . . . . . . . . . . . . . . 579
- K.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . 579
- K.3.1.1 Standard headers . . . . . . . . . . . . . . . 579
- K.3.1.2 Reserved identifiers . . . . . . . . . . . . . . 580
- K.3.1.3 Use of errno . . . . . . . . . . . . . . . . . 580
- K.3.1.4 Runtime-constraint violations . . . . . . . . . . 580
- K.3.2 Errors <errno.h> . . . . . . . . . . . . . . . . . 581
- K.3.3 Common definitions <stddef.h> . . . . . . . . . . . 581
- K.3.4 Integer types <stdint.h> . . . . . . . . . . . . . . 581
- K.3.5 Input/output <stdio.h> . . . . . . . . . . . . . . . 582
- K.3.5.1 Operations on files . . . . . . . . . . . . . . 582
- K.3.5.2 File access functions . . . . . . . . . . . . . . 584
- K.3.5.3 Formatted input/output functions . . . . . . . . . 587
- K.3.5.4 Character input/output functions . . . . . . . . . 598
- K.3.6 General utilities <stdlib.h> . . . . . . . . . . . . . 600
- K.3.6.1 Runtime-constraint handling . . . . . . . . . . 600
- K.3.6.2 Communication with the environment . . . . . . . 602
- K.3.6.3 Searching and sorting utilities . . . . . . . . . . 603
- K.3.6.4 Multibyte/wide character conversion functions . . . 606
- K.3.6.5 Multibyte/wide string conversion functions . . . . . 607
- K.3.7 String handling <string.h> . . . . . . . . . . . . . 610
- K.3.7.1 Copying functions . . . . . . . . . . . . . . 610
- K.3.7.2 Concatenation functions . . . . . . . . . . . . 613
- K.3.7.3 Search functions . . . . . . . . . . . . . . . 616
- K.3.7.4 Miscellaneous functions . . . . . . . . . . . . 617
- K.3.8 Date and time <time.h> . . . . . . . . . . . . . . . 620
- K.3.8.1 Components of time . . . . . . . . . . . . . . 620
- K.3.8.2 Time conversion functions . . . . . . . . . . . 620
- K.3.9 Extended multibyte and wide character utilities
- <wchar.h> . . . . . . . . . . . . . . . . . . . . 623
- K.3.9.1 Formatted wide character input/output functions . . . 624
- K.3.9.2 General wide string utilities . . . . . . . . . . . 635
+</ul>
+<li><a href="#I">Annex I (informative) Common warnings</a>
+<li><a href="#J">Annex J (informative) Portability issues</a>
+<ul>
+<li><a href="#J.1"> J.1 Unspecified behavior</a>
+<li><a href="#J.2"> J.2 Undefined behavior</a>
+<li><a href="#J.3"> J.3 Implementation-defined behavior</a>
+<li><a href="#J.4"> J.4 Locale-specific behavior</a>
+<li><a href="#J.5"> J.5 Common extensions</a>
+</ul>
+<li><a href="#K">Annex K (normative) Bounds-checking interfaces</a>
+<ul>
+<li><a href="#K.1"> K.1 Background</a>
+<li><a href="#K.2"> K.2 Scope</a>
+<li><a href="#K.3"> K.3 Library</a>
+<ul>
+<li><a href="#K.3.1"> K.3.1 Introduction</a>
+<ul>
+<li><a href="#K.3.1.1"> K.3.1.1 Standard headers</a>
+<li><a href="#K.3.1.2"> K.3.1.2 Reserved identifiers</a>
+<li><a href="#K.3.1.3"> K.3.1.3 Use of errno</a>
+<li><a href="#K.3.1.4"> K.3.1.4 Runtime-constraint violations</a>
+</ul>
+<li><a href="#K.3.2"> K.3.2 Errors <errno.h></a>
+<li><a href="#K.3.3"> K.3.3 Common definitions <stddef.h></a>
+<li><a href="#K.3.4"> K.3.4 Integer types <stdint.h></a>
+<li><a href="#K.3.5"> K.3.5 Input/output <stdio.h></a>
+<ul>
+<li><a href="#K.3.5.1"> K.3.5.1 Operations on files</a>
+<li><a href="#K.3.5.2"> K.3.5.2 File access functions</a>
+<li><a href="#K.3.5.3"> K.3.5.3 Formatted input/output functions</a>
+<li><a href="#K.3.5.4"> K.3.5.4 Character input/output functions</a>
+</ul>
+<li><a href="#K.3.6"> K.3.6 General utilities <stdlib.h></a>
+<ul>
+<li><a href="#K.3.6.1"> K.3.6.1 Runtime-constraint handling</a>
+<li><a href="#K.3.6.2"> K.3.6.2 Communication with the environment</a>
+<li><a href="#K.3.6.3"> K.3.6.3 Searching and sorting utilities</a>
+<li><a href="#K.3.6.4"> K.3.6.4 Multibyte/wide character conversion functions</a>
+<li><a href="#K.3.6.5"> K.3.6.5 Multibyte/wide string conversion functions</a>
+</ul>
+<li><a href="#K.3.7"> K.3.7 String handling <string.h></a>
+<ul>
+<li><a href="#K.3.7.1"> K.3.7.1 Copying functions</a>
+<li><a href="#K.3.7.2"> K.3.7.2 Concatenation functions</a>
+<li><a href="#K.3.7.3"> K.3.7.3 Search functions</a>
+<li><a href="#K.3.7.4"> K.3.7.4 Miscellaneous functions</a>
+</ul>
+<li><a href="#K.3.8"> K.3.8 Date and time <time.h></a>
+<ul>
+<li><a href="#K.3.8.1"> K.3.8.1 Components of time</a>
+<li><a href="#K.3.8.2"> K.3.8.2 Time conversion functions</a>
+</ul>
+<li><a href="#K.3.9"> K.3.9 Extended multibyte and wide character utilities <wchar.h></a>
+<ul>
+<li><a href="#K.3.9.1"> K.3.9.1 Formatted wide character input/output functions</a>
+<li><a href="#K.3.9.2"> K.3.9.2 General wide string utilities</a>
<!--page 12 indent 0-->
- K.3.9.3 Extended multibyte/wide character conversion
- utilities . . . . . . . . . . . . . . . . . . . 643
-Annex L (normative) Analyzability . . . . . . . . . . . . . . . . . . 648
- L.1 Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
- L.2 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . 648
- L.3 Requirements . . . . . . . . . . . . . . . . . . . . . . . . 649
-Bibliography . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
-Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
+<li><a href="#K.3.9.3"> K.3.9.3 Extended multibyte/wide character conversion utilities</a>
+</ul>
+</ul>
+</ul>
+<li><a href="#L">Annex L (normative) Analyzability</a>
+<ul>
+<li><a href="#L.1"> L.1 Scope</a>
+<li><a href="#L.2"> L.2 Definitions</a>
+<li><a href="#L.3"> L.3 Requirements</a>
+</ul>
+<li><a href="#Bibliography">Bibliography</a>
+<li><a href="#Index">Index</a>
<!--page 13 indent 4-->
-</pre>
+</ul>
<a name="Foreword" href="#Foreword"><h2>Foreword</h2></a>
<p><!--para 1-->
<ul>
<li> conditional (optional) features (including some that were previously mandatory)
<li> support for multiple threads of execution including an improved memory sequencing
- model, atomic objects, and thread-local storage (<stdatomic.h> and
- <threads.h>)
-<li> additional floating-point characteristic macros (<float.h>)
-<li> querying and specifying alignment of objects (<stdalign.h>, <stdlib.h>)
-<li> Unicode characters and strings (<uchar.h>) (originally specified in
+ model, atomic objects, and thread-local storage (<a href="#7.17"><stdatomic.h></a> and
+ <a href="#7.25"><threads.h></a>)
+<li> additional floating-point characteristic macros (<a href="#7.7"><float.h></a>)
+<li> querying and specifying alignment of objects (<a href="#7.15"><stdalign.h></a>, <a href="#7.22"><stdlib.h></a>)
+<li> Unicode characters and strings (<a href="#7.27"><uchar.h></a>) (originally specified in
ISO/IEC TR 19769:2004)
<li> type-generic expressions
<!--page 14 indent 4-->
<li> static assertions
<li> anonymous structures and unions
<li> no-return functions
-<li> macros to create complex numbers (<complex.h>)
+<li> macros to create complex numbers (<a href="#7.3"><complex.h></a>)
<li> support for opening files for exclusive access
-<li> removed the gets function (<stdio.h>)
+<li> removed the gets function (<a href="#7.21"><stdio.h></a>)
<li> added the aligned_alloc, at_quick_exit, and quick_exit functions
- (<stdlib.h>)
+ (<a href="#7.22"><stdlib.h></a>)
<li> (conditional) support for bounds-checking interfaces (originally specified in
ISO/IEC TR 24731-1:2007)
<li> (conditional) support for analyzability
<p><!--para 7-->
Major changes in the second edition included:
<ul>
-<li> restricted character set support via digraphs and <iso646.h> (originally specified
+<li> restricted character set support via digraphs and <a href="#7.9"><iso646.h></a> (originally specified
in AMD1)
-<li> wide character library support in <wchar.h> and <wctype.h> (originally
+<li> wide character library support in <a href="#7.28"><wchar.h></a> and <a href="#7.29"><wctype.h></a> (originally
specified in AMD1)
<li> more precise aliasing rules via effective type
<li> restricted pointers
<li> variable length arrays
<li> flexible array members
<li> static and type qualifiers in parameter array declarators
-<li> complex (and imaginary) support in <complex.h>
-<li> type-generic math macros in <tgmath.h>
+<li> complex (and imaginary) support in <a href="#7.3"><complex.h></a>
+<li> type-generic math macros in <a href="#7.24"><tgmath.h></a>
<li> the long long int type and library functions
<li> increased minimum translation limits
-<li> additional floating-point characteristics in <float.h>
+<li> additional floating-point characteristics in <a href="#7.7"><float.h></a>
<li> remove implicit int
<li> reliable integer division
<li> universal character names (\u and \U)
<li> compound literals
<li> designated initializers
<li> // comments
-<li> extended integer types and library functions in <inttypes.h> and <stdint.h>
+<li> extended integer types and library functions in <a href="#7.8"><inttypes.h></a> and <a href="#7.20"><stdint.h></a>
<li> remove implicit function declaration
<li> preprocessor arithmetic done in intmax_t/uintmax_t
<li> mixed declarations and code
<li> integer constant type rules
<li> integer promotion rules
<li> macros with a variable number of arguments
-<li> the vscanf family of functions in <stdio.h> and <wchar.h>
-<li> additional math library functions in <math.h>
+<li> the vscanf family of functions in <a href="#7.21"><stdio.h></a> and <a href="#7.28"><wchar.h></a>
+<li> additional math library functions in <a href="#7.12"><math.h></a>
<li> treatment of error conditions by math library functions (math_errhandling)
-<li> floating-point environment access in <fenv.h>
+<li> floating-point environment access in <a href="#7.6"><fenv.h></a>
<li> IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
<li> trailing comma allowed in enum declaration
<li> %lf conversion specifier allowed in printf
<li> inline functions
-<li> the snprintf family of functions in <stdio.h>
-<li> boolean type in <stdbool.h>
+<li> the snprintf family of functions in <a href="#7.21"><stdio.h></a>
+<li> boolean type in <a href="#7.18"><stdbool.h></a>
<li> idempotent type qualifiers
<li> empty macro arguments
<li> new structure type compatibility rules (tag compatibility)
</ul>
<h6>footnotes</h6>
-<p><a name="note1">1)</a> This International Standard is designed to promote the portability of C programs among a variety of
+<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
data-processing systems. It is intended for use by implementors and programmers.
-
+</small>
<a name="2" href="#2"><h2>2. Normative references</h2></a>
<p><!--para 1-->
<h6>footnotes</h6>
-<p><
a name="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
+<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
representation might perform a trap but is not required to (see <a href="#6.2.6.1">6.2.6.1</a>).
-
+</small>
<a name="3.20" href="#3.20"><h3>3.20</h3></a>
<p><!--para 1-->
hosted implementation shall accept any strictly conforming program. A conforming
freestanding implementation shall accept any strictly conforming program that does not
use complex types and in which the use of the features specified in the library clause
- (clause 7) is confined to the contents of the standard headers <float.h>,
- <iso646.h>, <limits.h>, <stdalign.h>, <stdarg.h>, <stdbool.h>,
- <stddef.h>, and <stdint.h>. A conforming implementation may have extensions
+ (clause 7) is confined to the contents of 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>, <a href="#7.16"><stdarg.h></a>, <a href="#7.18"><stdbool.h></a>,
+ <a href="#7.19"><stddef.h></a>, and <a href="#7.20"><stdint.h></a>. A conforming implementation may have extensions
(including additional library functions), provided they do not alter the behavior of any
strictly conforming program.<sup><a href="#note4"><b>4)</b></a></sup>
<p><!--para 8-->
An implementation shall be accompanied by a document that defines all implementation-
defined and locale-specific characteristics and all extensions.
-
Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
- characteristics of floating types <float.h> (<a href="#7.7">7.7</a>), alternative spellings <iso646.h>
- (<a href="#7.9">7.9</a>), sizes of integer types
<limits.h> (<a href="#7.10">7.10</a>), alignment <stdalign.h> (<a href="#7.15">7.15</a>),
- variable arguments <stdarg.h> (<a href="#7.16">7.16</a>), boolean type and values <stdbool.h>
- (<a href="#7.18">7.18</a>), common definitions
<stddef.h> (<a href="#7.19">7.19</a>), integer types <stdint.h> (<a href="#7.20">7.20</a>).
+
<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>),
+ 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>
+ (<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>),
+ 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>
+ (<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>).
<!--page 28 indent 4-->
<h6>footnotes</h6>
-<p><
a name="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
+<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
by an appropriate conditional inclusion preprocessing directive using the related macro. For example:
<pre>
/* ... */
#endif</pre>
-
-<p><a name="note4">4)</a> This implies that a conforming implementation reserves no identifiers other than those explicitly
+</small>
+<p><small><a name="note4" href="#note4">4)</a> This implies that a conforming implementation reserves no identifiers other than those explicitly
reserved in this International Standard.
-
-<p><a name="note5">5)</a> Strictly conforming programs are intended to be maximally portable among conforming
+</small>
+<p><small><a name="note5" href="#note5">5)</a> Strictly conforming programs are intended to be maximally portable among conforming
implementations. Conforming programs may depend upon nonportable features of a conforming
implementation.
-
+</small>
<a name="5" href="#5"><h2>5. Environment</h2></a>
<p><!--para 1-->
the execution environment in this International Standard. Their characteristics define and
constrain the results of executing conforming C programs constructed according to the
syntactic and semantic rules for conforming implementations.
- Forward references: In this clause, only a few of many possible forward references
+<p><b> Forward references</b>: In this clause, only a few of many possible forward references
have been noted.
<a name="5.1" href="#5.1"><h3>5.1 Conceptual models</h3></a>
linkage, manipulation of objects whose identifiers have external linkage, or manipulation
of data files. Translation units may be separately translated and then later linked to
produce an executable program.
-
Forward references: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
+
<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>),
preprocessing directives (<a href="#6.10">6.10</a>).
<a name="5.1.1.2" href="#5.1.1.2"><h5>5.1.1.2 Translation phases</h5></a>
current translation. All such translator output is collected into a program image
which contains information needed for execution in its execution environment.
</ol>
-
Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
+
<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>),
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>).
<!--page 30 indent 4-->
<h6>footnotes</h6>
-<p><a name="note6">6)</a> Implementations shall behave as if these separate phases occur, even though many are typically folded
+<p><small><a name="note6" href="#note6">6)</a> Implementations shall behave as if these separate phases occur, even though many are typically folded
together in practice. Source files, translation units, and translated translation units need not
necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
and any external representation. The description is conceptual only, and does not specify any
particular implementation.
-
-<p><
a name="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
+</small>
+<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
context-dependent. For example, see the handling of < within a #include preprocessing directive.
-
-<p><a name="note8">8)</a> An implementation need not convert all non-corresponding source characters to the same execution
+</small>
+<p><small><a name="note8" href="#note8">8)</a> An implementation need not convert all non-corresponding source characters to the same execution
character.
-
+</small>
<a name="5.1.1.3" href="#5.1.1.3"><h5>5.1.1.3 Diagnostics</h5></a>
<p><!--para 1-->
<h6>footnotes</h6>
-<p><a name="note9">9)</a> The intent is that an implementation should identify the nature of, and where possible localize, each
+<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
violation. Of course, an implementation is free to produce any number of diagnostics as long as a
valid program is still correctly translated. It may also successfully translate an invalid program.
-
+</small>
<a name="5.1.2" href="#5.1.2"><h4>5.1.2 Execution environments</h4></a>
<p><!--para 1-->
initial values) before program startup. The manner and timing of such initialization are
otherwise unspecified. Program termination returns control to the execution
environment.
-
Forward references: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+
<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>).
<a name="5.1.2.1" href="#5.1.2.1"><h5>5.1.2.1 Freestanding environment</h5></a>
<p><!--para 1-->
</ul>
<h6>footnotes</h6>
-<p><a name="note10">10)</a> Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
+<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
char ** argv, and so on.
-
+</small>
<a name="5.1.2.2.2" href="#5.1.2.2.2"><h5>5.1.2.2.2 Program execution</h5></a>
<p><!--para 1-->
returned by the main function as its argument;<sup><a href="#note11"><b>11)</b></a></sup> reaching the } that terminates the
main function returns a value of 0. If the return type is not compatible with int, the
termination status returned to the host environment is unspecified.
-
Forward references: 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>).
+
<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>).
<h6>footnotes</h6>
-<p><
a name="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
+<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
will have ended in the former case, even where they would not have in the latter.
-
+</small>
<a name="5.1.2.3" href="#5.1.2.3"><h5>5.1.2.3 Program execution</h5></a>
<p><!--para 1-->
EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
following fragment
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int sum;
char *p;
/* ... */
sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
value.
-
Forward references: 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>), the
+
<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>), the
signal function (<a href="#7.14">7.14</a>), files (<a href="#7.21.3">7.21.3</a>).
<h6>footnotes</h6>
-<p><a name="note12">12)</a> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
+<p><small><a name="note12" href="#note12">12)</a> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
values of floating-point operations. Implementations that support such floating-point state are
required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
- environment library <fenv.h> provides a programming facility for indicating when these side
+ environment library <a href="#7.6"><fenv.h></a> provides a programming facility for indicating when these side
effects matter, freeing the implementations in other cases.
-
-<p><a name="note13">13)</a> The executions of unsequenced evaluations can interleave. Indeterminately sequenced evaluations
+</small>
+<p><small><a name="note13" href="#note13">13)</a> The executions of unsequenced evaluations can interleave. Indeterminately sequenced evaluations
cannot interleave, but can be executed in any order.
-
+</small>
<a name="5.1.2.4" href="#5.1.2.4"><h5>5.1.2.4 Multi-threaded executions and data races</h5></a>
<p><!--para 1-->
<!--page 40 indent 4-->
<h6>footnotes</h6>
-<p><a name="note14">14)</a> The execution can usually be viewed as an interleaving of all of the threads. However, some kinds of
+<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
atomic operations, for example, allow executions inconsistent with a simple interleaving as described
below.
-
-<p><a name="note15">15)</a> The ''carries a dependency'' relation is a subset of the ''sequenced before'' relation, and is similarly
+</small>
+<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
strictly intra-thread.
-
-<p><a name="note16">16)</a> The ''dependency-ordered before'' relation is analogous to the ''synchronizes with'' relation, but uses
+</small>
+<p><small><a name="note16" href="#note16">16)</a> The ''dependency-ordered before'' relation is analogous to the ''synchronizes with'' relation, but uses
release/consume in place of release/acquire.
-
+</small>
<a name="5.2" href="#5.2"><h3>5.2 Environmental considerations</h3></a>
Standard the term does not include other characters that are letters in other alphabets.
<p><!--para 5-->
The universal character name construct provides a way to name other characters.
-
Forward references: 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>),
+
<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>),
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>).
<a name="5.2.1.1" href="#5.2.1.1"><h5>5.2.1.1 Trigraph sequences</h5></a>
<h6>footnotes</h6>
-<p><a name="note17">17)</a> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
+<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
described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
-
+</small>
<a name="5.2.1.2" href="#5.2.1.2"><h5>5.2.1.2 Multibyte characters</h5></a>
<p><!--para 1-->
which can be stored in a single char object. The external representations in a text file
need not be identical to the internal representations, and are outside the scope of this
International Standard.
-
Forward references: 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>).
+
<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>).
<a name="5.2.3" href="#5.2.3"><h4>5.2.3 Signals and interrupts</h4></a>
<p><!--para 1-->
</ul>
<h6>footnotes</h6>
-<p><a name="note18">18)</a> Implementations should avoid imposing fixed translation limits whenever possible.
-
-<p><
a name="note19">19)</a> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
-
+<p><small><a name="note18" href="#note18">18)</a> Implementations should avoid imposing fixed translation limits whenever possible.
+</small>
+<p><
small><a name="note19" href="#note19">19)</a> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
+</small>
<a name="5.2.4.2" href="#5.2.4.2"><h5>5.2.4.2 Numerical limits</h5></a>
<p><!--para 1-->
An implementation is required to document all the limits specified in this subclause,
- which are specified in the headers <limits.h> and <float.h>. Additional limits are
- specified in <stdint.h>.
-
Forward references: integer types <stdint.h> (<a href="#7.20">7.20</a>).
+ which are specified in the headers <a href="#7.10"><limits.h></a> and <a href="#7.7"><float.h></a>. Additional limits are
+ specified in <a href="#7.20"><stdint.h></a>.
+
<p><b> Forward references</b>: integer types <a href="#7.20"><stdint.h></a> (<a href="#7.20">7.20</a>).
<a name="5.2.4.2.1" href="#5.2.4.2.1"><h5>5.2.4.2.1 Sizes of integer types <limits.h></h5></a>
<p><!--para 1-->
value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
UCHAR_MAX.<sup><a href="#note20"><b>20)</b></a></sup> The value UCHAR_MAX shall equal 2CHAR_BIT - 1.
-
Forward references: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
+
<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>).
<h6>footnotes</h6>
-<p><
a name="note20">20)</a> See <a href="#6.2.5">6.2.5</a>.
-
+<p><
small><a name="note20" href="#note20">20)</a> See <a href="#6.2.5">6.2.5</a>.
+</small>
<a name="5.2.4.2.2" href="#5.2.4.2.2"><h5>5.2.4.2.2 Characteristics of floating types <float.h></h5></a>
<p><!--para 1-->
real numbers.
<p><!--para 6-->
The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
- <math.h> and <complex.h> that return floating-point results is implementation-
+ <a href="#7.12"><math.h></a> and <a href="#7.3"><complex.h></a> that return floating-point results is implementation-
defined, as is the accuracy of the conversion between floating-point internal
representations and string representations performed by the library functions in
- <stdio.h>, <stdlib.h>, and <wchar.h>. The implementation may state that the
+ <a href="#7.21"><stdio.h></a>, <a href="#7.22"><stdlib.h></a>, and <a href="#7.28"><wchar.h></a>. The implementation may state that the
accuracy is unknown.
<p><!--para 7-->
- All integer values in the <float.h> header, except FLT_ROUNDS, shall be constant
+ All integer values in the <a href="#7.7"><float.h></a> header, except FLT_ROUNDS, shall be constant
expressions suitable for use in #if preprocessing directives; all floating values shall be
constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
and FLT_ROUNDS have separate names for all three floating-point types. The floating-
should be the identity function.
<p><!--para 15-->
EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
- requirements of this International Standard, and the appropriate values in a <float.h> header for type
+ requirements of this International Standard, and the appropriate values in a <a href="#7.7"><float.h></a> header for type
float:
<pre>
6
<p><!--para 16-->
EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
single-precision and double-precision numbers in IEC 60559,<sup><a href="#note28"><b>28)</b></a></sup> and the appropriate values in a
- <float.h> header for types float and double:
+ <a href="#7.7"><float.h></a> header for types float and double:
<pre>
24
x f = s2e (Sum) f k 2-k ,
example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
precision), then DECIMAL_DIG would be 21.
-
Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
- <complex.h> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <wchar.h>
- (<a href="#7.28">7.28</a>), floating-point environment <fenv.h> (<a href="#7.6">7.6</a>), general utilities <stdlib.h>
- (<a href="#7.22">7.22</a>), input/output
<stdio.h> (<a href="#7.21">7.21</a>), mathematics <math.h> (<a href="#7.12">7.12</a>).
+
<p><b> Forward references</b>: conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
+ <a href="#7.3"><complex.h></a> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <a href="#7.28"><wchar.h></a>
+ (<a href="#7.28">7.28</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>
+ (<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>).
<!--page 53 indent 4-->
<h6>footnotes</h6>
-<p><a name="note21">21)</a> The floating-point model is intended to clarify the description of each floating-point characteristic and
+<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
does not require the floating-point arithmetic of the implementation to be identical.
-
-<p><a name="note22">22)</a> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
+</small>
+<p><small><a name="note22" href="#note22">22)</a> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
similar behavior.
-
-<p><a name="note23">23)</a> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
- the function fesetround in <fenv.h>.
-
-<p><a name="note24">24)</a> The evaluation method determines evaluation formats of expressions involving all floating types, not
+</small>
+<p><small><a name="note23" href="#note23">23)</a> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
+ the function fesetround in <a href="#7.6"><fenv.h></a>.
+</small>
+<p><small><a name="note24" href="#note24">24)</a> The evaluation method determines evaluation formats of expressions involving all floating types, not
just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
_Complex operands is represented in the double _Complex format, and its parts are evaluated to
double.
-
-<p><a name="note25">25)</a> Characterization as indeterminable is intended if floating-point operations do not consistently interpret
+</small>
+<p><small><a name="note25" href="#note25">25)</a> Characterization as indeterminable is intended if floating-point operations do not consistently interpret
subnormal representations as zero, nor as nonzero.
-
-<p><a name="note26">26)</a> Characterization as absent is intended if no floating-point operations produce subnormal results from
+</small>
+<p><small><a name="note26" href="#note26">26)</a> Characterization as absent is intended if no floating-point operations produce subnormal results from
non-subnormal inputs, even if the type format includes representations of subnormal numbers.
-
-<p><a name="note27">27)</a> If the presence or absence of subnormal numbers is indeterminable, then the value is intended to be a
+</small>
+<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
positive number no greater than the minimum normalized positive number for the type.
-
-<p><a name="note28">28)</a> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
+</small>
+<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
limits are one less than shown here.
-
+</small>
<a name="6" href="#6"><h2>6. Language</h2></a>
As a special case, a type name (which is not a declaration of an identifier) is considered to
have a scope that begins just after the place within the type name where the omitted
identifier would appear were it not omitted.
-
Forward references: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
+
<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
(<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>),
source file inclusion (<a href="#6.10.2">6.10.2</a>), statements (<a href="#6.8">6.8</a>).
<p><!--para 7-->
If, within a translation unit, the same identifier appears with both internal and external
linkage, the behavior is undefined.
-
Forward references: 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>),
+
<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>),
statements (<a href="#6.8">6.8</a>).
<h6>footnotes</h6>
-<p><a name="note29">29)</a> There is no linkage between different identifiers.
-
-<p><a name="note30">30)</a> A function declaration can contain the storage-class specifier static only if it is at file scope; see
+<p><small><a name="note29" href="#note29">29)</a> There is no linkage between different identifiers.
+</small>
+<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
<a href="#6.7.1">6.7.1</a>.
-
-<p><
a name="note31">31)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
-
+</small>
+<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.
+</small>
<a name="6.2.3" href="#6.2.3"><h4>6.2.3 Name spaces of identifiers</h4></a>
<p><!--para 1-->
<li> all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
enumeration constants).
</ul>
-
Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
+
<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>),
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
(<a href="#6.7.2.3">6.7.2.3</a>), the goto statement (<a href="#6.8.6.1">6.8.6.1</a>).
<!--page 56 indent 4-->
<h6>footnotes</h6>
-<p><a name="note32">32)</a> There is only one name space for tags even though three are possible.
-
+<p><small><a name="note32" href="#note32">32)</a> There is only one name space for tags even though three are possible.
+</small>
<a name="6.2.4" href="#6.2.4"><h4>6.2.4 Storage durations of objects</h4></a>
<p><!--para 1-->
value of the expression. Its lifetime ends when the evaluation of the containing full
expression or full declarator ends. Any attempt to modify an object with temporary
lifetime results in undefined behavior.
-
Forward references: 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
+
<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
(<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>).
<h6>footnotes</h6>
-<p><a name="note33">33)</a> The term ''constant address'' means that two pointers to the object constructed at possibly different
+<p><small><a name="note33" href="#note33">33)</a> The term ''constant address'' means that two pointers to the object constructed at possibly different
times will compare equal. The address may be different during two different executions of the same
program.
-
-<p><a name="note34">34)</a> In the case of a volatile object, the last store need not be explicit in the program.
-
-<p><a name="note35">35)</a> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
+</small>
+<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.
+</small>
+<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
embedded block prior to the declaration, leaves the scope of the declaration.
-
-<p><a name="note36">36)</a> The address of such an object is taken implicitly when an array member is accessed.
-
+</small>
+<p><small><a name="note36" href="#note36">36)</a> The address of such an object is taken implicitly when an array member is accessed.
+</small>
<a name="6.2.5" href="#6.2.5"><h4>6.2.5 Types</h4></a>
<p><!--para 1-->
An object declared as type signed char occupies the same amount of storage as a
''plain'' char object. A ''plain'' int object has the natural size suggested by the
architecture of the execution environment (large enough to contain any value in the range
- INT_MIN to INT_MAX as defined in the header <limits.h>).
+ INT_MIN to INT_MAX as defined in the header <a href="#7.10"><limits.h></a>).
<p><!--para 6-->
For each of the signed integer types, there is a corresponding (but different) unsigned
integer type (designated with the keyword unsigned) that uses the same amount of
function returning struct tag''. The array has length five and the function has a single parameter of type
float. Its type category is array.
-
Forward references: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
+
<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>).
<h6>footnotes</h6>
-<p><a name="note37">37)</a> A type may be incomplete or complete throughout an entire translation unit, or it may change states at
+<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
different points within a translation unit.
-
-<p><a name="note38">38)</a> Implementation-defined keywords shall have the form of an identifier reserved for any use as
+</small>
+<p><small><a name="note38" href="#note38">38)</a> Implementation-defined keywords shall have the form of an identifier reserved for any use as
described in <a href="#7.1.3">7.1.3</a>.
-
-<p><a name="note39">39)</a> Therefore, any statement in this Standard about signed integer types also applies to the extended
+</small>
+<p><small><a name="note39" href="#note39">39)</a> Therefore, any statement in this Standard about signed integer types also applies to the extended
signed integer types.
-
-<p><a name="note40">40)</a> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
+</small>
+<p><small><a name="note40" href="#note40">40)</a> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
unsigned integer types.
-
-<p><a name="note41">41)</a> The same representation and alignment requirements are meant to imply interchangeability as
+</small>
+<p><small><a name="note41" href="#note41">41)</a> The same representation and alignment requirements are meant to imply interchangeability as
arguments to functions, return values from functions, and members of unions.
-
-<p><
a name="note42">42)</a> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
-
-<p><
a name="note43">43)</a> A specification for imaginary types is in <a href="#G">annex G</a>.
-
-<p><a name="note44">44)</a> An implementation may define new keywords that provide alternative ways to designate a basic (or
+</small>
+<p><
small><a name="note42" href="#note42">42)</a> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
+</small>
+<p><
small><a name="note43" href="#note43">43)</a> A specification for imaginary types is in <a href="#G">annex G</a>.
+</small>
+<p><small><a name="note44" href="#note44">44)</a> An implementation may define new keywords that provide alternative ways to designate a basic (or
any other) type; this does not violate the requirement that all basic types be different.
Implementation-defined keywords shall have the form of an identifier reserved for any use as
described in <a href="#7.1.3">7.1.3</a>.
-
-<p><a name="note45">45)</a> CHAR_MIN, defined in <limits.h>, will have one of the values 0 or SCHAR_MIN, and this can be
+</small>
+<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
used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
other two and is not compatible with either.
-
-<p><a name="note46">46)</a> Note that aggregate type does not include union type because an object with union type can only
+</small>
+<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
contain one member at a time.
-
-<p><
a name="note47">47)</a> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
-
-<p><a name="note48">48)</a> The same representation and alignment requirements are meant to imply interchangeability as
+</small>
+<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.
+</small>
+<p><small><a name="note48" href="#note48">48)</a> The same representation and alignment requirements are meant to imply interchangeability as
arguments to functions, return values from functions, and members of unions.
-
+</small>
<a name="6.2.6" href="#6.2.6"><h4>6.2.6 Representations of types</h4></a>
<p><!--para 9-->
Loads and stores of objects with atomic types are done with
memory_order_seq_cst semantics.
-
Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
+
<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
designators (<a href="#6.3.2.1">6.3.2.1</a>), order and consistency (<a href="#7.17.3">7.17.3</a>).
<h6>footnotes</h6>
-<p><a name="note49">49)</a> A positional representation for integers that uses the binary digits 0 and 1, in which the values
+<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
represented by successive bits are additive, begin with 1, and are multiplied by successive integral
powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
<pre>
CHAR_BIT
- 1.</pre>
-
-<p><a name="note50">50)</a> Thus, an automatic variable can be initialized to a trap representation without causing undefined
+</small>
+<p><small><a name="note50" href="#note50">50)</a> Thus, an automatic variable can be initialized to a trap representation without causing undefined
behavior, but the value of the variable cannot be used until a proper value is stored in it.
-
-<p><a name="note51">51)</a> Thus, for example, structure assignment need not copy any padding bits.
-
-<p><a name="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
+</small>
+<p><small><a name="note51" href="#note51">51)</a> Thus, for example, structure assignment need not copy any padding bits.
+</small>
+<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
accessed as objects of type T, but to have different values in other contexts. In particular, if == is
defined for type T, then x == y does not imply that memcmp(&x, &y, sizeof (T)) == 0.
Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
on values of type T may distinguish between them.
-
+</small>
<a name="6.2.6.2" href="#6.2.6.2"><h5>6.2.6.2 Integer types</h5></a>
<p><!--para 1-->
<!--page 65 indent 4-->
<h6>footnotes</h6>
-<p><a name="note53">53)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
+<p><small><a name="note53" href="#note53">53)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
representation other than as part of an exceptional condition such as an overflow, and this cannot occur
with unsigned types. All other combinations of padding bits are alternative object representations of
the value specified by the value bits.
-
-<p><a name="note54">54)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
+</small>
+<p><small><a name="note54" href="#note54">54)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
representation other than as part of an exceptional condition such as an overflow. All other
combinations of padding bits are alternative object representations of the value specified by the value
bits.
-
+</small>
<a name="6.2.7" href="#6.2.7"><h4>6.2.7 Compatible type and composite type</h4></a>
<p><!--para 1-->
declaration of that identifier is visible,<sup><a href="#note56"><b>56)</b></a></sup> if the prior declaration specifies internal or
external linkage, the type of the identifier at the later declaration becomes the composite
type.
-
Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
+
<p><b> Forward references</b>: array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
<p><!--para 5-->
EXAMPLE Given the following two file scope declarations:
<pre>
<h6>footnotes</h6>
-<p><a name="note55">55)</a> Two types need not be identical to be compatible.
-
-<p><
a name="note56">56)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
-
+<p><small><a name="note55" href="#note55">55)</a> Two types need not be identical to be compatible.
+</small>
+<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.
+</small>
<a name="6.2.8" href="#6.2.8"><h4>6.2.8 Alignment of objects</h4></a>
<p><!--para 1-->
</ul>
<h6>footnotes</h6>
-<p><a name="note57">57)</a> Every over-aligned type is, or contains, a structure or union type with a member to which an extended
+<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
alignment has been applied.
-
+</small>
<a name="6.3" href="#6.3"><h3>6.3 Conversions</h3></a>
<p><!--para 1-->
<p><!--para 2-->
Conversion of an operand value to a compatible type causes no change to the value or the
representation.
-
Forward references: cast operators (<a href="#6.5.4">6.5.4</a>).
+
<p><b> Forward references</b>: cast operators (<a href="#6.5.4">6.5.4</a>).
<a name="6.3.1" href="#6.3.1"><h4>6.3.1 Arithmetic operands</h4></a>
<p><!--para 3-->
The integer promotions preserve value including sign. As discussed earlier, whether a
''plain'' char is treated as signed is implementation-defined.
-
Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
+
<p><b> Forward references</b>: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
(<a href="#6.7.2.1">6.7.2.1</a>).
<h6>footnotes</h6>
-<p><a name="note58">58)</a> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
+<p><small><a name="note58" href="#note58">58)</a> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
shift operators, as specified by their respective subclauses.
-
+</small>
<a name="6.3.1.2" href="#6.3.1.2"><h5>6.3.1.2 Boolean type</h5></a>
<p><!--para 1-->
to 0; otherwise, the result is 1.<sup><a href="#note59"><b>59)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note59">59)</a> NaNs do not compare equal to 0 and thus convert to 1.
-
+<p><small><a name="note59" href="#note59">59)</a> NaNs do not compare equal to 0 and thus convert to 1.
+</small>
<a name="6.3.1.3" href="#6.3.1.3"><h5>6.3.1.3 Signed and unsigned integers</h5></a>
<p><!--para 1-->
result is implementation-defined or an implementation-defined signal is raised.
<h6>footnotes</h6>
-<p><a name="note60">60)</a> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
-
+<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.
+</small>
<a name="6.3.1.4" href="#6.3.1.4"><h5>6.3.1.4 Real floating and integer</h5></a>
<p><!--para 1-->
required by the new type.
<h6>footnotes</h6>
-<p><a name="note61">61)</a> The remaindering operation performed when a value of integer type is converted to unsigned type
+<p><small><a name="note61" href="#note61">61)</a> The remaindering operation performed when a value of integer type is converted to unsigned type
need not be performed when a value of real floating type is converted to unsigned type. Thus, the
range of portable real floating values is (-1, Utype_MAX+1).
-
+</small>
<a name="6.3.1.5" href="#6.3.1.5"><h5>6.3.1.5 Real floating types</h5></a>
<p><!--para 1-->
<!--page 72 indent 4-->
<h6>footnotes</h6>
-<p><a name="note62">62)</a> For example, addition of a double _Complex and a float entails just the conversion of the
+<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
float operand to double (and yields a double _Complex result).
-
-<p><a name="note63">63)</a> The cast and assignment operators are still required to remove extra range and precision.
-
+</small>
+<p><small><a name="note63" href="#note63">63)</a> The cast and assignment operators are still required to remove extra range and precision.
+</small>
<a name="6.3.2" href="#6.3.2"><h4>6.3.2 Other operands</h4></a>
<!--page 73 indent 4-->
function returning type''.
-
Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
- (<a href="#6.5.16">6.5.16</a>), common definitions
<stddef.h> (<a href="#7.19">7.19</a>), initialization (<a href="#6.7.9">6.7.9</a>), postfix
+
<p><b> Forward references</b>: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
+ (<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
increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
(<a href="#6.5.3.1">6.5.3.1</a>), the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>).
<h6>footnotes</h6>
-<p><a name="note64">64)</a> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
+<p><small><a name="note64" href="#note64">64)</a> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
as the ''value of an expression''.
An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
-
-<p><a name="note65">65)</a> Because this conversion does not occur, the operand of the sizeof operator remains a function
+</small>
+<p><small><a name="note65" href="#note65">65)</a> Because this conversion does not occur, the operand of the sizeof operator remains a function
designator and violates the constraint in <a href="#6.5.3.4">6.5.3.4</a>.
-
+</small>
<a name="6.3.2.2" href="#6.3.2.2"><h5>6.3.2.2 void</h5></a>
<p><!--para 1-->
type and back again; the result shall compare equal to the original pointer. If a converted
pointer is used to call a function whose type is not compatible with the referenced type,
the behavior is undefined.
-
Forward references: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
+
<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
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>).
<!--page 75 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note66">66)</a> The macro NULL is defined in <stddef.h> (and other headers) as a null pointer constant; see <a href="#7.19">7.19</a>.
-
-<p><a name="note67">67)</a> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
+<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>.
+</small>
+<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
be consistent with the addressing structure of the execution environment.
-
-<p><a name="note68">68)</a> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
+</small>
+<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
pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
correctly aligned for a pointer to type C.
-
+</small>
<a name="6.4" href="#6.4"><h3>6.4 Lexical elements</h3></a>
<h6>Syntax</h6>
EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
increment operators, even though the parse x ++ + ++ y might yield a correct expression.
-
Forward references: 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>),
+
<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>),
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
increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
(<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
(<a href="#6.4.5">6.4.5</a>).
<h6>footnotes</h6>
-<p><
a name="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
+<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
occur in source files.
-
+</small>
<a name="6.4.1" href="#6.4.1"><h4>6.4.1 Keywords</h4></a>
<h6>Syntax</h6>
specifying imaginary types.<sup><a href="#note70"><b>70)</b></a></sup>
<h6>footnotes</h6>
-<p><
a name="note70">70)</a> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
-
+<p><
small><a name="note70" href="#note70">70)</a> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
+</small>
<a name="6.4.2" href="#6.4.2"><h4>6.4.2 Identifiers</h4></a>
<p><!--para 6-->
Any identifiers that differ in a significant character are different identifiers. If two
identifiers differ only in nonsignificant characters, the behavior is undefined.
-
Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
+
<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>).
<h6>footnotes</h6>
-<p><a name="note71">71)</a> On systems in which linkers cannot accept extended characters, an encoding of the universal character
+<p><small><a name="note71" href="#note71">71)</a> On systems in which linkers cannot accept extended characters, an encoding of the universal character
name may be used in forming valid external identifiers. For example, some otherwise unused
character or sequence of characters may be used to encode the \u in a universal character name.
Extended characters may produce a long external identifier.
-
+</small>
<a name="6.4.2.2" href="#6.4.2.2"><h5>6.4.2.2 Predefined identifiers</h5></a>
<h6>Semantics</h6>
<p><!--para 3-->
EXAMPLE Consider the code fragment:
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
void myfunc(void)
{
printf("%s\n", __func__);
<pre>
myfunc</pre>
-
Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+
<p><b> Forward references</b>: function definitions (<a href="#6.9.1">6.9.1</a>).
<!--page 79 indent 4-->
<h6>footnotes</h6>
-<p><
a name="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
+<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
identifier is explicitly declared using the name __func__, the behavior is undefined.
-
+</small>
<a name="6.4.3" href="#6.4.3"><h4>6.4.3 Universal character names</h4></a>
<h6>Syntax</h6>
<!--page 80 indent 4-->
<h6>footnotes</h6>
-<p><a name="note73">73)</a> The disallowed characters are the characters in the basic character set and the code positions reserved
+<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
by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
UTF-16).
-
-<p><a name="note74">74)</a> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
-
+</small>
+<p><small><a name="note74" href="#note74">74)</a> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
+</small>
<a name="6.4.4" href="#6.4.4"><h4>6.4.4 Constants</h4></a>
<h6>Syntax</h6>
<!--page 85 indent 4-->
<h6>footnotes</h6>
-<p><
a name="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
+<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
convert to the same internal format and value.
-
-<p><a name="note76">76)</a> The specification for the library functions recommends more accurate conversion than required for
+</small>
+<p><small><a name="note76" href="#note76">76)</a> The specification for the library functions recommends more accurate conversion than required for
floating constants (see <a href="#7.22.1.3">7.22.1.3</a>).
-
+</small>
<a name="6.4.4.3" href="#6.4.4.3"><h5>6.4.4.3 Enumeration constants</h5></a>
<h6>Syntax</h6>
<h6>Semantics</h6>
<p><!--para 2-->
An identifier declared as an enumeration constant has type int.
-
Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
+
<p><b> Forward references</b>: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
<a name="6.4.4.4" href="#6.4.4.4"><h5>6.4.4.4 Character constants</h5></a>
<h6>Syntax</h6>
type int.
<p><!--para 11-->
A wide character constant prefixed by the letter L has type wchar_t, an integer type
- defined in the <stddef.h> header; a wide character constant prefixed by the letter u or
+ defined in the <a href="#7.19"><stddef.h></a> header; a wide character constant prefixed by the letter u or
U has type char16_t or char32_t, respectively, unsigned integer types defined in the
- <uchar.h> header. The value of a wide character constant containing a single
+ <a href="#7.27"><uchar.h></a> header. The value of a wide character constant containing a single
multibyte character that maps to a single member of the extended execution character set
is the wide character corresponding to that multibyte character, as defined by the
mbtowc, mbrtoc16, or mbrtoc32 function as appropriate for its type, with an
L'\1234' specifies the implementation-defined value that results from the combination of the values
0123 and '4'.
-
Forward references: common definitions <stddef.h> (<a href="#7.19">7.19</a>), the mbtowc function
- (<a href="#7.22.7.2">7.22.7.2</a>), Unicode utilities
<uchar.h> (<a href="#7.27">7.27</a>).
+
<p><b> Forward references</b>: common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>), the mbtowc function
+ (<a href="#7.22.7.2">7.22.7.2</a>), Unicode utilities
<a href="#7.27"><uchar.h></a> (<a href="#7.27">7.27</a>).
<h6>footnotes</h6>
-<p><
a name="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,
+<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,
the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
-
+</small>
<a name="6.4.5" href="#6.4.5"><h4>6.4.5 String literals</h4></a>
<h6>Syntax</h6>
<pre>
u"abc"</pre>
-
Forward references: common definitions <stddef.h> (<a href="#7.19">7.19</a>), the mbstowcs
- function (<a href="#7.22.8.1">7.22.8.1</a>), Unicode utilities
<uchar.h> (<a href="#7.27">7.27</a>).
+
<p><b> Forward references</b>: common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>), the mbstowcs
+ function (<a href="#7.22.8.1">7.22.8.1</a>), Unicode utilities
<a href="#7.27"><uchar.h></a> (<a href="#7.27">7.27</a>).
<h6>footnotes</h6>
-<p><
a name="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
+<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
\0 escape sequence.
-
+</small>
<a name="6.4.6" href="#6.4.6"><h4>6.4.6 Punctuators</h4></a>
<h6>Syntax</h6>
<pre>
[ ] { } # ##</pre>
except for their spelling.<sup><a href="#note80"><b>80)</b></a></sup>
-
Forward references: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
+
<p><b> Forward references</b>: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
(<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
<h6>footnotes</h6>
-<p><a name="note79">79)</a> These tokens are sometimes called ''digraphs''.
-
-<p><
a name="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
+<p><small><a name="note79" href="#note79">79)</a> These tokens are sometimes called ''digraphs''.
+</small>
+<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
interchanged.
-
+</small>
<a name="6.4.7" href="#6.4.7"><h4>6.4.7 Header names</h4></a>
<h6>Syntax</h6>
{#}{include} {<1/a.h>}
{#}{define} {const}{.}{member}{@}{$}</pre>
-
Forward references: source file inclusion (<a href="#6.10.2">6.10.2</a>).
+
<p><b> Forward references</b>: source file inclusion (<a href="#6.10.2">6.10.2</a>).
<h6>footnotes</h6>
-<p><a name="note81">81)</a> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
-
-<p><
a name="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>.
-
+<p><small><a name="note81" href="#note81">81)</a> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
+</small>
+<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>.
+</small>
<a name="6.4.8" href="#6.4.8"><h4>6.4.8 Preprocessing numbers</h4></a>
<h6>Syntax</h6>
<!--page 94 indent 4-->
<h6>footnotes</h6>
-<p><a name="note83">83)</a> Thus, /* ... */ comments do not nest.
-
+<p><small><a name="note83" href="#note83">83)</a> Thus, /* ... */ comments do not nest.
+</small>
<a name="6.5" href="#6.5"><h3>6.5 Expressions</h3></a>
<p><!--para 1-->
<p><!--para 8-->
A floating expression may be contracted, that is, evaluated as though it were a single
operation, thereby omitting rounding errors implied by the source code and the
- expression evaluation method.<sup><a href="#note89"><b>89)</b></a></sup> The FP_CONTRACT pragma in <math.h> provides a
+ 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
way to disallow contracted expressions. Otherwise, whether and how expressions are
contracted is implementation-defined.<sup><a href="#note90"><b>90)</b></a></sup>
-
Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.23.2">7.23.2</a>).
+
<p><b> Forward references</b>: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.23.2">7.23.2</a>).
<!--page 96 indent 4-->
<h6>footnotes</h6>
-<p><a name="note84">84)</a> This paragraph renders undefined statement expressions such as
+<p><small><a name="note84" href="#note84">84)</a> This paragraph renders undefined statement expressions such as
<pre>
i = ++i + 1;
i = i + 1;
a[i] = i;</pre>
-
-<p><a name="note85">85)</a> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
+</small>
+<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
as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
<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
the conditional operator ? : (<a href="#6.5.15">6.5.15</a>).
Within each major subclause, the operators have the same precedence. Left- or right-associativity is
indicated in each subclause by the syntax for the expressions discussed therein.
-
-<p><a name="note86">86)</a> In an expression that is evaluated more than once during the execution of a program, unsequenced and
+</small>
+<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
indeterminately sequenced evaluations of its subexpressions need not be performed consistently in
different evaluations.
-
-<p><a name="note87">87)</a> Allocated objects have no declared type.
-
-<p><a name="note88">88)</a> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
-
-<p><a name="note89">89)</a> The intermediate operations in the contracted expression are evaluated as if to infinite precision and
+</small>
+<p><small><a name="note87" href="#note87">87)</a> Allocated objects have no declared type.
+</small>
+<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.
+</small>
+<p><small><a name="note89" href="#note89">89)</a> The intermediate operations in the contracted expression are evaluated as if to infinite precision and
range, while the final operation is rounded to the format determined by the expression evaluation
method. A contracted expression might also omit the raising of floating-point exceptions.
-
-<p><a name="note90">90)</a> This license is specifically intended to allow implementations to exploit fast machine instructions that
+</small>
+<p><small><a name="note90" href="#note90">90)</a> This license is specifically intended to allow implementations to exploit fast machine instructions that
combine multiple C operators. As contractions potentially undermine predictability, and can even
decrease accuracy for containing expressions, their use needs to be well-defined and clearly
documented.
-
+</small>
<a name="6.5.1" href="#6.5.1"><h4>6.5.1 Primary expressions</h4></a>
<h6>Syntax</h6>
those of the unparenthesized expression. It is an lvalue, a function designator, or a void
expression if the unparenthesized expression is, respectively, an lvalue, a function
designator, or a void expression.
-
Forward references: declarations (<a href="#6.7">6.7</a>).
+
<p><b> Forward references</b>: declarations (<a href="#6.7">6.7</a>).
<h6>footnotes</h6>
-<p><a name="note91">91)</a> Thus, an undeclared identifier is a violation of the syntax.
-
+<p><small><a name="note91" href="#note91">91)</a> Thus, an undeclared identifier is a violation of the syntax.
+</small>
<a name="6.5.1.1" href="#6.5.1.1"><h5>6.5.1.1 Generic selection</h5></a>
<h6>Syntax</h6>
expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
yields an int.
-
Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
+
<p><b> Forward references</b>: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
(<a href="#6.5.3.2">6.5.3.2</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
<a name="6.5.2.2" href="#6.5.2.2"><h5>6.5.2.2 Function calls</h5></a>
the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
the function pointed to by pf[f1()] is called.
-
Forward references: function declarators (including prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), function
+
<p><b> Forward references</b>: function declarators (including prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), function
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>).
<h6>footnotes</h6>
-<p><a name="note92">92)</a> Most often, this is the result of converting an identifier that is a function designator.
-
-<p><a name="note93">93)</a> A function may change the values of its parameters, but these changes cannot affect the values of the
+<p><small><a name="note92" href="#note92">92)</a> Most often, this is the result of converting an identifier that is a function designator.
+</small>
+<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
arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
change the value of the object pointed to. A parameter declared to have array or function type is
adjusted to have a pointer type as described in <a href="#6.9.1">6.9.1</a>.
-
-<p><a name="note94">94)</a> In other words, function executions do not ''interleave'' with each other.
-
+</small>
+<p><small><a name="note94" href="#note94">94)</a> In other words, function executions do not ''interleave'' with each other.
+</small>
<a name="6.5.2.3" href="#6.5.2.3"><h5>6.5.2.3 Structure and union members</h5></a>
<h6>Constraints</h6>
return f(&u.s1, &u.s2);
}</pre>
-
Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
+
<p><b> Forward references</b>: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
<!--page 103 indent 4-->
<h6>footnotes</h6>
-<p><a name="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
+<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
store a value in the object, the appropriate part of the object representation of the value is reinterpreted
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
punning''). This might be a trap representation.
-
-<p><a name="note96">96)</a> If &E is a valid pointer expression (where & is the ''address-of '' operator, which generates a pointer to
+</small>
+<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
its operand), the expression (&E)->MOS is the same as E.MOS.
-
-<p><a name="note97">97)</a> For example, a data race would occur if access to the entire structure or union in one thread conflicts
+</small>
+<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
with access to a member from another thread, where at least one access is a modification. Members
can be safely accessed using a non-atomic object which is assigned to or from the atomic object.
-
+</small>
<a name="6.5.2.4" href="#6.5.2.4"><h5>6.5.2.4 Postfix increment and decrement operators</h5></a>
<h6>Constraints</h6>
The postfix -- operator is analogous to the postfix ++ operator, except that the value of
the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
it).
-
Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+
<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>).
<h6>footnotes</h6>
-<p><a name="note98">98)</a> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
+<p><small><a name="note98" href="#note98">98)</a> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
where T is the type of E:
<pre>
tmp = result + 1;
} while (!atomic_compare_exchange_strong(&E, &result, tmp));</pre>
with result being the result of the operation.
-
+</small>
<a name="6.5.2.5" href="#6.5.2.5"><h5>6.5.2.5 Compound literals</h5></a>
<h6>Constraints</h6>
lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
have an indeterminate value, which would result in undefined behavior.
-
Forward references: type names (<a href="#6.7.7">6.7.7</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+
<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>).
<!--page 106 indent 4-->
<h6>footnotes</h6>
-<p><a name="note99">99)</a> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
+<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
or void only, and the result of a cast expression is not an lvalue.
-
-<p><a name="note100">100)</a> For example, subobjects without explicit initializers are initialized to zero.
-
-<p><a name="note101">101)</a> This allows implementations to share storage for string literals and constant compound literals with
+</small>
+<p><small><a name="note100" href="#note100">100)</a> For example, subobjects without explicit initializers are initialized to zero.
+</small>
+<p><small><a name="note101" href="#note101">101)</a> This allows implementations to share storage for string literals and constant compound literals with
the same or overlapping representations.
-
+</small>
<a name="6.5.3" href="#6.5.3"><h4>6.5.3 Unary operators</h4></a>
<h6>Syntax</h6>
<p><!--para 3-->
The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
operand is decremented.
-
Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+
<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>).
<a name="6.5.3.2" href="#6.5.3.2"><h5>6.5.3.2 Address and indirection operators</h5></a>
<h6>Constraints</h6>
object. If the operand has type ''pointer to type'', the result has type ''type''. If an
invalid value has been assigned to the pointer, the behavior of the unary * operator is
undefined.<sup><a href="#note102"><b>102)</b></a></sup>
-
Forward references: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
+
<p><b> Forward references</b>: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
(<a href="#6.7.2.1">6.7.2.1</a>).
<h6>footnotes</h6>
-<p><a name="note102">102)</a> Thus, &*E is equivalent to E (even if E is a null pointer), and &(E1[E2]) to ((E1)+(E2)). It is
+<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
always true that if E is a function designator or an lvalue that is a valid operand of the unary &
operator, *&E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
address inappropriately aligned for the type of object pointed to, and the address of an object after the
end of its lifetime.
-
+</small>
<a name="6.5.3.3" href="#6.5.3.3"><h5>6.5.3.3 Unary arithmetic operators</h5></a>
<h6>Constraints</h6>
bytes in such an object, including internal and trailing padding.
<p><!--para 5-->
The value of the result of both operators is implementation-defined, and its type (an
- unsigned integer type) is size_t, defined in <stddef.h> (and other headers).
+ unsigned integer type) is size_t, defined in <a href="#7.19"><stddef.h></a> (and other headers).
<p><!--para 6-->
EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
EXAMPLE 3 In this example, the size of a variable length array is computed and returned from a
function:
<pre>
- #include <stddef.h></pre>
+ #include <a href="#7.19"><stddef.h></a></pre>
return 0;
}</pre>
-
Forward references: common definitions <stddef.h> (<a href="#7.19">7.19</a>), declarations (<a href="#6.7">6.7</a>),
+
<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>),
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>).
<h6>footnotes</h6>
-<p><a name="note103">103)</a> When applied to a parameter declared to have array or function type, the sizeof operator yields the
+<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
size of the adjusted (pointer) type (see <a href="#6.9.1">6.9.1</a>).
-
+</small>
<a name="6.5.4" href="#6.5.4"><h4>6.5.4 Cast operators</h4></a>
<h6>Syntax</h6>
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
type of the expression is the same as the named type and removes any extra range and
precision.
-
Forward references: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
+
<p><b> Forward references</b>: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
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>).
<!--page 110 indent 4-->
<h6>footnotes</h6>
-<p><a name="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
+<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
unqualified version of the type.
-
+</small>
<a name="6.5.5" href="#6.5.5"><h4>6.5.5 Multiplicative operators</h4></a>
<h6>Syntax</h6>
undefined.
<h6>footnotes</h6>
-<p><a name="note105">105)</a> This is often called ''truncation toward zero''.
-
+<p><small><a name="note105" href="#note105">105)</a> This is often called ''truncation toward zero''.
+</small>
<a name="6.5.6" href="#6.5.6"><h4>6.5.6 Additive operators</h4></a>
<h6>Syntax</h6>
When two pointers are subtracted, both shall point to elements of the same array object,
or one past the last element of the array object; the result is the difference of the
subscripts of the two array elements. The size of the result is implementation-defined,
- and its type (a signed integer type) is ptrdiff_t defined in the <stddef.h> header.
+ and its type (a signed integer type) is ptrdiff_t defined in the <a href="#7.19"><stddef.h></a> header.
If the result is not representable in an object of that type, the behavior is undefined. In
other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
the same.
- Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), common definitions <stddef.h>
+<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>
(<a href="#7.19">7.19</a>).
<h6>footnotes</h6>
-<p><a name="note106">106)</a> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
+<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
this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
by the size of the object originally pointed to, and the resulting pointer is converted back to the
original type. For pointer subtraction, the result of the difference between the character pointers is
When viewed in this way, an implementation need only provide one extra byte (which may overlap
another object in the program) just after the end of the object in order to satisfy the ''one past the last
element'' requirements.
-
+</small>
<a name="6.5.7" href="#6.5.7"><h4>6.5.7 Bitwise shift operators</h4></a>
<h6>Syntax</h6>
false.<sup><a href="#note107"><b>107)</b></a></sup> The result has type int.
<h6>footnotes</h6>
-<p><a name="note107">107)</a> The expression a<b<c is not interpreted as in ordinary mathematics. As the syntax indicates, it
+<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
means (a<b)<c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
-
+</small>
<a name="6.5.9" href="#6.5.9"><h4>6.5.9 Equality operators</h4></a>
<h6>Syntax</h6>
type of the object as its element type.
<h6>footnotes</h6>
-<p><a name="note108">108)</a> Because of the precedences, a<b == c<d is 1 whenever a<b and c<d have the same truth-value.
-
-<p><a name="note109">109)</a> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
+<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.
+</small>
+<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
adjacent members of a structure with no padding between them, or because the implementation chose
to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
behavior.
-
+</small>
<a name="6.5.10" href="#6.5.10"><h4>6.5.10 Bitwise AND operator</h4></a>
<h6>Syntax</h6>
<h6>footnotes</h6>
-<p><a name="note110">110)</a> A conditional expression does not yield an lvalue.
-
+<p><small><a name="note110" href="#note110">110)</a> A conditional expression does not yield an lvalue.
+</small>
<a name="6.5.16" href="#6.5.16"><h4>6.5.16 Assignment operators</h4></a>
<h6>Syntax</h6>
<!--page 120 indent 4-->
<h6>footnotes</h6>
-<p><a name="note111">111)</a> The implementation is permitted to read the object to determine the value but is not required to, even
+<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
when the object has volatile-qualified type.
-
+</small>
<a name="6.5.16.1" href="#6.5.16.1"><h5>6.5.16.1 Simple assignment</h5></a>
<h6>Constraints</h6>
<h6>footnotes</h6>
-<p><a name="note112">112)</a> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
+<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
(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
qualifiers that were applied to the type category of the expression (for example, it removes const but
not volatile from the type int volatile * const).
-
+</small>
<a name="6.5.16.2" href="#6.5.16.2"><h5>6.5.16.2 Compound assignment</h5></a>
<h6>Constraints</h6>
semantics.<sup><a href="#note113"><b>113)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note113">113)</a> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
+<p><small><a name="note113" href="#note113">113)</a> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
where T is the type of E1:
<pre>
result = tmp op (E2);
} while (!atomic_compare_exchange_strong(&E1, &tmp, result));</pre>
with result being the result of the operation.
-
+</small>
<a name="6.5.17" href="#6.5.17"><h4>6.5.17 Comma operator</h4></a>
<h6>Syntax</h6>
f(a, (t=3, t+2), c)</pre>
the function has three arguments, the second of which has the value 5.
-
Forward references: initialization (<a href="#6.7.9">6.7.9</a>).
+
<p><b> Forward references</b>: initialization (<a href="#6.7.9">6.7.9</a>).
<!--page 123 indent 4-->
<h6>footnotes</h6>
-<p><a name="note114">114)</a> A comma operator does not yield an lvalue.
-
+<p><small><a name="note114" href="#note114">114)</a> A comma operator does not yield an lvalue.
+</small>
<a name="6.6" href="#6.6"><h3>6.6 Constant expressions</h3></a>
<h6>Syntax</h6>
<p><!--para 11-->
The semantic rules for the evaluation of a constant expression are the same as for
nonconstant expressions.<sup><a href="#note118"><b>118)</b></a></sup>
-
Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+
<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>).
<!--page 125 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note115">115)</a> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
-
-<p><a name="note116">116)</a> The use of evaluation formats as characterized by FLT_EVAL_METHOD also applies to evaluation in
+<p><
small><a name="note115" href="#note115">115)</a> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
+</small>
+<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
the translation environment.
-
-<p><a name="note117">117)</a> An integer constant expression is required in a number of contexts such as the size of a bit-field
+</small>
+<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
member of a structure, the value of an enumeration constant, and the size of a non-variable length
array. Further constraints that apply to the integer constant expressions used in conditional-inclusion
preprocessing directives are discussed in <a href="#6.10.1">6.10.1</a>.
-
-<p><a name="note118">118)</a> Thus, in the following initialization,
+</small>
+<p><small><a name="note118" href="#note118">118)</a> Thus, in the following initialization,
<pre>
static int i = 2 || 1 / 0;</pre>
the expression is a valid integer constant expression with value one.
-
+</small>
<a name="6.7" href="#6.7"><h3>6.7 Declarations</h3></a>
<h6>Syntax</h6>
complete by the end of its declarator, or by the end of its init-declarator if it has an
initializer; in the case of function parameters (including in prototypes), it is the adjusted
type (see <a href="#6.7.6.3">6.7.6.3</a>) that is required to be complete.
-
Forward references: declarators (<a href="#6.7.6">6.7.6</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
+
<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
(<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>).
<h6>footnotes</h6>
-<p><
a name="note119">119)</a> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
-
+<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>.
+</small>
<a name="6.7.1" href="#6.7.1"><h4>6.7.1 Storage-class specifiers</h4></a>
<h6>Syntax</h6>
typedef, the properties resulting from the storage-class specifier, except with respect to
linkage, also apply to the members of the object, and so on recursively for any aggregate
or union member objects.
-
Forward references: type definitions (<a href="#6.7.8">6.7.8</a>).
+
<p><b> Forward references</b>: type definitions (<a href="#6.7.8">6.7.8</a>).
<h6>footnotes</h6>
-<p><
a name="note120">120)</a> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
-
-<p><a name="note121">121)</a> The implementation may treat any register declaration simply as an auto declaration. However,
+<p><
small><a name="note120" href="#note120">120)</a> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
+</small>
+<p><small><a name="note121" href="#note121">121)</a> The implementation may treat any register declaration simply as an auto declaration. However,
whether or not addressable storage is actually used, the address of any part of an object declared with
storage-class specifier register cannot be computed, either explicitly (by use of the unary &
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
<a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operator that can be applied to an array declared with storage-class specifier
register is sizeof.
-
+</small>
<a name="6.7.2" href="#6.7.2"><h4>6.7.2 Type specifiers</h4></a>
<h6>Syntax</h6>
Each of the comma-separated multisets designates the same type, except that for bit-
fields, it is implementation-defined whether the specifier int designates the same type as
signed int or the same type as unsigned int.
-
Forward references: 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>),
+
<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>),
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>).
<a name="6.7.2.1" href="#6.7.2.1"><h5>6.7.2.1 Structure and union specifiers</h5></a>
only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
of the structure, they might be copied or simply overwritten with indeterminate values.
-
Forward references: declarators (<a href="#6.7.6">6.7.6</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>).
+
<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>).
<!--page 134 indent 4-->
<h6>footnotes</h6>
-<p><a name="note122">122)</a> While the number of bits in a _Bool object is at least CHAR_BIT, the width (number of sign and
+<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
value bits) of a _Bool may be just 1 bit.
-
-<p><a name="note123">123)</a> A structure or union cannot contain a member with a variably modified type because member names
+</small>
+<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
are not ordinary identifiers as defined in <a href="#6.2.3">6.2.3</a>.
-
-<p><a name="note124">124)</a> The unary & (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
+</small>
+<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
or arrays of bit-field objects.
-
-<p><
a name="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,
+</small>
+<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,
then it is implementation-defined whether the bit-field is signed or unsigned.
-
-<p><a name="note126">126)</a> An unnamed bit-field structure member is useful for padding to conform to externally imposed
+</small>
+<p><small><a name="note126" href="#note126">126)</a> An unnamed bit-field structure member is useful for padding to conform to externally imposed
layouts.
-
+</small>
<a name="6.7.2.2" href="#6.7.2.2"><h5>6.7.2.2 Enumeration specifiers</h5></a>
<h6>Syntax</h6>
makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
-
Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
+
<p><b> Forward references</b>: tags (<a href="#6.7.2.3">6.7.2.3</a>).
<h6>footnotes</h6>
-<p><a name="note127">127)</a> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
+<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
each other and from other identifiers declared in ordinary declarators.
-
-<p><a name="note128">128)</a> An implementation may delay the choice of which integer type until all enumeration constants have
+</small>
+<p><small><a name="note128" href="#note128">128)</a> An implementation may delay the choice of which integer type until all enumeration constants have
been seen.
-
+</small>
<a name="6.7.2.3" href="#6.7.2.3"><h5>6.7.2.3 Tags</h5></a>
<h6>Constraints</h6>
may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
completes the specification of the new type.
-
Forward references: declarators (<a href="#6.7.6">6.7.6</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+
<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>).
<h6>footnotes</h6>
-<p><a name="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
+<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
needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
when a pointer to or a function returning a structure or union is being declared. (See incomplete types
in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
-
-<p><a name="note130">130)</a> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
+</small>
+<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
of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
can make use of that typedef name to declare objects having the specified structure, union, or
enumerated type.
-
-<p><a name="note131">131)</a> A similar construction with enum does not exist.
-
+</small>
+<p><small><a name="note131" href="#note131">131)</a> A similar construction with enum does not exist.
+</small>
<a name="6.7.2.4" href="#6.7.2.4"><h5>6.7.2.4 Atomic type specifiers</h5></a>
<h6>Syntax</h6>
<h6>footnotes</h6>
-<p><a name="note132">132)</a> The implementation may place a const object that is not volatile in a read-only region of
+<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
storage. Moreover, the implementation need not allocate storage for such an object if its address is
never used.
-
-<p><a name="note133">133)</a> This applies to those objects that behave as if they were defined with qualified types, even if they are
+</small>
+<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
never actually defined as objects in the program (such as an object at a memory-mapped input/output
address).
-
-<p><a name="note134">134)</a> A volatile declaration may be used to describe an object corresponding to a memory-mapped
+</small>
+<p><small><a name="note134" href="#note134">134)</a> A volatile declaration may be used to describe an object corresponding to a memory-mapped
input/output port or an object accessed by an asynchronously interrupting function. Actions on
objects so declared shall not be ''optimized out'' by an implementation or reordered except as
permitted by the rules for evaluating expressions.
-
-<p><a name="note135">135)</a> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
+</small>
+<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
association between the allocated object and the pointer.
-
-<p><a name="note136">136)</a> Both of these can occur through the use of typedefs.
-
+</small>
+<p><small><a name="note136" href="#note136">136)</a> Both of these can occur through the use of typedefs.
+</small>
<a name="6.7.3.1" href="#6.7.3.1"><h5>6.7.3.1 Formal definition of restrict</h5></a>
<p><!--para 1-->
<h6>footnotes</h6>
-<p><a name="note137">137)</a> In other words, E depends on the value of P itself rather than on the value of an object referenced
+<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
indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
expressions *p and p[1] are not.
-
+</small>
<a name="6.7.4" href="#6.7.4"><h4>6.7.4 Function specifiers</h4></a>
<h6>Syntax</h6>
if (i > 0) abort();
}</pre>
-
Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+
<p><b> Forward references</b>: function definitions (<a href="#6.9.1">6.9.1</a>).
<h6>footnotes</h6>
-<p><a name="note138">138)</a> By using, for example, an alternative to the usual function call mechanism, such as ''inline
+<p><small><a name="note138" href="#note138">138)</a> By using, for example, an alternative to the usual function call mechanism, such as ''inline
substitution''. Inline substitution is not textual substitution, nor does it create a new function.
Therefore, for example, the expansion of a macro used within the body of the function uses the
definition it had at the point the function body appears, and not where the function is called; and
identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
single address, regardless of the number of inline definitions that occur in addition to the external
definition.
-
-<p><a name="note139">139)</a> For example, an implementation might never perform inline substitution, or might only perform inline
+</small>
+<p><small><a name="note139" href="#note139">139)</a> For example, an implementation might never perform inline substitution, or might only perform inline
substitutions to calls in the scope of an inline declaration.
-
-<p><a name="note140">140)</a> Since an inline definition is distinct from the corresponding external definition and from any other
+</small>
+<p><small><a name="note140" href="#note140">140)</a> Since an inline definition is distinct from the corresponding external definition and from any other
corresponding inline definitions in other translation units, all corresponding objects with static storage
duration are also distinct in each of the definitions.
-
+</small>
<a name="6.7.5" href="#6.7.5"><h4>6.7.5 Alignment specifier</h4></a>
<h6>Syntax</h6>
<!--page 145 indent 4-->
<h6>footnotes</h6>
-<p><a name="note141">141)</a> An alignment specification of zero also does not affect other alignment specifications in the same
+<p><small><a name="note141" href="#note141">141)</a> An alignment specification of zero also does not affect other alignment specifications in the same
declaration.
-
+</small>
<a name="6.7.6" href="#6.7.6"><h4>6.7.6 Declarators</h4></a>
<h6>Syntax</h6>
As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
function declarators that modify an arithmetic, structure, union, or void type, either
directly or via one or more typedefs.
-
Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+
<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>).
<a name="6.7.6.1" href="#6.7.6.1"><h5>6.7.6.1 Pointer declarators</h5></a>
<h6>Semantics</h6>
static int (*q)[m] = &B; // valid: q is a static block pointer to VLA
}</pre>
-
Forward references: function declarators (<a href="#6.7.6.3">6.7.6.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
+
<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>),
initialization (<a href="#6.7.9">6.7.9</a>).
<h6>footnotes</h6>
-<p><a name="note142">142)</a> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
-
-<p><
a name="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>).
-
+<p><small><a name="note142" href="#note142">142)</a> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
+</small>
+<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>).
+</small>
<a name="6.7.6.3" href="#6.7.6.3"><h5>6.7.6.3 Function declarators (including prototypes)</h5></a>
<h6>Constraints</h6>
(Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
-
Forward references: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
+
<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>).
<!--page 153 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note144">144)</a> The macros defined in the <stdarg.h> header (<a href="#7.16">7.16</a>) may be used to access arguments that
+<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
correspond to the ellipsis.
-
-<p><
a name="note145">145)</a> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
-
-<p><a name="note146">146)</a> If both function types are ''old style'', parameter types are not compared.
-
+</small>
+<p><
small><a name="note145" href="#note145">145)</a> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
+</small>
+<p><small><a name="note146" href="#note146">146)</a> If both function types are ''old style'', parameter types are not compared.
+</small>
<a name="6.7.7" href="#6.7.7"><h4>6.7.7 Type names</h4></a>
<h6>Syntax</h6>
<!--page 154 indent 4-->
<h6>footnotes</h6>
-<p><a name="note147">147)</a> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
+<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
parameter specification'', rather than redundant parentheses around the omitted identifier.
-
+</small>
<a name="6.7.8" href="#6.7.8"><h4>6.7.8 Type definitions</h4></a>
<h6>Syntax</h6>
respect to one another and thus the order in which any side effects occur is
unspecified.<sup><a href="#note152"><b>152)</b></a></sup>
<p><!--para 24-->
- EXAMPLE 1 Provided that <complex.h> has been #included, the declarations
+ EXAMPLE 1 Provided that <a href="#7.3"><complex.h></a> has been #included, the declarations
<pre>
int i = <a href="#3.5">3.5</a>;
double complex c = 5 + 3 * I;</pre>
<pre>
union { /* ... */ } u = { .any_member = 42 };</pre>
-
Forward references: common definitions <stddef.h> (<a href="#7.19">7.19</a>).
+
<p><b> Forward references</b>: common definitions <a href="#7.19"><stddef.h></a> (<a href="#7.19">7.19</a>).
<!--page 162 indent 4-->
<h6>footnotes</h6>
-<p><a name="note148">148)</a> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
+<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
subobjects are initialized as usual, but the subaggregate or contained union does not become the
current object: current objects are associated only with brace-enclosed initializer lists.
-
-<p><a name="note149">149)</a> After a union member is initialized, the next object is not the next member of the union; instead, it is
+</small>
+<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
the next subobject of an object containing the union.
-
-<p><a name="note150">150)</a> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
+</small>
+<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
the surrounding brace pair. Note, too, that each separate designator list is independent.
-
-<p><a name="note151">151)</a> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
+</small>
+<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
not be evaluated at all.
-
-<p><a name="note152">152)</a> In particular, the evaluation order need not be the same as the order of subobject initialization.
-
+</small>
+<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.
+</small>
<a name="6.7.10" href="#6.7.10"><h4>6.7.10 Static assertions</h4></a>
<h6>Syntax</h6>
constraint is violated and the implementation shall produce a diagnostic message that
includes the text of the string literal, except that characters not in the basic source
character set are not required to appear in the message.
-
Forward references: diagnostics (<a href="#7.2">7.2</a>).
+
<p><b> Forward references</b>: diagnostics (<a href="#7.2">7.2</a>).
<!--page 163 indent 4-->
<a name="6.8" href="#6.8"><h3>6.8 Statements and blocks</h3></a>
of the (optional) expressions of a for statement; the (optional) expression in a return
statement. There is a sequence point between the evaluation of a full expression and the
evaluation of the next full expression to be evaluated.
-
Forward references: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
+
<p><b> Forward references</b>: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
(<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>).
<a name="6.8.1" href="#6.8.1"><h4>6.8.1 Labeled statements</h4></a>
Any statement may be preceded by a prefix that declares an identifier as a label name.
Labels in themselves do not alter the flow of control, which continues unimpeded across
them.
-
Forward references: 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>).
+
<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>).
<a name="6.8.2" href="#6.8.2"><h4>6.8.2 Compound statement</h4></a>
<h6>Syntax</h6>
end_loop1: ;
}</pre>
-
Forward references: iteration statements (<a href="#6.8.5">6.8.5</a>).
+
<p><b> Forward references</b>: iteration statements (<a href="#6.8.5">6.8.5</a>).
<h6>footnotes</h6>
-<p><a name="note153">153)</a> Such as assignments, and function calls which have side effects.
-
+<p><small><a name="note153" href="#note153">153)</a> Such as assignments, and function calls which have side effects.
+</small>
<a name="6.8.4" href="#6.8.4"><h4>6.8.4 Selection statements</h4></a>
<h6>Syntax</h6>
<h6>footnotes</h6>
-<p><a name="note154">154)</a> That is, the declaration either precedes the switch statement, or it follows the last case or
+<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
default label associated with the switch that is in the block containing the declaration.
-
+</small>
<a name="6.8.5" href="#6.8.5"><h4>6.8.5 Iteration statements</h4></a>
<h6>Syntax</h6>
terminate.<sup><a href="#note157"><b>157)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note155">155)</a> Code jumped over is not executed. In particular, the controlling expression of a for or while
+<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
statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
-
-<p><a name="note156">156)</a> An omitted controlling expression is replaced by a nonzero constant, which is a constant expression.
-
-<p><a name="note157">157)</a> This is intended to allow compiler transformations such as removal of empty loops even when
+</small>
+<p><small><a name="note156" href="#note156">156)</a> An omitted controlling expression is replaced by a nonzero constant, which is a constant expression.
+</small>
+<p><small><a name="note157" href="#note157">157)</a> This is intended to allow compiler transformations such as removal of empty loops even when
termination cannot be proven.
-
+</small>
<a name="6.8.5.1" href="#6.8.5.1"><h5>6.8.5.1 The while statement</h5></a>
<p><!--para 1-->
nonzero constant.
<h6>footnotes</h6>
-<p><a name="note158">158)</a> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
+<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
the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
such that execution of the loop continues until the expression compares equal to 0; and expression-3
specifies an operation (such as incrementing) that is performed after each iteration.
-
+</small>
<a name="6.8.6" href="#6.8.6"><h4>6.8.6 Jump statements</h4></a>
<h6>Syntax</h6>
case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note159"><b>159)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note159">159)</a> Following the contin: label is a null statement.
-
+<p><small><a name="note159" href="#note159">159)</a> Following the contin: label is a null statement.
+</small>
<a name="6.8.6.3" href="#6.8.6.3"><h5>6.8.6.3 The break statement</h5></a>
<h6>Constraints</h6>
<!--page 172 indent 4-->
<h6>footnotes</h6>
-<p><
a name="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
+<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
apply to the case of function return. The representation of floating-point values may have wider range
or precision than implied by the type; a cast may be used to remove this extra range and precision.
-
+</small>
<a name="6.9" href="#6.9"><h3>6.9 External definitions</h3></a>
<h6>Syntax</h6>
<!--page 173 indent 4-->
<h6>footnotes</h6>
-<p><a name="note161">161)</a> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
+<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
external definition for it.
-
+</small>
<a name="6.9.1" href="#6.9.1"><h4>6.9.1 Function definitions</h4></a>
<h6>Syntax</h6>
<h6>footnotes</h6>
-<p><a name="note162">162)</a> The intent is that the type category in a function definition cannot be inherited from a typedef:
+<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:
<pre>
typedef int F(void); // type F is ''function with no parameters
F *((e))(void) { /* ... */ } // same: parentheses irrelevant
int (*fp)(void); // fp points to a function that has type F
F *Fp; // Fp points to a function that has type F</pre>
-
-<p><
a name="note163">163)</a> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
-
-<p><a name="note164">164)</a> A parameter identifier cannot be redeclared in the function body except in an enclosed block.
-
+</small>
+<p><
small><a name="note163" href="#note163">163)</a> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
+</small>
+<p><small><a name="note164" href="#note164">164)</a> A parameter identifier cannot be redeclared in the function body except in an enclosed block.
+</small>
<a name="6.9.2" href="#6.9.2"><h4>6.9.2 External object definitions</h4></a>
<h6>Semantics</h6>
<h6>footnotes</h6>
-<p><a name="note165">165)</a> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
+<p><small><a name="note165" href="#note165">165)</a> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
significance, as all white space is equivalent except in certain situations during preprocessing (see the
# character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
-
+</small>
<a name="6.10.1" href="#6.10.1"><h4>6.10.1 Conditional inclusion</h4></a>
<h6>Constraints</h6>
expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
token conversion and evaluation, all signed integer types and all unsigned integer types
act as if they have the same representation as, respectively, the types intmax_t and
- uintmax_t defined in the header
<stdint.h>.<sup><a href="#note167"><b>167)</b></a></sup> This includes interpreting
+ 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
character constants, which may involve converting escape sequences into execution
character set members. Whether the numeric value for these character constants matches
the value obtained when an identical character constant occurs in an expression (other
processed. If none of the conditions evaluates to true, and there is a #else directive, the
group controlled by the #else is processed; lacking a #else directive, all the groups
until the #endif are skipped.<sup><a href="#note169"><b>169)</b></a></sup>
-
Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
+
<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
integer types (<a href="#7.20.1.5">7.20.1.5</a>).
<h6>footnotes</h6>
-<p><a name="note166">166)</a> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
+<p><small><a name="note166" href="#note166">166)</a> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
-
-<p><a name="note167">167)</a> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
+</small>
+<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
0x8000 is signed and positive within a #if expression even though it would be unsigned in
translation phase 7.
-
-<p><a name="note168">168)</a> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
+</small>
+<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
evaluate to the same value in these two contexts.
#if 'z' - 'a' == 25
if ('z' - 'a' == 25)
-
-<p><a name="note169">169)</a> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
+</small>
+<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
before the terminating new-line character. However, comments may appear anywhere in a source file,
including within a preprocessing directive.
-
+</small>
<a name="6.10.2" href="#6.10.2"><h4>6.10.2 Source file inclusion</h4></a>
<h6>Constraints</h6>
<p><!--para 7-->
EXAMPLE 1 The most common uses of #include preprocessing directives are as in the following:
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
#include "myprog.h"</pre>
#endif
#include INCFILE</pre>
-
Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>).
+
<p><b> Forward references</b>: macro replacement (<a href="#6.10.3">6.10.3</a>).
<h6>footnotes</h6>
-<p><a name="note170">170)</a> Note that adjacent string literals are not concatenated into a single string literal (see the translation
+<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
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.
-
+</small>
<a name="6.10.3" href="#6.10.3"><h4>6.10.3 Macro replacement</h4></a>
<h6>Constraints</h6>
definition (excluding the ...).
<h6>footnotes</h6>
-<p><a name="note171">171)</a> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
+<p><small><a name="note171" href="#note171">171)</a> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
are never scanned for macro names or parameters.
-
-<p><a name="note172">172)</a> Despite the name, a non-directive is a preprocessing directive.
-
+</small>
+<p><small><a name="note172" href="#note172">172)</a> Despite the name, a non-directive is a preprocessing directive.
+</small>
<a name="6.10.3.1" href="#6.10.3.1"><h5>6.10.3.1 Argument substitution</h5></a>
<p><!--para 1-->
<!--page 187 indent 4-->
<h6>footnotes</h6>
-<p><a name="note173">173)</a> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
+<p><small><a name="note173" href="#note173">173)</a> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
exist only within translation phase 4.
-
+</small>
<a name="6.10.3.4" href="#6.10.3.4"><h5>6.10.3.4 Rescanning and further replacement</h5></a>
<p><!--para 1-->
#pragma STDC CX_LIMITED_RANGE on-off-switch
on-off-switch: one of
ON OFF DEFAULT</pre>
-
Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
+
<p><b> Forward references</b>: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
(<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
<!--page 192 indent 4-->
<h6>footnotes</h6>
-<p><a name="note174">174)</a> An implementation is not required to perform macro replacement in pragmas, but it is permitted
+<p><small><a name="note174" href="#note174">174)</a> An implementation is not required to perform macro replacement in pragmas, but it is permitted
except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
but is not required to.
-
-<p><
a name="note175">175)</a> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
-
+</small>
+<p><
small><a name="note175" href="#note175">175)</a> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
+</small>
<a name="6.10.7" href="#6.10.7"><h4>6.10.7 Null directive</h4></a>
<h6>Semantics</h6>
<p><!--para 3-->
The implementation shall not predefine the macro __cplusplus, nor shall it define it
in any standard header.
-
Forward references: standard headers (<a href="#7.1.2">7.1.2</a>).
+
<p><b> Forward references</b>: standard headers (<a href="#7.1.2">7.1.2</a>).
<h6>footnotes</h6>
-<p><
a name="note176">176)</a> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
-
+<p><
small><a name="note176" href="#note176">176)</a> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
+</small>
<a name="6.10.8.1" href="#6.10.8.1"><h5>6.10.8.1 Mandatory macros</h5></a>
<p><!--para 1-->
string literal of the form "hh:mm:ss" as in the time generated by the
asctime function. If the time of translation is not available, an
implementation-defined valid time shall be supplied.</pre>
-
Forward references: the asctime function (<a href="#7.26.3.1">7.26.3.1</a>).
+
<p><b> Forward references</b>: the asctime function (<a href="#7.26.3.1">7.26.3.1</a>).
<h6>footnotes</h6>
-<p><a name="note177">177)</a> The presumed source file name and line number can be changed by the #line directive.
-
-<p><a name="note178">178)</a> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
+<p><small><a name="note177" href="#note177">177)</a> The presumed source file name and line number can be changed by the #line directive.
+</small>
+<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
ISO/IEC 9899/AMD1:1995 and as 199901L in ISO/IEC 9899:1999. The intention is that this will
remain an integer constant of type long int that is increased with each revision of this International
Standard.
-
+</small>
<a name="6.10.8.2" href="#6.10.8.2"><h5>6.10.8.2 Environment macros</h5></a>
<p><!--para 1-->
char32_t are UTF-32 encoded. If some other encoding is used, the
macro shall not be defined and the actual encoding used is implementation-
defined.</pre>
-
Forward references: common definitions (<a href="#7.19">7.19</a>), unicode utilities (<a href="#7.27">7.27</a>).
+
<p><b> Forward references</b>: common definitions (<a href="#7.19">7.19</a>), unicode utilities (<a href="#7.27">7.27</a>).
for the extensions defined in <a href="#K">annex K</a> (Bounds-checking interfaces).<sup><a href="#note179"><b>179)</b></a></sup></pre>
__STDC_NO_COMPLEX__ The integer constant 1, intended to indicate that the
<pre>
- implementation does not support complex types or the <complex.h>
+ implementation does not support complex types or the <a href="#7.3"><complex.h></a>
header.</pre>
__STDC_NO_THREADS__ The integer constant 1, intended to indicate that the
<pre>
implementation does not support atomic types (including the _Atomic
- type qualifier and the <stdatomic.h> header) or the <threads.h>
+ type qualifier and the <a href="#7.17"><stdatomic.h></a> header) or the <a href="#7.25"><threads.h></a>
header.</pre>
__STDC_NO_VLA__ The integer constant 1, intended to indicate that the
<p><!--para 2-->
__STDC_IEC_559_COMPLEX__.
<h6>footnotes</h6>
-<p><a name="note179">179)</a> The intention is that this will remain an integer constant of type long int that is increased with
+<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
each revision of this International Standard.
-
+</small>
<a name="6.10.9" href="#6.10.9"><h4>6.10.9 Pragma operator</h4></a>
<h6>Semantics</h6>
(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
corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
character.<sup><a href="#note181"><b>181)</b></a></sup>
-
Forward references: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+
<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>).
<!--page 198 indent 4-->
<h6>footnotes</h6>
-<p><a name="note180">180)</a> The functions that make use of the decimal-point character are the numeric conversion functions
+<p><small><a name="note180" href="#note180">180)</a> The functions that make use of the decimal-point character are the numeric conversion functions
(<a href="#7.22.1">7.22.1</a>, <a href="#7.28.4.1">7.28.4.1</a>) and the formatted input/output functions (<a href="#7.21.6">7.21.6</a>, <a href="#7.28.2">7.28.2</a>).
-
-<p><a name="note181">181)</a> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
+</small>
+<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
enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
sequence of maximum length. Whether these counts provide for more than one shift sequence is the
implementation's choice.
-
+</small>
<a name="7.1.2" href="#7.1.2"><h4>7.1.2 Standard headers</h4></a>
<p><!--para 1-->
The standard headers are<sup><a href="#note183"><b>183)</b></a></sup>
<p><!--para 3-->
<pre>
- <assert.h> <iso646.h> <stdarg.h> <string.h>
- <complex.h> <limits.h> <stdatomic.h> <tgmath.h>
- <ctype.h> <locale.h> <stdbool.h> <threads.h>
- <errno.h> <math.h> <stddef.h> <time.h>
- <fenv.h> <setjmp.h> <stdint.h> <uchar.h>
- <float.h> <signal.h> <stdio.h> <wchar.h>
- <inttypes.h> <stdalign.h> <stdlib.h> <wctype.h></pre>
+ <a href="#7.2"><assert.h></a> <a href="#7.9"><iso646.h></a> <a href="#7.16"><stdarg.h></a> <a href="#7.23"><string.h></a>
+ <a href="#7.3"><complex.h></a> <a href="#7.10"><limits.h></a> <a href="#7.17"><stdatomic.h></a> <a href="#7.24"><tgmath.h></a>
+ <a href="#7.4"><ctype.h></a> <a href="#7.11"><locale.h></a> <a href="#7.18"><stdbool.h></a> <a href="#7.25"><threads.h></a>
+ <a href="#7.5"><errno.h></a> <a href="#7.12"><math.h></a> <a href="#7.19"><stddef.h></a> <a href="#7.26"><time.h></a>
+ <a href="#7.6"><fenv.h></a> <a href="#7.13"><setjmp.h></a> <a href="#7.20"><stdint.h></a> <a href="#7.27"><uchar.h></a>
+ <a href="#7.7"><float.h></a> <a href="#7.14"><signal.h></a> <a href="#7.21"><stdio.h></a> <a href="#7.28"><wchar.h></a>
+ <a href="#7.8"><inttypes.h></a> <a href="#7.15"><stdalign.h></a> <a href="#7.22"><stdlib.h></a> <a href="#7.29"><wctype.h></a></pre>
If a file with the same name as one of the above < and > delimited sequences, not
provided as part of the implementation, is placed in any of the standard places that are
searched for included source files, the behavior is undefined.
<p><!--para 4-->
Standard headers may be included in any order; each may be included more than once in
a given scope, with no effect different from being included only once, except that the
- effect of including
<assert.h> depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
+ 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
used, a header shall be included outside of any external declaration or definition, and it
shall first be included before the first reference to any of the functions or objects it
declares, or to any of the types or macros it defines. However, if an identifier is declared
<!--page 199 indent 4-->
<p><!--para 7-->
A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
-
Forward references: diagnostics (<a href="#7.2">7.2</a>).
+
<p><b> Forward references</b>: diagnostics (<a href="#7.2">7.2</a>).
<h6>footnotes</h6>
-<p><a name="note182">182)</a> A header is not necessarily a source file, nor are the < and > delimited sequences in header names
+<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
necessarily valid source file names.
-
-<p><a name="note183">183)</a> The headers <complex.h>, <stdatomic.h>, and <threads.h> are conditional features that
+</small>
+<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.25"><threads.h></a> are conditional features that
implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.
-
+</small>
<a name="7.1.3" href="#7.1.3"><h4>7.1.3 Reserved identifiers</h4></a>
<p><!--para 1-->
<!--page 200 indent 4-->
<h6>footnotes</h6>
-<p><a name="note184">184)</a> The list of reserved identifiers with external linkage includes math_errhandling, setjmp,
+<p><small><a name="note184" href="#note184">184)</a> The list of reserved identifiers with external linkage includes math_errhandling, setjmp,
va_copy, and va_end.
-
+</small>
<a name="7.1.4" href="#7.1.4"><h4>7.1.4 Use of library functions</h4></a>
<p><!--para 1-->
<ul>
<li> by use of its associated header (possibly generating a macro expansion)
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
const char *str;
/* ... */
i = atoi(str);</pre>
<!--page 202 indent 0-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
#undef atoi
const char *str;
/* ... */
i = atoi(str);</pre>
or
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
const char *str;
/* ... */
i = (atoi)(str);</pre>
</ul>
<h6>footnotes</h6>
-<p><a name="note185">185)</a> This means that an implementation shall provide an actual function for each library function, even if it
+<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
also provides a macro for that function.
-
-<p><a name="note186">186)</a> Such macros might not contain the sequence points that the corresponding function calls do.
-
-<p><a name="note187">187)</a> Because external identifiers and some macro names beginning with an underscore are reserved,
+</small>
+<p><small><a name="note186" href="#note186">186)</a> Such macros might not contain the sequence points that the corresponding function calls do.
+</small>
+<p><small><a name="note187" href="#note187">187)</a> Because external identifiers and some macro names beginning with an underscore are reserved,
implementations may provide special semantics for such names. For example, the identifier
_BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
appropriate header could specify
#undef abs</pre>
whether the implementation's header provides a macro implementation of abs or a built-in
implementation. The prototype for the function, which precedes and is hidden by any macro
- definition, is thereby revealed also.
-
-<p><a name="note188">188)</a> Thus, a signal handler cannot, in general, call standard library functions.
-
-<p><a name="note189">189)</a> This means, for example, that an implementation is not permitted to use a static object for internal
+ definition, is thereby revealed also.
+</small>
+<p><small><a name="note188" href="#note188">188)</a> Thus, a signal handler cannot, in general, call standard library functions.
+</small>
+<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
purposes without synchronization because it could cause a data race even in programs that do not
explicitly share objects between threads.
-
-<p><a name="note190">190)</a> This allows implementations to parallelize operations if there are no visible side effects.
-
+</small>
+<p><small><a name="note190" href="#note190">190)</a> This allows implementations to parallelize operations if there are no visible side effects.
+</small>
<a name="7.2" href="#7.2"><h3>7.2 Diagnostics <assert.h></h3></a>
<p><!--para 1-->
- The header <assert.h> defines the assert and static_assert macros and
+ The header <a href="#7.2"><assert.h></a> defines the assert and static_assert macros and
refers to another macro,
<pre>
NDEBUG</pre>
- which is not defined by <assert.h>. If NDEBUG is defined as a macro name at the
- point in the source file where <assert.h> is included, the assert macro is defined
+ which is not defined by <a href="#7.2"><assert.h></a>. If NDEBUG is defined as a macro name at the
+ point in the source file where <a href="#7.2"><assert.h></a> is included, the assert macro is defined
simply as
<pre>
#define assert(ignore) ((void)0)</pre>
The assert macro is redefined according to the current state of NDEBUG each time that
- <assert.h> is included.
+ <a href="#7.2"><assert.h></a> is included.
<p><!--para 2-->
The assert macro shall be implemented as a macro, not as an actual function. If the
macro definition is suppressed in order to access an actual function, the behavior is
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <assert.h>
+ #include <a href="#7.2"><assert.h></a>
void assert(scalar expression);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Returns</h6>
<p><!--para 3-->
The assert macro returns no value.
-
Forward references: the abort function (<a href="#7.22.4.1">7.22.4.1</a>).
+
<p><b> Forward references</b>: the abort function (<a href="#7.22.4.1">7.22.4.1</a>).
<!--page 205 indent 4-->
<h6>footnotes</h6>
-<p><a name="note191">191)</a> The message written might be of the form:
+<p><small><a name="note191" href="#note191">191)</a> The message written might be of the form:
Assertion failed: expression, function abc, file xyz, line nnn.
-
+</small>
<a name="7.3" href="#7.3"><h3>7.3 Complex arithmetic <complex.h></h3></a>
<a name="7.3.1" href="#7.3.1"><h4>7.3.1 Introduction</h4></a>
<p><!--para 1-->
- The header <complex.h> defines macros and declares functions that support complex
+ The header <a href="#7.3"><complex.h></a> defines macros and declares functions that support complex
arithmetic.<sup><a href="#note192"><b>192)</b></a></sup>
<p><!--para 2-->
Implementations that define the macro __STDC_NO_COMPLEX__ need not provide
redefine the macros complex, imaginary, and I.
<!--page 206 indent 4-->
-
Forward references: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
+
<p><b> Forward references</b>: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
<h6>footnotes</h6>
-<p><
a name="note192">192)</a> See ''future library directions'' (<a href="#7.30.1">7.30.1</a>).
-
-<p><a name="note193">193)</a> The imaginary unit is a number i such that i 2 = -1.
-
-<p><
a name="note194">194)</a> A specification for imaginary types is in informative <a href="#G">annex G</a>.
-
+<p><
small><a name="note192" href="#note192">192)</a> See ''future library directions'' (<a href="#7.30.1">7.30.1</a>).
+</small>
+<p><small><a name="note193" href="#note193">193)</a> The imaginary unit is a number i such that i 2 = -1.
+</small>
+<p><
small><a name="note194" href="#note194">194)</a> A specification for imaginary types is in informative <a href="#G">annex G</a>.
+</small>
<a name="7.3.2" href="#7.3.2"><h4>7.3.2 Conventions</h4></a>
<p><!--para 1-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
#pragma STDC CX_LIMITED_RANGE on-off-switch</pre>
<h6>Description</h6>
<p><!--para 2-->
undefined. The default state for the pragma is ''off''.
<h6>footnotes</h6>
-<p><a name="note195">195)</a> The purpose of the pragma is to allow the implementation to use the formulas:
+<p><small><a name="note195" href="#note195">195)</a> The purpose of the pragma is to allow the implementation to use the formulas:
<pre>
(x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
| x + iy | = (sqrt) x 2 + y 2
-----</pre>
where the programmer can determine they are safe.
-
+</small>
<a name="7.3.5" href="#7.3.5"><h4>7.3.5 Trigonometric functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex cacos(double complex z);
float complex cacosf(float complex z);
long double complex cacosl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex casin(double complex z);
float complex casinf(float complex z);
long double complex casinl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex catan(double complex z);
float complex catanf(float complex z);
long double complex catanl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex ccos(double complex z);
float complex ccosf(float complex z);
long double complex ccosl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex csin(double complex z);
float complex csinf(float complex z);
long double complex csinl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex ctan(double complex z);
float complex ctanf(float complex z);
long double complex ctanl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex cacosh(double complex z);
float complex cacoshf(float complex z);
long double complex cacoshl(long double complex z);</pre>
<p><!--para 1-->
<!--page 210 indent 4-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex casinh(double complex z);
float complex casinhf(float complex z);
long double complex casinhl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex catanh(double complex z);
float complex catanhf(float complex z);
long double complex catanhl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex ccosh(double complex z);
float complex ccoshf(float complex z);
long double complex ccoshl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex csinh(double complex z);
float complex csinhf(float complex z);
long double complex csinhl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex ctanh(double complex z);
float complex ctanhf(float complex z);
long double complex ctanhl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex cexp(double complex z);
float complex cexpf(float complex z);
long double complex cexpl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex clog(double complex z);
float complex clogf(float complex z);
long double complex clogl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double cabs(double complex z);
float cabsf(float complex z);
long double cabsl(long double complex z);</pre>
<p><!--para 1-->
<!--page 213 indent 4-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex cpow(double complex x, double complex y);
float complex cpowf(float complex x, float complex y);
long double complex cpowl(long double complex x,
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex csqrt(double complex z);
float complex csqrtf(float complex z);
long double complex csqrtl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double carg(double complex z);
float cargf(float complex z);
long double cargl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double cimag(double complex z);
float cimagf(float complex z);
long double cimagl(long double complex z);</pre>
The cimag functions return the imaginary part value (as a real).
<h6>footnotes</h6>
-<p><a name="note196">196)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
-
+<p><small><a name="note196" href="#note196">196)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+</small>
<a name="7.3.9.3" href="#7.3.9.3"><h5>7.3.9.3 The CMPLX macros</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex CMPLX(double x, double y);
float complex CMPLXF(float x, float y);
long double complex CMPLXL(long double x, long double y);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex conj(double complex z);
float complex conjf(float complex z);
long double complex conjl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double complex cproj(double complex z);
float complex cprojf(float complex z);
long double complex cprojl(long double complex z);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <complex.h>
+ #include <a href="#7.3"><complex.h></a>
double creal(double complex z);
float crealf(float complex z);
long double creall(long double complex z);</pre>
<!--page 217 indent 4-->
<h6>footnotes</h6>
-<p><a name="note197">197)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
-
+<p><small><a name="note197" href="#note197">197)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+</small>
<a name="7.4" href="#7.4"><h3>7.4 Character handling <ctype.h></h3></a>
<p><!--para 1-->
- The header <ctype.h> declares several functions useful for classifying and mapping
+ The header <a href="#7.4"><ctype.h></a> declares several functions useful for classifying and mapping
characters.<sup><a href="#note198"><b>198)</b></a></sup> In all cases the argument is an int, the value of which shall be
representable as an unsigned char or shall equal the value of the macro EOF. If the
argument has any other value, the behavior is undefined.
of which occupies one printing position on a display device; the term control character
refers to a member of a locale-specific set of characters that are not printing
characters.<sup><a href="#note199"><b>199)</b></a></sup> All letters and digits are printing characters.
-
Forward references: EOF (<a href="#7.21.1">7.21.1</a>), localization (<a href="#7.11">7.11</a>).
+
<p><b> Forward references</b>: EOF (<a href="#7.21.1">7.21.1</a>), localization (<a href="#7.11">7.11</a>).
<h6>footnotes</h6>
-<p><
a name="note198">198)</a> See ''future library directions'' (<a href="#7.30.2">7.30.2</a>).
-
-<p><a name="note199">199)</a> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
+<p><
small><a name="note198" href="#note198">198)</a> See ''future library directions'' (<a href="#7.30.2">7.30.2</a>).
+</small>
+<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
whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
-
+</small>
<a name="7.4.1" href="#7.4.1"><h4>7.4.1 Character classification functions</h4></a>
<p><!--para 1-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isalnum(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isalpha(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
isalpha returns true only for the characters for which isupper or islower is true.
<h6>footnotes</h6>
-<p><a name="note200">200)</a> The functions islower and isupper test true or false separately for each of these additional
+<p><small><a name="note200" href="#note200">200)</a> The functions islower and isupper test true or false separately for each of these additional
characters; all four combinations are possible.
-
+</small>
<a name="7.4.1.3" href="#7.4.1.3"><h5>7.4.1.3 The isblank function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isblank(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int iscntrl(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isdigit(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isgraph(int c);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int islower(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isprint(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int ispunct(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isspace(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isupper(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int isxdigit(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int tolower(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <ctype.h>
+ #include <a href="#7.4"><ctype.h></a>
int toupper(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<a name="7.5" href="#7.5"><h3>7.5 Errors <errno.h></h3></a>
<p><!--para 1-->
- The header <errno.h> defines several macros, all relating to the reporting of error
+ The header <a href="#7.5"><errno.h></a> defines several macros, all relating to the reporting of error
conditions.
<p><!--para 2-->
The macros are
<!--page 223 indent 4-->
<h6>footnotes</h6>
-<p><a name="note201">201)</a> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
+<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
resulting from a function call (for example, *errno()).
-
-<p><a name="note202">202)</a> Thus, a program that uses errno for error checking should set it to zero before a library function call,
+</small>
+<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,
then inspect it before a subsequent library function call. Of course, a library function can save the
value of errno on entry and then set it to zero, as long as the original value is restored if errno's
value is still zero just before the return.
-
-<p><
a name="note203">203)</a> See ''future library directions'' (<a href="#7.30.3">7.30.3</a>).
-
+</small>
+<p><
small><a name="note203" href="#note203">203)</a> See ''future library directions'' (<a href="#7.30.3">7.30.3</a>).
+</small>
<a name="7.6" href="#7.6"><h3>7.6 Floating-point environment <fenv.h></h3></a>
<p><!--para 1-->
- The header <fenv.h> defines several macros, and declares types and functions that
+ The header <a href="#7.6"><fenv.h></a> defines several macros, and declares types and functions that
provide access to the floating-point environment. The floating-point environment refers
collectively to any floating-point status flags and control modes supported by the
implementation.<sup><a href="#note204"><b>204)</b></a></sup> A floating-point status flag is a system variable whose value is set
<ul>
<li> and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
</ul>
- <fenv.h> functions that manage the floating-point environment.
+ <a href="#7.6"><fenv.h></a> functions that manage the floating-point environment.
<p><!--para 10-->
Additional implementation-defined environments, with macro definitions beginning with
FE_ and an uppercase letter, and having type ''pointer to const-qualified fenv_t'', may
also be specified by the implementation.
<h6>footnotes</h6>
-<p><a name="note204">204)</a> This header is designed to support the floating-point exception status flags and directed-rounding
+<p><small><a name="note204" href="#note204">204)</a> This header is designed to support the floating-point exception status flags and directed-rounding
control modes required by IEC 60559, and other similar floating-point state information. It is also
designed to facilitate code portability among all systems.
-
-<p><a name="note205">205)</a> A floating-point status flag is not an object and can be set more than once within an expression.
-
-<p><a name="note206">206)</a> With these conventions, a programmer can safely assume default floating-point control modes (or be
+</small>
+<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.
+</small>
+<p><small><a name="note206" href="#note206">206)</a> With these conventions, a programmer can safely assume default floating-point control modes (or be
unaware of them). The responsibilities associated with accessing the floating-point environment fall
on the programmer or program that does so explicitly.
-
-<p><a name="note207">207)</a> The implementation supports a floating-point exception if there are circumstances where a call to at
+</small>
+<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
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
necessary for all the functions to succeed all the time.
-
-<p><a name="note208">208)</a> The macros should be distinct powers of two.
-
-<p><a name="note209">209)</a> Even though the rounding direction macros may expand to constants corresponding to the values of
+</small>
+<p><small><a name="note208" href="#note208">208)</a> The macros should be distinct powers of two.
+</small>
+<p><small><a name="note209" href="#note209">209)</a> Even though the rounding direction macros may expand to constants corresponding to the values of
FLT_ROUNDS, they are not required to do so.
-
+</small>
<a name="7.6.1" href="#7.6.1"><h4>7.6.1 The FENV_ACCESS pragma</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS on-off-switch</pre>
<h6>Description</h6>
<p><!--para 2-->
EXAMPLE
<p><!--para 4-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
void f(double x)
{
#pragma STDC FENV_ACCESS ON
<h6>footnotes</h6>
-<p><a name="note210">210)</a> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
+<p><small><a name="note210" href="#note210">210)</a> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
modes are in effect and the flags are not tested.
-
-<p><a name="note211">211)</a> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
+</small>
+<p><small><a name="note211" href="#note211">211)</a> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
''off'', just one evaluation of x + 1 would suffice.
-
+</small>
<a name="7.6.2" href="#7.6.2"><h4>7.6.2 Floating-point exceptions</h4></a>
<p><!--para 1-->
functions is undefined.
<h6>footnotes</h6>
-<p><a name="note212">212)</a> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
+<p><small><a name="note212" href="#note212">212)</a> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
abstraction of flags that are either set or clear. An implementation may endow floating-point status
flags with more information -- for example, the address of the code which first raised the floating-
point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
content of flags.
-
+</small>
<a name="7.6.2.1" href="#7.6.2.1"><h5>7.6.2.1 The feclearexcept function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int feclearexcept(int excepts);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int fegetexceptflag(fexcept_t *flagp,
int excepts);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int feraiseexcept(int excepts);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 228 indent 4-->
<h6>footnotes</h6>
-<p><a name="note213">213)</a> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
+<p><small><a name="note213" href="#note213">213)</a> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
in <a href="#F.8.6">F.8.6</a> is in the same spirit.
-
+</small>
<a name="7.6.2.4" href="#7.6.2.4"><h5>7.6.2.4 The fesetexceptflag function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int fesetexceptflag(const fexcept_t *flagp,
int excepts);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int fetestexcept(int excepts);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 229 indent 4-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
/* ... */
{
#pragma STDC FENV_ACCESS ON
<h6>footnotes</h6>
-<p><a name="note214">214)</a> This mechanism allows testing several floating-point exceptions with just one function call.
-
+<p><small><a name="note214" href="#note214">214)</a> This mechanism allows testing several floating-point exceptions with just one function call.
+</small>
<a name="7.6.3" href="#7.6.3"><h4>7.6.3 Rounding</h4></a>
<p><!--para 1-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int fegetround(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int fesetround(int round);</pre>
<h6>Description</h6>
<p><!--para 2-->
EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
rounding direction fails.
<pre>
- #include <fenv.h>
- #include <assert.h>
+ #include <a href="#7.6"><fenv.h></a>
+ #include <a href="#7.2"><assert.h></a>
void f(int round_dir)
{
#pragma STDC FENV_ACCESS ON
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int fegetenv(fenv_t *envp);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int feholdexcept(fenv_t *envp);</pre>
<h6>Description</h6>
<p><!--para 2-->
exception handling was successfully installed.
<h6>footnotes</h6>
-<p><a name="note215">215)</a> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
+<p><small><a name="note215" href="#note215">215)</a> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
such systems, the feholdexcept function can be used in conjunction with the feupdateenv
function to write routines that hide spurious floating-point exceptions from their callers.
-
+</small>
<a name="7.6.4.3" href="#7.6.4.3"><h5>7.6.4.3 The fesetenv function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int fesetenv(const fenv_t *envp);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
int feupdateenv(const fenv_t *envp);</pre>
<h6>Description</h6>
<p><!--para 2-->
EXAMPLE Hide spurious underflow floating-point exceptions:
<!--page 233 indent 4-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
double f(double x)
{
#pragma STDC FENV_ACCESS ON
<a name="7.7" href="#7.7"><h3>7.7 Characteristics of floating types <float.h></h3></a>
<p><!--para 1-->
- The header <float.h> defines several macros that expand to various limits and
+ The header <a href="#7.7"><float.h></a> defines several macros that expand to various limits and
parameters of the standard floating-point types.
<p><!--para 2-->
The macros, their meanings, and the constraints (or restrictions) on their values are listed
<a name="7.8" href="#7.8"><h3>7.8 Format conversion of integer types <inttypes.h></h3></a>
<p><!--para 1-->
- The header <inttypes.h> includes the header <stdint.h> and extends it with
+ The header <a href="#7.8"><inttypes.h></a> includes the header <a href="#7.20"><stdint.h></a> and extends it with
additional facilities provided by hosted implementations.
<p><!--para 2-->
It declares functions for manipulating greatest-width integers and converting numeric
<pre>
imaxdiv_t</pre>
which is a structure type that is the type of the value returned by the imaxdiv function.
- For each type declared in <stdint.h>, it defines corresponding macros for conversion
+ For each type declared in <a href="#7.20"><stdint.h></a>, it defines corresponding macros for conversion
specifiers for use with the formatted input/output functions.<sup><a href="#note216"><b>216)</b></a></sup>
-
Forward references: integer types <stdint.h> (<a href="#7.20">7.20</a>), formatted input/output
+
<p><b> Forward references</b>: integer types <a href="#7.20"><stdint.h></a> (<a href="#7.20">7.20</a>), formatted input/output
functions (<a href="#7.21.6">7.21.6</a>), formatted wide character input/output functions (<a href="#7.28.2">7.28.2</a>).
<h6>footnotes</h6>
-<p><
a name="note216">216)</a> See ''future library directions'' (<a href="#7.30.4">7.30.4</a>).
-
+<p><
small><a name="note216" href="#note216">216)</a> See ''future library directions'' (<a href="#7.30.4">7.30.4</a>).
+</small>
<a name="7.8.1" href="#7.8.1"><h4>7.8.1 Macros for format specifiers</h4></a>
<p><!--para 1-->
SCNoN SCNoLEASTN SCNoFASTN SCNoMAX SCNoPTR
SCNuN SCNuLEASTN SCNuFASTN SCNuMAX SCNuPTR
SCNxN SCNxLEASTN SCNxFASTN SCNxMAX SCNxPTR</pre>
- For each type that the implementation provides in <stdint.h>, the corresponding
+ For each type that the implementation provides in <a href="#7.20"><stdint.h></a>, the corresponding
fprintf macros shall be defined and the corresponding fscanf macros shall be
defined unless the implementation does not have a suitable fscanf length modifier for
the type.
<p><!--para 7-->
EXAMPLE
<pre>
- #include <inttypes.h>
- #include <wchar.h>
+ #include <a href="#7.8"><inttypes.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int main(void)
{
uintmax_t i = UINTMAX_MAX; // this type always exists
<h6>footnotes</h6>
-<p><a name="note217">217)</a> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
+<p><small><a name="note217" href="#note217">217)</a> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
different format specifiers may be required for fprintf and fscanf, even when the type is the
same.
-
+</small>
<a name="7.8.2" href="#7.8.2"><h4>7.8.2 Functions for greatest-width integer types</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <inttypes.h>
+ #include <a href="#7.8"><inttypes.h></a>
intmax_t imaxabs(intmax_t j);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 236 indent 4-->
<h6>footnotes</h6>
-<p><a name="note218">218)</a> The absolute value of the most negative number cannot be represented in two's complement.
-
+<p><small><a name="note218" href="#note218">218)</a> The absolute value of the most negative number cannot be represented in two's complement.
+</small>
<a name="7.8.2.2" href="#7.8.2.2"><h5>7.8.2.2 The imaxdiv function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <inttypes.h>
+ #include <a href="#7.8"><inttypes.h></a>
imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <inttypes.h>
+ #include <a href="#7.8"><inttypes.h></a>
intmax_t strtoimax(const char * restrict nptr,
char ** restrict endptr, int base);
uintmax_t strtoumax(const char * restrict nptr,
of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
(according to the return type and sign of the value, if any), and the value of the macro
ERANGE is stored in errno.
- Forward references: the strtol, strtoll, strtoul, and strtoull functions
+<p><b> Forward references</b>: the strtol, strtoll, strtoul, and strtoull functions
(<a href="#7.22.1.4">7.22.1.4</a>).
<!--page 237 indent 4-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stddef.h> // for wchar_t
- #include <inttypes.h>
+ #include <a href="#7.19"><stddef.h></a> // for wchar_t
+ #include <a href="#7.8"><inttypes.h></a>
intmax_t wcstoimax(const wchar_t * restrict nptr,
wchar_t ** restrict endptr, int base);
uintmax_t wcstoumax(const wchar_t * restrict nptr,
values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
return type and sign of the value, if any), and the value of the macro ERANGE is stored in
errno.
- Forward references: the wcstol, wcstoll, wcstoul, and wcstoull functions
+<p><b> Forward references</b>: the wcstol, wcstoll, wcstoul, and wcstoull functions
(<a href="#7.28.4.1.2">7.28.4.1.2</a>).
<!--page 238 indent 4-->
<a name="7.9" href="#7.9"><h3>7.9 Alternative spellings <iso646.h></h3></a>
<p><!--para 1-->
- The header <iso646.h> defines the following eleven macros (on the left) that expand
+ The header <a href="#7.9"><iso646.h></a> defines the following eleven macros (on the left) that expand
to the corresponding tokens (on the right):
<!--page 239 indent 4-->
<pre>
<a name="7.10" href="#7.10"><h3>7.10 Sizes of integer types <limits.h></h3></a>
<p><!--para 1-->
- The header <limits.h> defines several macros that expand to various limits and
+ The header <a href="#7.10"><limits.h></a> defines several macros that expand to various limits and
parameters of the standard integer types.
<p><!--para 2-->
The macros, their meanings, and the constraints (or restrictions) on their values are listed
<a name="7.11" href="#7.11"><h3>7.11 Localization <locale.h></h3></a>
<p><!--para 1-->
- The header <locale.h> declares two functions, one type, and defines several macros.
+ The header <a href="#7.11"><locale.h></a> declares two functions, one type, and defines several macros.
<p><!--para 2-->
The type is
<pre>
implementation.
<h6>footnotes</h6>
-<p><a name="note219">219)</a> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
-
-<p><
a name="note220">220)</a> See ''future library directions'' (<a href="#7.30.5">7.30.5</a>).
-
+<p><small><a name="note219" href="#note219">219)</a> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
+</small>
+<p><
small><a name="note220" href="#note220">220)</a> See ''future library directions'' (<a href="#7.30.5">7.30.5</a>).
+</small>
<a name="7.11.1" href="#7.11.1"><h4>7.11.1 Locale control</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <locale.h>
+ #include <a href="#7.11"><locale.h></a>
char *setlocale(int category, const char *locale);</pre>
<h6>Description</h6>
<p><!--para 2-->
with that string value and its associated category will restore that part of the program's
locale. The string pointed to shall not be modified by the program, but may be
overwritten by a subsequent call to the setlocale function.
-
Forward references: formatted input/output functions (<a href="#7.21.6">7.21.6</a>), multibyte/wide
+
<p><b> Forward references</b>: formatted input/output functions (<a href="#7.21.6">7.21.6</a>), multibyte/wide
character conversion functions (<a href="#7.22.7">7.22.7</a>), multibyte/wide string conversion functions
(<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.23.4.3">7.23.4.3</a>), the
strftime function (<a href="#7.26.3.5">7.26.3.5</a>), the strxfrm function (<a href="#7.23.4.5">7.23.4.5</a>).
<h6>footnotes</h6>
-<p><
a name="note221">221)</a> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
+<p><
small><a name="note221" href="#note221">221)</a> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
isxdigit.
-
-<p><a name="note222">222)</a> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
+</small>
+<p><small><a name="note222" href="#note222">222)</a> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
locale when category has the value LC_ALL.
-
+</small>
<a name="7.11.2" href="#7.11.2"><h4>7.11.2 Numeric formatting convention inquiry</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <locale.h>
+ #include <a href="#7.11"><locale.h></a>
struct lconv *localeconv(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
<a name="7.12" href="#7.12"><h3>7.12 Mathematics <math.h></h3></a>
<p><!--para 1-->
- The header <math.h> declares two types and many mathematical functions and defines
+ The header <a href="#7.12"><math.h></a> declares two types and many mathematical functions and defines
several macros. Most synopses specify a family of functions consisting of a principal
function with one or more double parameters, a double return value, or both; and
other functions with the same name but with f and l suffixes, which are corresponding
math_errhandling, the behavior is undefined. If the expression
math_errhandling & MATH_ERREXCEPT can be nonzero, the implementation
shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
- <fenv.h>.
+ <a href="#7.6"><fenv.h></a>.
<h6>footnotes</h6>
-<p><a name="note223">223)</a> Particularly on systems with wide expression evaluation, a <math.h> function might pass arguments
+<p><small><a name="note223" href="#note223">223)</a> Particularly on systems with wide expression evaluation, a <a href="#7.12"><math.h></a> function might pass arguments
and return values in wider format than the synopsis prototype indicates.
-
-<p><a name="note224">224)</a> The types float_t and double_t are intended to be the implementation's most efficient types at
+</small>
+<p><small><a name="note224" href="#note224">224)</a> The types float_t and double_t are intended to be the implementation's most efficient types at
least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
type float_t is the narrowest type used by the implementation to evaluate floating expressions.
-
-<p><a name="note225">225)</a> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
+</small>
+<p><small><a name="note225" href="#note225">225)</a> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
supports infinities.
-
-<p><
a name="note226">226)</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.
-
-<p><a name="note227">227)</a> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
+</small>
+<p><
small><a name="note226" href="#note226">226)</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.
+</small>
+<p><small><a name="note227" href="#note227">227)</a> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
directly with a hardware multiply-add instruction. Software implementations are expected to be
substantially slower.
-
+</small>
<a name="7.12.1" href="#7.12.1"><h4>7.12.1 Treatment of error conditions</h4></a>
<p><!--para 1-->
- The behavior of each of the functions in <math.h> is specified for all representable
+ The behavior of each of the functions in <a href="#7.12"><math.h></a> is specified for all representable
values of its input arguments, except where stated otherwise. Each function shall execute
as if it were a single operation without raising SIGFPE and without generating any of the
floating-point exceptions ''invalid'', ''divide-by-zero'', or ''overflow'' except to reflect
<!--page 252 indent 4-->
<h6>footnotes</h6>
-<p><a name="note228">228)</a> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
+<p><small><a name="note228" href="#note228">228)</a> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
error if the mathematical domain of the function does not include the infinity.
-
-<p><a name="note229">229)</a> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
+</small>
+<p><small><a name="note229" href="#note229">229)</a> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
also ''flush-to-zero'' underflow.
-
-<p><a name="note230">230)</a> Math errors are being indicated by the floating-point exception flags rather than by errno.
-
+</small>
+<p><small><a name="note230" href="#note230">230)</a> Math errors are being indicated by the floating-point exception flags rather than by errno.
+</small>
<a name="7.12.2" href="#7.12.2"><h4>7.12.2 The FP_CONTRACT pragma</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
#pragma STDC FP_CONTRACT on-off-switch</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int fpclassify(real-floating x);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 253 indent 4-->
<h6>footnotes</h6>
-<p><a name="note231">231)</a> Since an expression can be evaluated with more range and precision than its type has, it is important to
+<p><small><a name="note231" href="#note231">231)</a> Since an expression can be evaluated with more range and precision than its type has, it is important to
know the type that classification is based on. For example, a normal long double value might
become subnormal when converted to double, and zero when converted to float.
-
+</small>
<a name="7.12.3.2" href="#7.12.3.2"><h5>7.12.3.2 The isfinite macro</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isfinite(real-floating x);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isinf(real-floating x);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isnan(real-floating x);</pre>
<h6>Description</h6>
<p><!--para 2-->
The isnan macro returns a nonzero value if and only if its argument has a NaN value.
<h6>footnotes</h6>
-<p><a name="note232">232)</a> For the isnan macro, the type for determination does not matter unless the implementation supports
+<p><small><a name="note232" href="#note232">232)</a> For the isnan macro, the type for determination does not matter unless the implementation supports
NaNs in the evaluation type but not in the semantic type.
-
+</small>
<a name="7.12.3.5" href="#7.12.3.5"><h5>7.12.3.5 The isnormal macro</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isnormal(real-floating x);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int signbit(real-floating x);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 255 indent 4-->
<h6>footnotes</h6>
-<p><a name="note233">233)</a> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
+<p><small><a name="note233" href="#note233">233)</a> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
unsigned, it is treated as positive.
-
+</small>
<a name="7.12.4" href="#7.12.4"><h4>7.12.4 Trigonometric functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double acos(double x);
float acosf(float x);
long double acosl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double asin(double x);
float asinf(float x);
long double asinl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double atan(double x);
float atanf(float x);
long double atanl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double atan2(double y, double x);
float atan2f(float y, float x);
long double atan2l(long double y, long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double cos(double x);
float cosf(float x);
long double cosl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double sin(double x);
float sinf(float x);
long double sinl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double tan(double x);
float tanf(float x);
long double tanl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double acosh(double x);
float acoshf(float x);
long double acoshl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double asinh(double x);
float asinhf(float x);
long double asinhl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double atanh(double x);
float atanhf(float x);
long double atanhl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double cosh(double x);
float coshf(float x);
long double coshl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double sinh(double x);
float sinhf(float x);
long double sinhl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double tanh(double x);
float tanhf(float x);
long double tanhl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double exp(double x);
float expf(float x);
long double expl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double exp2(double x);
float exp2f(float x);
long double exp2l(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double expm1(double x);
float expm1f(float x);
long double expm1l(long double x);</pre>
The expm1 functions return ex - 1.
<h6>footnotes</h6>
-<p><a name="note234">234)</a> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
-
+<p><small><a name="note234" href="#note234">234)</a> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
+</small>
<a name="7.12.6.4" href="#7.12.6.4"><h5>7.12.6.4 The frexp functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double frexp(double value, int *exp);
float frexpf(float value, int *exp);
long double frexpl(long double value, int *exp);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int ilogb(double x);
int ilogbf(float x);
int ilogbl(long double x);</pre>
<h6>Returns</h6>
<p><!--para 3-->
The ilogb functions return the exponent of x as a signed int value.
-
Forward references: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
+
<p><b> Forward references</b>: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
<a name="7.12.6.6" href="#7.12.6.6"><h5>7.12.6.6 The ldexp functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double ldexp(double x, int exp);
float ldexpf(float x, int exp);
long double ldexpl(long double x, int exp);</pre>
<p><!--para 1-->
<!--page 262 indent 4-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double log(double x);
float logf(float x);
long double logl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double log10(double x);
float log10f(float x);
long double log10l(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double log1p(double x);
float log1pf(float x);
long double log1pl(long double x);</pre>
<!--page 263 indent 4-->
<h6>footnotes</h6>
-<p><a name="note235">235)</a> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
-
+<p><small><a name="note235" href="#note235">235)</a> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
+</small>
<a name="7.12.6.10" href="#7.12.6.10"><h5>7.12.6.10 The log2 functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double log2(double x);
float log2f(float x);
long double log2l(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double logb(double x);
float logbf(float x);
long double logbl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double modf(double value, double *iptr);
float modff(float value, float *iptr);
long double modfl(long double value, long double *iptr);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double scalbn(double x, int n);
float scalbnf(float x, int n);
long double scalbnl(long double x, int n);
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double cbrt(double x);
float cbrtf(float x);
long double cbrtl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double fabs(double x);
float fabsf(float x);
long double fabsl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double hypot(double x, double y);
float hypotf(float x, float y);
long double hypotl(long double x, long double y);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double pow(double x, double y);
float powf(float x, float y);
long double powl(long double x, long double y);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double sqrt(double x);
float sqrtf(float x);
long double sqrtl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double erf(double x);
float erff(float x);
long double erfl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double erfc(double x);
float erfcf(float x);
long double erfcl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double lgamma(double x);
float lgammaf(float x);
long double lgammal(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double tgamma(double x);
float tgammaf(float x);
long double tgammal(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double ceil(double x);
float ceilf(float x);
long double ceill(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double floor(double x);
float floorf(float x);
long double floorl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double nearbyint(double x);
float nearbyintf(float x);
long double nearbyintl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double rint(double x);
float rintf(float x);
long double rintl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
long int lrint(double x);
long int lrintf(float x);
long int lrintl(long double x);
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double round(double x);
float roundf(float x);
long double roundl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
long int lround(double x);
long int lroundf(float x);
long int lroundl(long double x);
<p><!--para 1-->
<!--page 271 indent 4-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double trunc(double x);
float truncf(float x);
long double truncl(long double x);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double fmod(double x, double y);
float fmodf(float x, float y);
long double fmodl(long double x, long double y);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double remainder(double x, double y);
float remainderf(float x, float y);
long double remainderl(long double x, long double y);</pre>
or the functions return zero is implementation defined.
<h6>footnotes</h6>
-<p><a name="note236">236)</a> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
+<p><small><a name="note236" href="#note236">236)</a> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
| n - x/y | = 1/2, then n is even. If r = 0, its sign shall be that of x.'' This definition is applicable for *
all implementations.
-
+</small>
<a name="7.12.10.3" href="#7.12.10.3"><h5>7.12.10.3 The remquo functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double remquo(double x, double y, int *quo);
float remquof(float x, float y, int *quo);
long double remquol(long double x, long double y,
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double copysign(double x, double y);
float copysignf(float x, float y);
long double copysignl(long double x, long double y);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double nan(const char *tagp);
float nanf(const char *tagp);
long double nanl(const char *tagp);</pre>
<p><!--para 3-->
The nan functions return a quiet NaN, if available, with content indicated through tagp.
If the implementation does not support quiet NaNs, the functions return zero.
-
Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
+
<p><b> Forward references</b>: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
<a name="7.12.11.3" href="#7.12.11.3"><h5>7.12.11.3 The nextafter functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double nextafter(double x, double y);
float nextafterf(float x, float y);
long double nextafterl(long double x, long double y);</pre>
<!--page 274 indent 4-->
<h6>footnotes</h6>
-<p><a name="note237">237)</a> The argument values are converted to the type of the function, even by a macro implementation of the
+<p><small><a name="note237" href="#note237">237)</a> The argument values are converted to the type of the function, even by a macro implementation of the
function.
-
+</small>
<a name="7.12.11.4" href="#7.12.11.4"><h5>7.12.11.4 The nexttoward functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
long double nexttowardl(long double x, long double y);</pre>
type of the function if x equals y.<sup><a href="#note238"><b>238)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note238">238)</a> The result of the nexttoward functions is determined in the type of the function, without loss of
+<p><small><a name="note238" href="#note238">238)</a> The result of the nexttoward functions is determined in the type of the function, without loss of
range or precision in a floating second argument.
-
+</small>
<a name="7.12.12" href="#7.12.12"><h4>7.12.12 Maximum, minimum, and positive difference functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double fdim(double x, double y);
float fdimf(float x, float y);
long double fdiml(long double x, long double y);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double fmax(double x, double y);
float fmaxf(float x, float y);
long double fmaxl(long double x, long double y);</pre>
The fmax functions return the maximum numeric value of their arguments.
<h6>footnotes</h6>
-<p><a name="note239">239)</a> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
+<p><small><a name="note239" href="#note239">239)</a> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
fmax functions choose the numeric value. See <a href="#F.10.9.2">F.10.9.2</a>.
-
+</small>
<a name="7.12.12.3" href="#7.12.12.3"><h5>7.12.12.3 The fmin functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double fmin(double x, double y);
float fminf(float x, float y);
long double fminl(long double x, long double y);</pre>
The fmin functions return the minimum numeric value of their arguments.
<h6>footnotes</h6>
-<p><a name="note240">240)</a> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
-
+<p><small><a name="note240" href="#note240">240)</a> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
+</small>
<a name="7.12.13" href="#7.12.13"><h4>7.12.13 Floating multiply-add</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y,
expression of real floating type<sup><a href="#note242"><b>242)</b></a></sup> (both arguments need not have the same type).<sup><a href="#note243"><b>243)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note241">241)</a> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
+<p><small><a name="note241" href="#note241">241)</a> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
the operands compare unordered, as an error indicator for programs written without consideration of
NaNs; the result in these cases is false.
-
-<p><a name="note242">242)</a> If any argument is of integer type, or any other type that is not a real floating type, the behavior is
+</small>
+<p><small><a name="note242" href="#note242">242)</a> If any argument is of integer type, or any other type that is not a real floating type, the behavior is
undefined.
-
-<p><a name="note243">243)</a> Whether an argument represented in a format wider than its semantic type is converted to the semantic
+</small>
+<p><small><a name="note243" href="#note243">243)</a> Whether an argument represented in a format wider than its semantic type is converted to the semantic
type is unspecified.
-
+</small>
<a name="7.12.14.1" href="#7.12.14.1"><h5>7.12.14.1 The isgreater macro</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isgreater(real-floating x, real-floating y);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isgreaterequal(real-floating x, real-floating y);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isless(real-floating x, real-floating y);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int islessequal(real-floating x, real-floating y);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int islessgreater(real-floating x, real-floating y);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <math.h>
+ #include <a href="#7.12"><math.h></a>
int isunordered(real-floating x, real-floating y);</pre>
<h6>Description</h6>
<p><!--para 2-->
<a name="7.13" href="#7.13"><h3>7.13 Nonlocal jumps <setjmp.h></h3></a>
<p><!--para 1-->
- The header <setjmp.h> defines the macro setjmp, and declares one function and
+ The header <a href="#7.13"><setjmp.h></a> defines the macro setjmp, and declares one function and
one type, for bypassing the normal function call and return discipline.<sup><a href="#note244"><b>244)</b></a></sup>
<p><!--para 2-->
The type declared is
program defines an external identifier with the name setjmp, the behavior is undefined.
<h6>footnotes</h6>
-<p><a name="note244">244)</a> These functions are useful for dealing with unusual conditions encountered in a low-level function of
+<p><small><a name="note244" href="#note244">244)</a> These functions are useful for dealing with unusual conditions encountered in a low-level function of
a program.
-
+</small>
<a name="7.13.1" href="#7.13.1"><h4>7.13.1 Save calling environment</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <setjmp.h>
+ #include <a href="#7.13"><setjmp.h></a>
int setjmp(jmp_buf env);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <setjmp.h>
+ #include <a href="#7.13"><setjmp.h></a>
_Noreturn void longjmp(jmp_buf env, int val);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 281 indent -1-->
<!--page 282 indent 4-->
<pre>
- #include <setjmp.h>
+ #include <a href="#7.13"><setjmp.h></a>
jmp_buf buf;
void g(int n);
void h(int n);
}</pre>
<h6>footnotes</h6>
-<p><a name="note245">245)</a> For example, by executing a return statement or because another longjmp call has caused a
+<p><small><a name="note245" href="#note245">245)</a> For example, by executing a return statement or because another longjmp call has caused a
transfer to a setjmp invocation in a function earlier in the set of nested calls.
-
-<p><a name="note246">246)</a> This includes, but is not limited to, the floating-point status flags and the state of open files.
-
+</small>
+<p><small><a name="note246" href="#note246">246)</a> This includes, but is not limited to, the floating-point status flags and the state of open files.
+</small>
<a name="7.14" href="#7.14"><h3>7.14 Signal handling <signal.h></h3></a>
<p><!--para 1-->
- The header <signal.h> declares a type and two functions and defines several macros,
+ The header <a href="#7.14"><signal.h></a> declares a type and two functions and defines several macros,
for handling various signals (conditions that may be reported during program execution).
<p><!--para 2-->
The type defined is
<!--page 283 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note247">247)</a> See ''future library directions'' (<a href="#7.30.6">7.30.6</a>). The names of the signal numbers reflect the following terms
+<p><
small><a name="note247" href="#note247">247)</a> See ''future library directions'' (<a href="#7.30.6">7.30.6</a>). The names of the signal numbers reflect the following terms
(respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
and termination.
-
+</small>
<a name="7.14.1" href="#7.14.1"><h4>7.14.1 Specify signal handling</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <signal.h>
+ #include <a href="#7.14"><signal.h></a>
void (*signal(int sig, void (*func)(int)))(int);</pre>
<h6>Description</h6>
<p><!--para 2-->
If the request can be honored, the signal function returns the value of func for the
most recent successful call to signal for the specified signal sig. Otherwise, a value of
SIG_ERR is returned and a positive value is stored in errno.
-
Forward references: 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
+
<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
_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>).
<h6>footnotes</h6>
-<p><a name="note248">248)</a> This includes functions called indirectly via standard library functions (e.g., a SIGABRT handler
+<p><small><a name="note248" href="#note248">248)</a> This includes functions called indirectly via standard library functions (e.g., a SIGABRT handler
called via the abort function).
-
-<p><a name="note249">249)</a> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
-
+</small>
+<p><small><a name="note249" href="#note249">249)</a> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
+</small>
<a name="7.14.2" href="#7.14.2"><h4>7.14.2 Send signal</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <signal.h>
+ #include <a href="#7.14"><signal.h></a>
int raise(int sig);</pre>
<h6>Description</h6>
<p><!--para 2-->
<a name="7.15" href="#7.15"><h3>7.15 Alignment <stdalign.h></h3></a>
<p><!--para 1-->
- The header <stdalign.h> defines two macros.
+ The header <a href="#7.15"><stdalign.h></a> defines two macros.
<p><!--para 2-->
The macro
<pre>
<a name="7.16" href="#7.16"><h3>7.16 Variable arguments <stdarg.h></h3></a>
<p><!--para 1-->
- The header <stdarg.h> declares a type and defines four macros, for advancing
+ The header <a href="#7.16"><stdarg.h></a> declares a type and defines four macros, for advancing
through a list of arguments whose number and types are not known to the called function
when it is translated.
<p><!--para 2-->
macro prior to any further reference to ap.<sup><a href="#note250"><b>250)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note250">250)</a> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
+<p><small><a name="note250" href="#note250">250)</a> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
case the original function may make further use of the original list after the other function returns.
-
+</small>
<a name="7.16.1" href="#7.16.1"><h4>7.16.1 Variable argument list access macros</h4></a>
<p><!--para 1-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
+ #include <a href="#7.16"><stdarg.h></a>
type va_arg(va_list ap, type);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
+ #include <a href="#7.16"><stdarg.h></a>
void va_copy(va_list dest, va_list src);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
+ #include <a href="#7.16"><stdarg.h></a>
void va_end(va_list ap);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
+ #include <a href="#7.16"><stdarg.h></a>
void va_start(va_list ap, parmN);</pre>
<h6>Description</h6>
<p><!--para 2-->
pointers is specified by the first argument to f1.
<!--page 289 indent 4-->
<pre>
- #include <stdarg.h>
+ #include <a href="#7.16"><stdarg.h></a>
#define MAXARGS 31
void f1(int n_ptrs, ...)
{
is gathered again and passed to function f4.
<!--page 290 indent 4-->
<pre>
- #include <stdarg.h>
+ #include <a href="#7.16"><stdarg.h></a>
#define MAXARGS 31
void f3(int n_ptrs, int f4_after, ...)
{
<a name="7.17.1" href="#7.17.1"><h4>7.17.1 Introduction</h4></a>
<p><!--para 1-->
- The header <stdatomic.h> defines several macros and declares several types and
+ The header <a href="#7.17"><stdatomic.h></a> defines several macros and declares several types and
functions for performing atomic operations on data shared between threads.
<p><!--para 2-->
Implementations that define the macro __STDC_NO_THREADS__ need not provide
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
#define ATOMIC_VAR_INIT(C value)</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
void atomic_init(volatile A *obj, C value);</pre>
<h6>Description</h6>
<p><!--para 2-->
amount of time.
<h6>footnotes</h6>
-<p><a name="note251">251)</a> Among other implications, atomic variables shall not decay.
-
+<p><small><a name="note251" href="#note251">251)</a> Among other implications, atomic variables shall not decay.
+</small>
<a name="7.17.3.1" href="#7.17.3.1"><h5>7.17.3.1 The kill_dependency macro</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
type kill_dependency(type y);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
void atomic_thread_fence(memory_order order);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
void atomic_signal_fence(memory_order order);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
_Bool atomic_is_lock_free(atomic_type const volatile *obj);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
void atomic_store(volatile A *object, C desired);
void atomic_store_explicit(volatile A *object,
C desired, memory_order order);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
C atomic_load(volatile A *object);
C atomic_load_explicit(volatile A *object,
memory_order order);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
C atomic_exchange(volatile A *object, C desired);
C atomic_exchange_explicit(volatile A *object,
C desired, memory_order order);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
_Bool atomic_compare_exchange_strong(volatile A *object,
C *expected, C desired);
_Bool atomic_compare_exchange_strong_explicit(
<h6>Synopsis</h6>
<p><!--para 2-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
C atomic_fetch_key(volatile A *object, M operand);
C atomic_fetch_key_explicit(volatile A *object,
M operand, memory_order order);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
bool atomic_flag_test_and_set(
volatile atomic_flag *object);
bool atomic_flag_test_and_set_explicit(
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdatomic.h>
+ #include <a href="#7.17"><stdatomic.h></a>
void atomic_flag_clear(volatile atomic_flag *object);
void atomic_flag_clear_explicit(
volatile atomic_flag *object, memory_order order);</pre>
<a name="7.18" href="#7.18"><h3>7.18 Boolean type and values <stdbool.h></h3></a>
<p><!--para 1-->
- The header <stdbool.h> defines four macros.
+ The header <a href="#7.18"><stdbool.h></a> defines four macros.
<p><!--para 2-->
The macro
<pre>
<!--page 305 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note252">252)</a> See ''future library directions'' (<a href="#7.30.7">7.30.7</a>).
-
+<p><
small><a name="note252" href="#note252">252)</a> See ''future library directions'' (<a href="#7.30.7">7.30.7</a>).
+</small>
<a name="7.19" href="#7.19"><h3>7.19 Common definitions <stddef.h></h3></a>
<p><!--para 1-->
- The header <stddef.h> defines the following macros and declares the following types.
+ The header <a href="#7.19"><stddef.h></a> defines the following macros and declares the following types.
Some are also defined in other headers, as noted in their respective subclauses.
<p><!--para 2-->
The types are
greater than that of signed long int unless the implementation supports objects
large enough to make this necessary.
<!--page 306 indent 0-->
-
Forward references: localization (<a href="#7.11">7.11</a>).
+
<p><b> Forward references</b>: localization (<a href="#7.11">7.11</a>).
<!--page 307 indent 4-->
<a name="7.20" href="#7.20"><h3>7.20 Integer types <stdint.h></h3></a>
<p><!--para 1-->
- The header <stdint.h> declares sets of integer types having specified widths, and
+ The header <a href="#7.20"><stdint.h></a> declares sets of integer types having specified widths, and
defines corresponding sets of macros.<sup><a href="#note253"><b>253)</b></a></sup> It also defines macros that specify limits of
integer types corresponding to types defined in other standard headers.
<p><!--para 2-->
Corresponding macros specify limits of the declared types and construct suitable
constants.
<p><!--para 4-->
- For each type described herein that the implementation provides,<sup><a href="#note254"><b>254)</b></a></sup> <stdint.h> shall
+ For each type described herein that the implementation provides,<sup><a href="#note254"><b>254)</b></a></sup> <a href="#7.20"><stdint.h></a> shall
declare that typedef name and define the associated macros. Conversely, for each type
- described herein that the implementation does not provide, <stdint.h> shall not
+ described herein that the implementation does not provide, <a href="#7.20"><stdint.h></a> shall not
declare that typedef name nor shall it define the associated macros. An implementation
shall provide those types described as ''required'', but need not provide any of the others
(described as ''optional'').
<h6>footnotes</h6>
-<p><
a name="note253">253)</a> See ''future library directions'' (<a href="#7.30.8">7.30.8</a>).
-
-<p><a name="note254">254)</a> Some of these types may denote implementation-defined extended integer types.
-
+<p><
small><a name="note253" href="#note253">253)</a> See ''future library directions'' (<a href="#7.30.8">7.30.8</a>).
+</small>
+<p><small><a name="note254" href="#note254">254)</a> Some of these types may denote implementation-defined extended integer types.
+</small>
<a name="7.20.1" href="#7.20.1"><h4>7.20.1 Integer types</h4></a>
<p><!--para 1-->
All other types of this form are optional.
<h6>footnotes</h6>
-<p><a name="note255">255)</a> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
+<p><small><a name="note255" href="#note255">255)</a> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
grounds for choosing one type over another, it will simply pick some integer type satisfying the
signedness and width requirements.
-
+</small>
<a name="7.20.1.4" href="#7.20.1.4"><h5>7.20.1.4 Integer types capable of holding object pointers</h5></a>
<p><!--para 1-->
<a name="7.20.2" href="#7.20.2"><h4>7.20.2 Limits of specified-width integer types</h4></a>
<p><!--para 1-->
The following object-like macros specify the minimum and maximum limits of the types *
- declared in <stdint.h>. Each macro name corresponds to a similar type name in
+ declared in <a href="#7.20"><stdint.h></a>. Each macro name corresponds to a similar type name in
<a href="#7.20.1">7.20.1</a>.
<p><!--para 2-->
Each instance of any defined macro shall be replaced by a constant expression suitable
shall be 0 and the value of WINT_MAX shall be no less than 65535.
<h6>footnotes</h6>
-<p><a name="note256">256)</a> A freestanding implementation need not provide all of these types.
-
-<p><a name="note257">257)</a> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
+<p><small><a name="note256" href="#note256">256)</a> A freestanding implementation need not provide all of these types.
+</small>
+<p><small><a name="note257" href="#note257">257)</a> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
character set.
-
+</small>
<a name="7.20.4" href="#7.20.4"><h4>7.20.4 Macros for integer constants</h4></a>
<p><!--para 1-->
The following function-like macros expand to integer constants suitable for initializing *
- objects that have integer types corresponding to types defined in <stdint.h>. Each
+ objects that have integer types corresponding to types defined in <a href="#7.20"><stdint.h></a>. Each
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>.
<p><!--para 2-->
The argument in any instance of these macros shall be an unsuffixed integer constant (as
<a name="7.21.1" href="#7.21.1"><h4>7.21.1 Introduction</h4></a>
<p><!--para 1-->
- The header <stdio.h> defines several macros, and declares three types and many
+ The header <a href="#7.21"><stdio.h></a> defines several macros, and declares three types and many
functions for performing input and output.
<p><!--para 2-->
The types declared are size_t (described in <a href="#7.19">7.19</a>);
which are expressions of type ''pointer to FILE'' that point to the FILE objects
associated, respectively, with the standard error, input, and output streams.
<p><!--para 4-->
- The header <wchar.h> declares a number of functions useful for wide character input
+ The header <a href="#7.28"><wchar.h></a> declares a number of functions useful for wide character input
and output. The wide character input/output functions described in that subclause
provide operations analogous to most of those described here, except that the
fundamental units internal to the program are wide characters. The external
fscanf, fwrite, getc, getchar, printf, putc, putchar, puts, scanf, *
ungetc, vfprintf, vfscanf, vprintf, and vscanf.
</ul>
-
Forward references: 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
- tmpnam function (<a href="#7.21.4.4">7.21.4.4</a>),
<wchar.h> (<a href="#7.28">7.28</a>).
+
<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
+ tmpnam function (<a href="#7.21.4.4">7.21.4.4</a>),
<a href="#7.28"><wchar.h></a> (<a href="#7.28">7.28</a>).
<h6>footnotes</h6>
-<p><a name="note258">258)</a> If the implementation imposes no practical limit on the length of file name strings, the value of
+<p><small><a name="note258" href="#note258">258)</a> If the implementation imposes no practical limit on the length of file name strings, the value of
FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
string. Of course, file name string contents are subject to other system-specific constraints; therefore
all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
-
+</small>
<a name="7.21.2" href="#7.21.2"><h4>7.21.2 Streams</h4></a>
<p><!--para 1-->
An implementation shall support text files with lines containing at least 254 characters,
including the terminating new-line character. The value of the macro BUFSIZ shall be at
least 256.
-
Forward references: the freopen function (<a href="#7.21.5.4">7.21.5.4</a>), the fwide function (<a href="#7.28.3.5">7.28.3.5</a>),
+
<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.28.3.5">7.28.3.5</a>),
mbstate_t (<a href="#7.29.1">7.29.1</a>), the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>), the fsetpos function
(<a href="#7.21.9.3">7.21.9.3</a>).
<!--page 318 indent 4-->
<h6>footnotes</h6>
-<p><a name="note259">259)</a> An implementation need not distinguish between text streams and binary streams. In such an
+<p><small><a name="note259" href="#note259">259)</a> An implementation need not distinguish between text streams and binary streams. In such an
implementation, there need be no new-line characters in a text stream nor any limit to the length of a
line.
-
-<p><a name="note260">260)</a> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
-
+</small>
+<p><small><a name="note260" href="#note260">260)</a> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
+</small>
<a name="7.21.3" href="#7.21.3"><h4>7.21.3 Files</h4></a>
<p><!--para 1-->
<p><!--para 15-->
The value of FOPEN_MAX shall be at least eight, including the three standard text
streams.
-
Forward references: 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
+
<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
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
(<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.28.3.1">7.28.3.1</a>), the
fputwc function (<a href="#7.28.3.3">7.28.3.3</a>), conversion state (<a href="#7.28.6">7.28.6</a>), the mbrtowc function
(<a href="#7.28.6.3.2">7.28.6.3.2</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
<h6>footnotes</h6>
-<p><a name="note261">261)</a> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
+<p><small><a name="note261" href="#note261">261)</a> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
with state-dependent encoding that does not assuredly end in the initial shift state.
-
+</small>
<a name="7.21.4" href="#7.21.4"><h4>7.21.4 Operations on files</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int remove(const char *filename);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int rename(const char *old, const char *new);</pre>
<h6>Description</h6>
<p><!--para 2-->
which case if the file existed previously it is still known by its original name.
<h6>footnotes</h6>
-<p><a name="note262">262)</a> Among the reasons the implementation may cause the rename function to fail are that the file is open
+<p><small><a name="note262" href="#note262">262)</a> Among the reasons the implementation may cause the rename function to fail are that the file is open
or that it is necessary to copy its contents to effectuate its renaming.
-
+</small>
<a name="7.21.4.3" href="#7.21.4.3"><h5>7.21.4.3 The tmpfile function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
FILE *tmpfile(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 4-->
The tmpfile function returns a pointer to the stream of the file that it created. If the file
cannot be created, the tmpfile function returns a null pointer.
-
Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+
<p><b> Forward references</b>: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
<a name="7.21.4.4" href="#7.21.4.4"><h5>7.21.4.4 The tmpnam function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
char *tmpnam(char *s);</pre>
<h6>Description</h6>
<p><!--para 2-->
The value of the macro TMP_MAX shall be at least 25.
<h6>footnotes</h6>
-<p><a name="note263">263)</a> Files created using strings generated by the tmpnam function are temporary only in the sense that
+<p><small><a name="note263" href="#note263">263)</a> Files created using strings generated by the tmpnam function are temporary only in the sense that
their names should not collide with those generated by conventional naming rules for the
implementation. It is still necessary to use the remove function to remove such files when their use
is ended, and before program termination.
-
+</small>
<a name="7.21.5" href="#7.21.5"><h4>7.21.5 File access functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fclose(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fflush(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 4-->
The fflush function sets the error indicator for the stream and returns EOF if a write
error occurs, otherwise it returns zero.
-
Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+
<p><b> Forward references</b>: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
<a name="7.21.5.3" href="#7.21.5.3"><h5>7.21.5.3 The fopen function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
FILE *fopen(const char * restrict filename,
const char * restrict mode);</pre>
<h6>Description</h6>
<p><!--para 9-->
The fopen function returns a pointer to the object controlling the stream. If the open
operation fails, fopen returns a null pointer.
-
Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
+
<p><b> Forward references</b>: file positioning functions (<a href="#7.21.9">7.21.9</a>).
<!--page 325 indent 4-->
<h6>footnotes</h6>
-<p><a name="note264">264)</a> If the string begins with one of the above sequences, the implementation might choose to ignore the
+<p><small><a name="note264" href="#note264">264)</a> If the string begins with one of the above sequences, the implementation might choose to ignore the
remaining characters, or it might use them to select different kinds of a file (some of which might not
conform to the properties in <a href="#7.21.2">7.21.2</a>).
-
+</small>
<a name="7.21.5.4" href="#7.21.5.4"><h5>7.21.5.4 The freopen function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
FILE *freopen(const char * restrict filename,
const char * restrict mode,
FILE * restrict stream);</pre>
freopen returns the value of stream.
<h6>footnotes</h6>
-<p><a name="note265">265)</a> The primary use of the freopen function is to change the file associated with a standard text stream
+<p><small><a name="note265" href="#note265">265)</a> The primary use of the freopen function is to change the file associated with a standard text stream
(stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
returned by the fopen function may be assigned.
-
+</small>
<a name="7.21.5.5" href="#7.21.5.5"><h5>7.21.5.5 The setbuf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
void setbuf(FILE * restrict stream,
char * restrict buf);</pre>
<h6>Description</h6>
<h6>Returns</h6>
<p><!--para 3-->
The setbuf function returns no value.
-
Forward references: the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
+
<p><b> Forward references</b>: the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
<a name="7.21.5.6" href="#7.21.5.6"><h5>7.21.5.6 The setvbuf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int setvbuf(FILE * restrict stream,
char * restrict buf,
int mode, size_t size);</pre>
<!--page 327 indent 4-->
<h6>footnotes</h6>
-<p><a name="note266">266)</a> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
+<p><small><a name="note266" href="#note266">266)</a> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
before a buffer that has automatic storage duration is deallocated upon block exit.
-
+</small>
<a name="7.21.6" href="#7.21.6"><h4>7.21.6 Formatted input/output functions</h4></a>
<p><!--para 1-->
actions associated with each specifier.<sup><a href="#note267"><b>267)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note267">267)</a> The fprintf functions perform writes to memory for the %n specifier.
-
+<p><small><a name="note267" href="#note267">267)</a> The fprintf functions perform writes to memory for the %n specifier.
+</small>
<a name="7.21.6.1" href="#7.21.6.1"><h5>7.21.6.1 The fprintf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fprintf(FILE * restrict stream,
const char * restrict format, ...);</pre>
<h6>Description</h6>
EXAMPLE 1 To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
places:
<pre>
- #include <math.h>
- #include <stdio.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
char *weekday, *month; // pointers to strings
int day, hour, min;
| abc Z W|
| Z|</pre>
-
Forward references: conversion state (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+
<p><b> Forward references</b>: conversion state (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
<!--page 335 indent 4-->
<h6>footnotes</h6>
-<p><a name="note268">268)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
-
-<p><a name="note269">269)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+<p><small><a name="note268" href="#note268">268)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
+</small>
+<p><small><a name="note269" href="#note269">269)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
include a minus sign.
-
-<p><a name="note270">270)</a> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
+</small>
+<p><small><a name="note270" href="#note270">270)</a> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
the # and 0 flag characters have no effect.
-
-<p><a name="note271">271)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
+</small>
+<p><small><a name="note271" href="#note271">271)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
that subsequent digits align to nibble (4-bit) boundaries.
-
-<p><a name="note272">272)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 > b n where b is
+</small>
+<p><small><a name="note272" href="#note272">272)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 > b n where b is
FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
might suffice depending on the implementation's scheme for determining the digit to the left of the
decimal-point character.
-
-<p><a name="note273">273)</a> No special provisions are made for multibyte characters.
-
-<p><a name="note274">274)</a> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
-
-<p><
a name="note275">275)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
-
-<p><a name="note276">276)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+</small>
+<p><small><a name="note273" href="#note273">273)</a> No special provisions are made for multibyte characters.
+</small>
+<p><small><a name="note274" href="#note274">274)</a> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
+</small>
+<p><
small><a name="note275" href="#note275">275)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+</small>
+<p><small><a name="note276" href="#note276">276)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
given format specifier. The number of significant digits is determined by the format specifier, and in
the case of fixed-point conversion by the source value as well.
-
+</small>
<a name="7.21.6.2" href="#7.21.6.2"><h5>7.21.6.2 The fscanf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fscanf(FILE * restrict stream,
const char * restrict format, ...);</pre>
<h6>Description</h6>
<p><!--para 17-->
EXAMPLE 1 The call:
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
int n, i; float x; char name[50];
n = fscanf(stdin, "%d%f%s", &i, &x, name);</pre>
<p><!--para 18-->
EXAMPLE 2 The call:
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
int i; float x; char name[50];
fscanf(stdin, "%2d%f%*d %[0123456789]", &i, &x, name);</pre>
EXAMPLE 3 To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
<p><!--para 20-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
int count; float quant; char units[21], item[21];
do {
<p><!--para 21-->
EXAMPLE 4 In:
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
int d1, d2, n1, n2, i;
i = sscanf("123", "%d%n%n%d", &d1, &n1, &n2, &d2);</pre>
<p><!--para 23-->
After the call:
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
char str[50];
fscanf(stdin, "a%s", str);</pre>
<p><!--para 24-->
In contrast, after the call:
<pre>
- #include <stdio.h>
- #include <stddef.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.19"><stddef.h></a>
/* ... */
wchar_t wstr[50];
fscanf(stdin, "a%ls", wstr);</pre>
However, the call:
<!--page 342 indent 5-->
<pre>
- #include <stdio.h>
- #include <stddef.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.19"><stddef.h></a>
/* ... */
wchar_t wstr[50];
fscanf(stdin, "a(uparrow) X(downarrow)%ls", wstr);</pre>
Assuming that the first byte of the multibyte character X is the same as the first byte of the multibyte
character Y, after the call:
<pre>
- #include <stdio.h>
- #include <stddef.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.19"><stddef.h></a>
/* ... */
wchar_t wstr[50];
fscanf(stdin, "a(uparrow) Y(downarrow)%ls", wstr);</pre>
with the same input line, zero will again be returned, but stdin will be left with a partially consumed
multibyte character.
-
Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>), the
+
<p><b> Forward references</b>: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>), the
strtol, strtoll, strtoul, and strtoull functions (<a href="#7.22.1.4">7.22.1.4</a>), conversion state
(<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
<h6>footnotes</h6>
-<p><a name="note277">277)</a> These white-space characters are not counted against a specified field width.
-
-<p><a name="note278">278)</a> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
+<p><small><a name="note277" href="#note277">277)</a> These white-space characters are not counted against a specified field width.
+</small>
+<p><small><a name="note278" href="#note278">278)</a> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
-
-<p><a name="note279">279)</a> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
+</small>
+<p><small><a name="note279" href="#note279">279)</a> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
-
-<p><
a name="note280">280)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
-
+</small>
+<p><
small><a name="note280" href="#note280">280)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+</small>
<a name="7.21.6.3" href="#7.21.6.3"><h5>7.21.6.3 The printf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int printf(const char * restrict format, ...);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int scanf(const char * restrict format, ...);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int snprintf(char * restrict s, size_t n,
const char * restrict format, ...);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int sprintf(char * restrict s,
const char * restrict format, ...);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int sscanf(const char * restrict s,
const char * restrict format, ...);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vfprintf(FILE * restrict stream,
const char * restrict format,
va_list arg);</pre>
<!--page 345 indent 4-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
void error(char *function_name, char *format, ...)
{
va_list args;
<h6>footnotes</h6>
-<p><a name="note281">281)</a> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
+<p><small><a name="note281" href="#note281">281)</a> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
-
+</small>
<a name="7.21.6.9" href="#7.21.6.9"><h5>7.21.6.9 The vfscanf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vfscanf(FILE * restrict stream,
const char * restrict format,
va_list arg);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vprintf(const char * restrict format,
va_list arg);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vscanf(const char * restrict format,
va_list arg);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vsnprintf(char * restrict s, size_t n,
const char * restrict format,
va_list arg);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vsprintf(char * restrict s,
const char * restrict format,
va_list arg);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vsscanf(const char * restrict s,
const char * restrict format,
va_list arg);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fgetc(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
returns EOF.<sup><a href="#note282"><b>282)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note282">282)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
-
+<p><small><a name="note282" href="#note282">282)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+</small>
<a name="7.21.7.2" href="#7.21.7.2"><h5>7.21.7.2 The fgets function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
char *fgets(char * restrict s, int n,
FILE * restrict stream);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fputc(int c, FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fputs(const char * restrict s,
FILE * restrict stream);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int getc(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int getchar(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int putc(int c, FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int putchar(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int puts(const char *s);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int ungetc(int c, FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 6-->
The ungetc function returns the character pushed back after conversion, or EOF if the
operation fails.
-
Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
+
<p><b> Forward references</b>: file positioning functions (<a href="#7.21.9">7.21.9</a>).
<h6>footnotes</h6>
-<p><
a name="note283">283)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
-
+<p><
small><a name="note283" href="#note283">283)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+</small>
<a name="7.21.8" href="#7.21.8"><h4>7.21.8 Direct input/output functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
size_t fread(void * restrict ptr,
size_t size, size_t nmemb,
FILE * restrict stream);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
size_t fwrite(const void * restrict ptr,
size_t size, size_t nmemb,
FILE * restrict stream);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fgetpos(FILE * restrict stream,
fpos_t * restrict pos);</pre>
<h6>Description</h6>
<p><!--para 3-->
If successful, the fgetpos function returns zero; on failure, the fgetpos function
returns nonzero and stores an implementation-defined positive value in errno.
-
Forward references: the fsetpos function (<a href="#7.21.9.3">7.21.9.3</a>).
+
<p><b> Forward references</b>: the fsetpos function (<a href="#7.21.9.3">7.21.9.3</a>).
<!--page 354 indent 4-->
<a name="7.21.9.2" href="#7.21.9.2"><h5>7.21.9.2 The fseek function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fseek(FILE *stream, long int offset, int whence);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Returns</h6>
<p><!--para 6-->
The fseek function returns nonzero only for a request that cannot be satisfied.
-
Forward references: the ftell function (<a href="#7.21.9.4">7.21.9.4</a>).
+
<p><b> Forward references</b>: the ftell function (<a href="#7.21.9.4">7.21.9.4</a>).
<a name="7.21.9.3" href="#7.21.9.3"><h5>7.21.9.3 The fsetpos function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fsetpos(FILE *stream, const fpos_t *pos);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
long int ftell(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
void rewind(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
void clearerr(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int feof(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int ferror(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
void perror(const char *s);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Returns</h6>
<p><!--para 3-->
The perror function returns no value.
-
Forward references: the strerror function (<a href="#7.23.6.2">7.23.6.2</a>).
+
<p><b> Forward references</b>: the strerror function (<a href="#7.23.6.2">7.23.6.2</a>).
<!--page 358 indent 4-->
<a name="7.22" href="#7.22"><h3>7.22 General utilities <stdlib.h></h3></a>
<p><!--para 1-->
- The header <stdlib.h> declares five types and several functions of general utility, and
+ The header <a href="#7.22"><stdlib.h></a> declares five types and several functions of general utility, and
defines several macros.<sup><a href="#note284"><b>284)</b></a></sup>
<p><!--para 2-->
The types declared are size_t and wchar_t (both described in <a href="#7.19">7.19</a>),
<!--page 359 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note284">284)</a> See ''future library directions'' (<a href="#7.30.10">7.30.10</a>).
-
+<p><
small><a name="note284" href="#note284">284)</a> See ''future library directions'' (<a href="#7.30.10">7.30.10</a>).
+</small>
<a name="7.22.1" href="#7.22.1"><h4>7.22.1 Numeric conversion functions</h4></a>
<p><!--para 1-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
double atof(const char *nptr);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Returns</h6>
<p><!--para 3-->
The atof function returns the converted value.
-
Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
+
<p><b> Forward references</b>: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
<a name="7.22.1.2" href="#7.22.1.2"><h5>7.22.1.2 The atoi, atol, and atoll functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int atoi(const char *nptr);
long int atol(const char *nptr);
long long int atoll(const char *nptr);</pre>
<h6>Returns</h6>
<p><!--para 3-->
The atoi, atol, and atoll functions return the converted value.
- Forward references: the strtol, strtoll, strtoul, and strtoull functions
+<p><b> Forward references</b>: the strtol, strtoll, strtoul, and strtoull functions
(<a href="#7.22.1.4">7.22.1.4</a>).
<!--page 360 indent 4-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
double strtod(const char * restrict nptr,
char ** restrict endptr);
float strtof(const char * restrict nptr,
direction.
<p><!--para 9-->
If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
- <float.h>) significant digits, the result should be correctly rounded. If the subject
+ <a href="#7.7"><float.h></a>) significant digits, the result should be correctly rounded. If the subject
sequence D has the decimal form and more than DECIMAL_DIG significant digits,
consider the two bounding, adjacent decimal strings L and U, both having
DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L <= D <= U.
errno acquires the value ERANGE is implementation-defined.
<h6>footnotes</h6>
-<p><a name="note285">285)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+<p><small><a name="note285" href="#note285">285)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
methods may yield different results if rounding is toward positive or negative infinity. In either case,
the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
-
-<p><a name="note286">286)</a> An implementation may use the n-char sequence to determine extra information to be represented in
+</small>
+<p><small><a name="note286" href="#note286">286)</a> An implementation may use the n-char sequence to determine extra information to be represented in
the NaN's significand.
-
-<p><a name="note287">287)</a> DECIMAL_DIG, defined in <float.h>, should be sufficiently large that L and U will usually round
+</small>
+<p><small><a name="note287" href="#note287">287)</a> DECIMAL_DIG, defined in <a href="#7.7"><float.h></a>, should be sufficiently large that L and U will usually round
to the same internal floating value, but if not will round to adjacent values.
-
+</small>
<a name="7.22.1.4" href="#7.22.1.4"><h5>7.22.1.4 The strtol, strtoll, strtoul, and strtoull functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
long int strtol(
const char * restrict nptr,
char ** restrict endptr,
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int rand(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
The value of the RAND_MAX macro shall be at least 32767.
<h6>footnotes</h6>
-<p><a name="note288">288)</a> There are no guarantees as to the quality of the random sequence produced and some implementations
+<p><small><a name="note288" href="#note288">288)</a> There are no guarantees as to the quality of the random sequence produced and some implementations
are known to produce sequences with distressingly non-random low-order bits. Applications with
particular requirements should use a generator that is known to be sufficient for their needs.
-
+</small>
<a name="7.22.2.2" href="#7.22.2.2"><h5>7.22.2.2 The srand function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void srand(unsigned int seed);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void *aligned_alloc(size_t alignment, size_t size);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void *calloc(size_t nmemb, size_t size);</pre>
<h6>Description</h6>
<p><!--para 2-->
The calloc function returns either a null pointer or a pointer to the allocated space.
<h6>footnotes</h6>
-<p><a name="note289">289)</a> Note that this need not be the same as the representation of floating-point zero or a null pointer
+<p><small><a name="note289" href="#note289">289)</a> Note that this need not be the same as the representation of floating-point zero or a null pointer
constant.
-
+</small>
<a name="7.22.3.3" href="#7.22.3.3"><h5>7.22.3.3 The free function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void free(void *ptr);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void *malloc(size_t size);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void *realloc(void *ptr, size_t size);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
_Noreturn void abort(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int atexit(void (*func)(void));</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Returns</h6>
<p><!--para 4-->
The atexit function returns zero if the registration succeeds, nonzero if it fails.
-
Forward references: the at_quick_exit function (<a href="#7.22.4.3">7.22.4.3</a>), the exit function
+
<p><b> Forward references</b>: the at_quick_exit function (<a href="#7.22.4.3">7.22.4.3</a>), the exit function
(<a href="#7.22.4.4">7.22.4.4</a>).
<h6>footnotes</h6>
-<p><a name="note290">290)</a> The atexit function registrations are distinct from the at_quick_exit registrations, so
+<p><small><a name="note290" href="#note290">290)</a> The atexit function registrations are distinct from the at_quick_exit registrations, so
applications may need to call both registration functions with the same argument.
-
+</small>
<a name="7.22.4.3" href="#7.22.4.3"><h5>7.22.4.3 The at_quick_exit function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int at_quick_exit(void (*func)(void));</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 4-->
The at_quick_exit function returns zero if the registration succeeds, nonzero if it
fails.
-
Forward references: the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
+
<p><b> Forward references</b>: the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
<!--page 369 indent 4-->
<h6>footnotes</h6>
-<p><a name="note291">291)</a> The at_quick_exit function registrations are distinct from the atexit registrations, so
+<p><small><a name="note291" href="#note291">291)</a> The at_quick_exit function registrations are distinct from the atexit registrations, so
applications may need to call both registration functions with the same argument.
-
+</small>
<a name="7.22.4.4" href="#7.22.4.4"><h5>7.22.4.4 The exit function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
_Noreturn void exit(int status);</pre>
<h6>Description</h6>
<p><!--para 2-->
The exit function cannot return to its caller.
<h6>footnotes</h6>
-<p><a name="note292">292)</a> Each function is called as many times as it was registered, and in the correct order with respect to
+<p><small><a name="note292" href="#note292">292)</a> Each function is called as many times as it was registered, and in the correct order with respect to
other registered functions.
-
+</small>
<a name="7.22.4.5" href="#7.22.4.5"><h5>7.22.4.5 The _Exit function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
_Noreturn void _Exit(int status);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
char *getenv(const char *name);</pre>
<h6>Description</h6>
<p><!--para 2-->
be found, a null pointer is returned.
<h6>footnotes</h6>
-<p><a name="note293">293)</a> Many implementations provide non-standard functions that modify the environment list.
-
+<p><small><a name="note293" href="#note293">293)</a> Many implementations provide non-standard functions that modify the environment list.
+</small>
<a name="7.22.4.7" href="#7.22.4.7"><h5>7.22.4.7 The quick_exit function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
_Noreturn void quick_exit(int status);</pre>
<h6>Description</h6>
<p><!--para 2-->
The quick_exit function cannot return to its caller.
<h6>footnotes</h6>
-<p><a name="note294">294)</a> Each function is called as many times as it was registered, and in the correct order with respect to
+<p><small><a name="note294" href="#note294">294)</a> Each function is called as many times as it was registered, and in the correct order with respect to
other registered functions.
-
+</small>
<a name="7.22.4.8" href="#7.22.4.8"><h5>7.22.4.8 The system function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int system(const char *string);</pre>
<h6>Description</h6>
<p><!--para 2-->
movement of the objects passed as arguments to that call.
<h6>footnotes</h6>
-<p><a name="note295">295)</a> That is, if the value passed is p, then the following expressions are always nonzero:
+<p><small><a name="note295" href="#note295">295)</a> That is, if the value passed is p, then the following expressions are always nonzero:
<pre>
((char *)p - (char *)base) % size == 0
(char *)p >= (char *)base
(char *)p < (char *)base + nmemb * size</pre>
-
+</small>
<a name="7.22.5.1" href="#7.22.5.1"><h5>7.22.5.1 The bsearch function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void *bsearch(const void *key, const void *base,
size_t nmemb, size_t size,
int (*compar)(const void *, const void *));</pre>
matched is unspecified.
<h6>footnotes</h6>
-<p><a name="note296">296)</a> In practice, the entire array is sorted according to the comparison function.
-
+<p><small><a name="note296" href="#note296">296)</a> In practice, the entire array is sorted according to the comparison function.
+</small>
<a name="7.22.5.2" href="#7.22.5.2"><h5>7.22.5.2 The qsort function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void qsort(void *base, size_t nmemb, size_t size,
int (*compar)(const void *, const void *));</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int abs(int j);
long int labs(long int j);
long long int llabs(long long int j);</pre>
<!--page 374 indent 4-->
<h6>footnotes</h6>
-<p><a name="note297">297)</a> The absolute value of the most negative number cannot be represented in two's complement.
-
+<p><small><a name="note297" href="#note297">297)</a> The absolute value of the most negative number cannot be represented in two's complement.
+</small>
<a name="7.22.6.2" href="#7.22.6.2"><h5>7.22.6.2 The div, ldiv, and lldiv functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
lldiv_t lldiv(long long int numer, long long int denom);</pre>
category causes the conversion state of these functions to be indeterminate.
<h6>footnotes</h6>
-<p><a name="note298">298)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+<p><small><a name="note298" href="#note298">298)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
character codes, but are grouped with an adjacent multibyte character.
-
+</small>
<a name="7.22.7.1" href="#7.22.7.1"><h5>7.22.7.1 The mblen function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int mblen(const char *s, size_t n);</pre>
<h6>Description</h6>
<p><!--para 2-->
or returns the number of bytes that are contained in the multibyte character (if the next n
or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
multibyte character).
-
Forward references: the mbtowc function (<a href="#7.22.7.2">7.22.7.2</a>).
+
<p><b> Forward references</b>: the mbtowc function (<a href="#7.22.7.2">7.22.7.2</a>).
<a name="7.22.7.2" href="#7.22.7.2"><h5>7.22.7.2 The mbtowc function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int mbtowc(wchar_t * restrict pwc,
const char * restrict s,
size_t n);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
int wctomb(char *s, wchar_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
size_t mbstowcs(wchar_t * restrict pwcs,
const char * restrict s,
size_t n);</pre>
elements modified, not including a terminating null wide character, if any.<sup><a href="#note299"><b>299)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note299">299)</a> The array will not be null-terminated if the value returned is n.
-
+<p><small><a name="note299" href="#note299">299)</a> The array will not be null-terminated if the value returned is n.
+</small>
<a name="7.22.8.2" href="#7.22.8.2"><h5>7.22.8.2 The wcstombs function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
size_t wcstombs(char * restrict s,
const wchar_t * restrict pwcs,
size_t n);</pre>
<a name="7.23.1" href="#7.23.1"><h4>7.23.1 String function conventions</h4></a>
<p><!--para 1-->
- The header <string.h> declares one type and several functions, and defines one
+ The header <a href="#7.23"><string.h></a> declares one type and several functions, and defines one
macro useful for manipulating arrays of character type and other objects treated as arrays
of character type.<sup><a href="#note300"><b>300)</b></a></sup> The type is size_t and the macro is NULL (both described in
<a href="#7.19">7.19</a>). Various methods are used for determining the lengths of the arrays, but in all cases
different value).
<h6>footnotes</h6>
-<p><
a name="note300">300)</a> See ''future library directions'' (<a href="#7.30.11">7.30.11</a>).
-
+<p><
small><a name="note300" href="#note300">300)</a> See ''future library directions'' (<a href="#7.30.11">7.30.11</a>).
+</small>
<a name="7.23.2" href="#7.23.2"><h4>7.23.2 Copying functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
void *memcpy(void * restrict s1,
const void * restrict s2,
size_t n);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
void *memmove(void *s1, const void *s2, size_t n);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strcpy(char * restrict s1,
const char * restrict s2);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strncpy(char * restrict s1,
const char * restrict s2,
size_t n);</pre>
The strncpy function returns the value of s1.
<h6>footnotes</h6>
-<p><a name="note301">301)</a> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
+<p><small><a name="note301" href="#note301">301)</a> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
not be null-terminated.
-
+</small>
<a name="7.23.3" href="#7.23.3"><h4>7.23.3 Concatenation functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strcat(char * restrict s1,
const char * restrict s2);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strncat(char * restrict s1,
const char * restrict s2,
size_t n);</pre>
<h6>Returns</h6>
<p><!--para 3-->
The strncat function returns the value of s1.
-
Forward references: the strlen function (<a href="#7.23.6.3">7.23.6.3</a>).
+
<p><b> Forward references</b>: the strlen function (<a href="#7.23.6.3">7.23.6.3</a>).
<h6>footnotes</h6>
-<p><a name="note302">302)</a> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
+<p><small><a name="note302" href="#note302">302)</a> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
strlen(s1)+n+1.
-
+</small>
<a name="7.23.4" href="#7.23.4"><h4>7.23.4 Comparison functions</h4></a>
<p><!--para 1-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
int memcmp(const void *s1, const void *s2, size_t n);</pre>
<h6>Description</h6>
<p><!--para 2-->
pointed to by s2.
<h6>footnotes</h6>
-<p><a name="note303">303)</a> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
+<p><small><a name="note303" href="#note303">303)</a> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
indeterminate. Strings shorter than their allocated space and unions may also cause problems in
comparison.
-
+</small>
<a name="7.23.4.2" href="#7.23.4.2"><h5>7.23.4.2 The strcmp function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
int strcmp(const char *s1, const char *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
int strcoll(const char *s1, const char *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
int strncmp(const char *s1, const char *s2, size_t n);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
size_t strxfrm(char * restrict s1,
const char * restrict s2,
size_t n);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
void *memchr(const void *s, int c, size_t n);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strchr(const char *s, int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
size_t strcspn(const char *s1, const char *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strpbrk(const char *s1, const char *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strrchr(const char *s, int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
size_t strspn(const char *s1, const char *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strstr(const char *s1, const char *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strtok(char * restrict s1,
const char * restrict s2);</pre>
<h6>Description</h6>
<p><!--para 8-->
EXAMPLE
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
static char str[] = "?a???b,,,#c";
char *t;
t = strtok(str, "?"); // t points to the token "a"
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
void *memset(void *s, int c, size_t n);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strerror(int errnum);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
size_t strlen(const char *s);</pre>
<h6>Description</h6>
<p><!--para 2-->
<a name="7.24" href="#7.24"><h3>7.24 Type-generic math <tgmath.h></h3></a>
<p><!--para 1-->
- The header <tgmath.h> includes the headers <math.h> and <complex.h> and
+ The header <a href="#7.24"><tgmath.h></a> includes the headers <a href="#7.12"><math.h></a> and <a href="#7.3"><complex.h></a> and
defines several type-generic macros.
<p><!--para 2-->
- Of the <math.h> and <complex.h> functions without an f (float) or l (long
+ 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
double) suffix, several have one or more parameters whose corresponding real type is
double. For each such function, except modf, there is a corresponding type-generic
macro.<sup><a href="#note304"><b>304)</b></a></sup> The parameters whose corresponding real type is double in the function
<li> Otherwise, the type determined is float.
</ul>
<p><!--para 4-->
- For each unsuffixed function in <math.h> for which there is a function in
- <complex.h> with the same name except for a c prefix, the corresponding type-
- generic macro (for both functions) has the same name as the function in <math.h>. The
+ For each unsuffixed function in <a href="#7.12"><math.h></a> for which there is a function in
+ <a href="#7.3"><complex.h></a> with the same name except for a c prefix, the corresponding type-
+ generic macro (for both functions) has the same name as the function in <a href="#7.12"><math.h></a>. The
corresponding type-generic macro for fabs and cabs is fabs.
<!--page 389 indent 4-->
<pre>
- <math.h> <complex.h> type-generic
+ <a href="#7.12"><math.h></a> <a href="#7.3"><complex.h></a> type-generic
function function macro
acos cacos acos
asin casin asin
If at least one argument for a generic parameter is complex, then use of the macro invokes
a complex function; otherwise, use of the macro invokes a real function.
<p><!--para 5-->
- For each unsuffixed function in <math.h> without a c-prefixed counterpart in
- <complex.h> (except modf), the corresponding type-generic macro has the same
+ For each unsuffixed function in <a href="#7.12"><math.h></a> without a c-prefixed counterpart in
+ <a href="#7.3"><complex.h></a> (except modf), the corresponding type-generic macro has the same
name as the function. These type-generic macros are:
<pre>
atan2 fma llround remainder
function; otherwise, use of the macro results in undefined behavior.
<!--page 390 indent 4-->
<p><!--para 6-->
- For each unsuffixed function in <complex.h> that is not a c-prefixed counterpart to a
- function in <math.h>, the corresponding type-generic macro has the same name as the
+ For each unsuffixed function in <a href="#7.3"><complex.h></a> that is not a c-prefixed counterpart to a
+ function in <a href="#7.12"><math.h></a>, the corresponding type-generic macro has the same name as the
function. These type-generic macros are:
<pre>
carg conj creal
<p><!--para 7-->
EXAMPLE With the declarations
<pre>
- #include <tgmath.h>
+ #include <a href="#7.24"><tgmath.h></a>
int n;
float f;
double d;
cproj(ldc) cprojl(ldc)</pre>
<h6>footnotes</h6>
-<p><a name="note304">304)</a> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
+<p><small><a name="note304" href="#note304">304)</a> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
make available the corresponding ordinary function.
-
-<p><a name="note305">305)</a> If the type of the argument is not compatible with the type of the parameter for the selected function,
+</small>
+<p><small><a name="note305" href="#note305">305)</a> If the type of the argument is not compatible with the type of the parameter for the selected function,
the behavior is undefined.
-
+</small>
<a name="7.25" href="#7.25"><h3>7.25 Threads <threads.h></h3></a>
<a name="7.25.1" href="#7.25.1"><h4>7.25.1 Introduction</h4></a>
<p><!--para 1-->
- The header <threads.h> defines macros, and declares types, enumeration constants,
+ The header <a href="#7.25"><threads.h></a> defines macros, and declares types, enumeration constants,
and functions that support multiple threads of execution.
<p><!--para 2-->
Implementations that define the macro __STDC_NO_THREADS__ need not provide
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void call_once(once_flag *flag, void (*func)(void));</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int cnd_broadcast(cnd_t *cond);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void cnd_destroy(cnd_t *cond);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int cnd_init(cnd_t *cond);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int cnd_signal(cnd_t *cond);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 1-->
<!--page 395 indent 4-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int cnd_timedwait(cnd_t *cond, mtx_t *mtx,
const xtime *xt);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int cnd_wait(cnd_t *cond, mtx_t *mtx);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void mtx_destroy(mtx_t *mtx);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int mtx_init(mtx_t *mtx, int type);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int mtx_lock(mtx_t *mtx);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int mtx_timedlock(mtx_t *mtx, const xtime *xt);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int mtx_trylock(mtx_t *mtx);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int mtx_unlock(mtx_t *mtx);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int thrd_create(thrd_t *thr, thrd_start_t func,
void *arg);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
thrd_t thrd_current(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 1-->
<!--page 399 indent 4-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int thrd_detach(thrd_t thr);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int thrd_equal(thrd_t thr0, thrd_t thr1);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void thrd_exit(int res);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int thrd_join(thrd_t thr, int *res);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void thrd_sleep(const xtime *xt);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void thrd_yield(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int tss_create(tss_t *key, tss_dtor_t dtor);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void tss_delete(tss_t key);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
void *tss_get(tss_t key);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int tss_set(tss_t key, void *val);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <threads.h>
+ #include <a href="#7.25"><threads.h></a>
int xtime_get(xtime *xt, int base);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 403 indent 4-->
<h6>footnotes</h6>
-<p><a name="note306">306)</a> Although an xtime object describes times with nanosecond resolution, the actual resolution in an
+<p><small><a name="note306" href="#note306">306)</a> Although an xtime object describes times with nanosecond resolution, the actual resolution in an
xtime object is system dependent.
-
+</small>
<a name="7.26" href="#7.26"><h3>7.26 Date and time <time.h></h3></a>
<a name="7.26.1" href="#7.26.1"><h4>7.26.1 Components of time</h4></a>
<p><!--para 1-->
- The header <time.h> defines two macros, and declares several types and functions for
+ The header <a href="#7.26"><time.h></a> defines two macros, and declares several types and functions for
manipulating time. Many functions deal with a calendar time that represents the current
date (according to the Gregorian calendar) and time. Some functions deal with local
time, which is the calendar time expressed for some specific time zone, and with Daylight
Saving Time is not in effect, and negative if the information is not available.
<h6>footnotes</h6>
-<p><a name="note307">307)</a> The range [0, 60] for tm_sec allows for a positive leap second.
-
+<p><small><a name="note307" href="#note307">307)</a> The range [0, 60] for tm_sec allows for a positive leap second.
+</small>
<a name="7.26.2" href="#7.26.2"><h4>7.26.2 Time manipulation functions</h4></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
clock_t clock(void);</pre>
<h6>Description</h6>
<p><!--para 2-->
returns the value (clock_t)(-1).<sup><a href="#note308"><b>308)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note308">308)</a> In order to measure the time spent in a program, the clock function should be called at the start of
+<p><small><a name="note308" href="#note308">308)</a> In order to measure the time spent in a program, the clock function should be called at the start of
the program and its return value subtracted from the value returned by subsequent calls.
-
+</small>
<a name="7.26.2.2" href="#7.26.2.2"><h5>7.26.2.2 The difftime function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
double difftime(time_t time1, time_t time0);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
time_t mktime(struct tm *timeptr);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 4-->
EXAMPLE What day of the week is July 4, 2001?
<pre>
- #include <stdio.h>
- #include <time.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.26"><time.h></a>
static const char *const wday[] = {
"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday", "-unknown-"
<h6>footnotes</h6>
-<p><a name="note309">309)</a> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
+<p><small><a name="note309" href="#note309">309)</a> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
-
+</small>
<a name="7.26.2.4" href="#7.26.2.4"><h5>7.26.2.4 The time function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
time_t time(time_t *timer);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
char *asctime(const struct tm *timeptr);</pre>
<h6>Description</h6>
<p><!--para 2-->
The asctime function returns a pointer to the string.
<h6>footnotes</h6>
-<p><
a name="note310">310)</a> See <a href="#7.26.1">7.26.1</a>.
-
+<p><
small><a name="note310" href="#note310">310)</a> See <a href="#7.26.1">7.26.1</a>.
+</small>
<a name="7.26.3.2" href="#7.26.3.2"><h5>7.26.3.2 The ctime function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
char *ctime(const time_t *timer);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 3-->
The ctime function returns the pointer returned by the asctime function with that
broken-down time as argument.
-
Forward references: the localtime function (<a href="#7.26.3.4">7.26.3.4</a>).
+
<p><b> Forward references</b>: the localtime function (<a href="#7.26.3.4">7.26.3.4</a>).
<a name="7.26.3.3" href="#7.26.3.3"><h5>7.26.3.3 The gmtime function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
struct tm *gmtime(const time_t *timer);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
struct tm *localtime(const time_t *timer);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 1-->
<!--page 409 indent 4-->
<pre>
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
size_t strftime(char * restrict s,
size_t maxsize,
const char * restrict format,
<a name="7.27" href="#7.27"><h3>7.27 Unicode utilities <uchar.h></h3></a>
<p><!--para 1-->
- The header <uchar.h> declares types and functions for manipulating Unicode
+ The header <a href="#7.27"><uchar.h></a> declares types and functions for manipulating Unicode
characters.
<p><!--para 2-->
The types declared are mbstate_t (described in <a href="#7.29.1">7.29.1</a>) and size_t (described in
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <uchar.h>
+ #include <a href="#7.27"><uchar.h></a>
size_t mbrtoc16(char16_t * restrict pc16,
const char * restrict s, size_t n,
mbstate_t * restrict ps);</pre>
and the conversion state is unspecified.</pre>
<h6>footnotes</h6>
-<p><a name="note311">311)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+<p><small><a name="note311" href="#note311">311)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
sequence of redundant shift sequences (for implementations with state-dependent encodings).
-
+</small>
<a name="7.27.1.2" href="#7.27.1.2"><h5>7.27.1.2 The c16rtomb function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <uchar.h>
+ #include <a href="#7.27"><uchar.h></a>
size_t c16rtomb(char * restrict s, char16_t c16,
mbstate_t * restrict ps);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <uchar.h>
+ #include <a href="#7.27"><uchar.h></a>
size_t mbrtoc32(char32_t * restrict pc32,
const char * restrict s, size_t n,
mbstate_t * restrict ps);</pre>
and the conversion state is unspecified.</pre>
<h6>footnotes</h6>
-<p><a name="note312">312)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+<p><small><a name="note312" href="#note312">312)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
sequence of redundant shift sequences (for implementations with state-dependent encodings).
-
+</small>
<a name="7.27.1.4" href="#7.27.1.4"><h5>7.27.1.4 The c32rtomb function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <uchar.h>
+ #include <a href="#7.27"><uchar.h></a>
size_t c32rtomb(char * restrict s, char32_t c32,
mbstate_t * restrict ps);</pre>
<h6>Description</h6>
<a name="7.28.1" href="#7.28.1"><h4>7.28.1 Introduction</h4></a>
<p><!--para 1-->
- The header <wchar.h> defines four macros, and declares four data types, one tag, and
+ The header <a href="#7.28"><wchar.h></a> defines four macros, and declares four data types, one tag, and
many functions.<sup><a href="#note313"><b>313)</b></a></sup>
<p><!--para 2-->
The types declared are wchar_t and size_t (both described in <a href="#7.19">7.19</a>);
undefined.
<h6>footnotes</h6>
-<p><
a name="note313">313)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
-
-<p><a name="note314">314)</a> wchar_t and wint_t can be the same integer type.
-
-<p><a name="note315">315)</a> The value of the macro WEOF may differ from that of EOF and need not be negative.
-
+<p><
small><a name="note313" href="#note313">313)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+</small>
+<p><small><a name="note314" href="#note314">314)</a> wchar_t and wint_t can be the same integer type.
+</small>
+<p><small><a name="note315" href="#note315">315)</a> The value of the macro WEOF may differ from that of EOF and need not be negative.
+</small>
<a name="7.28.2" href="#7.28.2"><h4>7.28.2 Formatted wide character input/output functions</h4></a>
<p><!--para 1-->
point after the actions associated with each specifier.<sup><a href="#note316"><b>316)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note316">316)</a> The fwprintf functions perform writes to memory for the %n specifier.
-
+<p><small><a name="note316" href="#note316">316)</a> The fwprintf functions perform writes to memory for the %n specifier.
+</small>
<a name="7.28.2.1" href="#7.28.2.1"><h5>7.28.2.1 The fwprintf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int fwprintf(FILE * restrict stream,
const wchar_t * restrict format, ...);</pre>
<h6>Description</h6>
EXAMPLE To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
places:
<pre>
- #include <math.h>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
/* ... */
wchar_t *weekday, *month; // pointers to wide strings
int day, hour, min;
weekday, month, day, hour, min);
fwprintf(stdout, L"pi = %.5f\n", 4 * atan(1.0));</pre>
-
Forward references: the btowc function (<a href="#7.28.6.1.1">7.28.6.1.1</a>), the mbrtowc function
+
<p><b> Forward references</b>: the btowc function (<a href="#7.28.6.1.1">7.28.6.1.1</a>), the mbrtowc function
(<a href="#7.28.6.3.2">7.28.6.3.2</a>).
<h6>footnotes</h6>
-<p><a name="note317">317)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
-
-<p><a name="note318">318)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+<p><small><a name="note317" href="#note317">317)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
+</small>
+<p><small><a name="note318" href="#note318">318)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
include a minus sign.
-
-<p><a name="note319">319)</a> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
+</small>
+<p><small><a name="note319" href="#note319">319)</a> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
meaning; the # and 0 flag wide characters have no effect.
-
-<p><a name="note320">320)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
+</small>
+<p><small><a name="note320" href="#note320">320)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
character so that subsequent digits align to nibble (4-bit) boundaries.
-
-<p><a name="note321">321)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 > b n where b is
+</small>
+<p><small><a name="note321" href="#note321">321)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 > b n where b is
FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
might suffice depending on the implementation's scheme for determining the digit to the left of the
decimal-point wide character.
-
-<p><
a name="note322">322)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
-
-<p><a name="note323">323)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+</small>
+<p><
small><a name="note322" href="#note322">322)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+</small>
+<p><small><a name="note323" href="#note323">323)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
given format specifier. The number of significant digits is determined by the format specifier, and in
the case of fixed-point conversion by the source value as well.
-
+</small>
<a name="7.28.2.2" href="#7.28.2.2"><h5>7.28.2.2 The fwscanf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int fwscanf(FILE * restrict stream,
const wchar_t * restrict format, ...);</pre>
<h6>Description</h6>
<p><!--para 17-->
EXAMPLE 1 The call:
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
/* ... */
int n, i; float x; wchar_t name[50];
n = fwscanf(stdin, L"%d%f%ls", &i, &x, name);</pre>
<p><!--para 18-->
EXAMPLE 2 The call:
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
/* ... */
int i; float x; double y;
fwscanf(stdin, L"%2d%f%*d %lf", &i, &x, &y);</pre>
<!--page 431 indent 4-->
-
Forward references: the wcstod, wcstof, and wcstold functions (<a href="#7.28.4.1.1">7.28.4.1.1</a>), the
+
<p><b> Forward references</b>: the wcstod, wcstof, and wcstold functions (<a href="#7.28.4.1.1">7.28.4.1.1</a>), the
wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.28.4.1.2">7.28.4.1.2</a>), the wcrtomb
function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
<h6>footnotes</h6>
-<p><a name="note324">324)</a> These white-space wide characters are not counted against a specified field width.
-
-<p><a name="note325">325)</a> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
+<p><small><a name="note324" href="#note324">324)</a> These white-space wide characters are not counted against a specified field width.
+</small>
+<p><small><a name="note325" href="#note325">325)</a> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
-
-<p><
a name="note326">326)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
-
+</small>
+<p><
small><a name="note326" href="#note326">326)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+</small>
<a name="7.28.2.3" href="#7.28.2.3"><h5>7.28.2.3 The swprintf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int swprintf(wchar_t * restrict s,
size_t n,
const wchar_t * restrict format, ...);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int swscanf(const wchar_t * restrict s,
const wchar_t * restrict format, ...);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vfwprintf(FILE * restrict stream,
const wchar_t * restrict format,
va_list arg);</pre>
EXAMPLE The following shows the use of the vfwprintf function in a general error-reporting
routine.
<pre>
- #include <stdarg.h>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
void error(char *function_name, wchar_t *format, ...)
{
va_list args;
<!--page 433 indent 4-->
<h6>footnotes</h6>
-<p><a name="note327">327)</a> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
+<p><small><a name="note327" href="#note327">327)</a> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
invoke the va_arg macro, the value of arg after the return is indeterminate.
-
+</small>
<a name="7.28.2.6" href="#7.28.2.6"><h5>7.28.2.6 The vfwscanf function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vfwscanf(FILE * restrict stream,
const wchar_t * restrict format,
va_list arg);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vswprintf(wchar_t * restrict s,
size_t n,
const wchar_t * restrict format,
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vswscanf(const wchar_t * restrict s,
const wchar_t * restrict format,
va_list arg);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vwprintf(const wchar_t * restrict format,
va_list arg);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vwscanf(const wchar_t * restrict format,
va_list arg);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wprintf(const wchar_t * restrict format, ...);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wscanf(const wchar_t * restrict format, ...);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
wint_t fgetwc(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note328"><b>328)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note328">328)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+<p><small><a name="note328" href="#note328">328)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
-
+</small>
<a name="7.28.3.2" href="#7.28.3.2"><h5>7.28.3.2 The fgetws function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *fgetws(wchar_t * restrict s,
int n, FILE * restrict stream);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
wint_t fputwc(wchar_t c, FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int fputws(const wchar_t * restrict s,
FILE * restrict stream);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int fwide(FILE *stream, int mode);</pre>
<h6>Description</h6>
<p><!--para 2-->
stream has no orientation.
<h6>footnotes</h6>
-<p><a name="note329">329)</a> If the orientation of the stream has already been determined, fwide does not change it.
-
+<p><small><a name="note329" href="#note329">329)</a> If the orientation of the stream has already been determined, fwide does not change it.
+</small>
<a name="7.28.3.6" href="#7.28.3.6"><h5>7.28.3.6 The getwc function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
wint_t getwc(FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wint_t getwchar(void);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
wint_t putwc(wchar_t c, FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wint_t putwchar(wchar_t c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
wint_t ungetwc(wint_t c, FILE *stream);</pre>
<h6>Description</h6>
<p><!--para 2-->
<a name="7.28.4" href="#7.28.4"><h4>7.28.4 General wide string utilities</h4></a>
<p><!--para 1-->
- The header <wchar.h> declares a number of functions useful for wide string
+ The header <a href="#7.28"><wchar.h></a> declares a number of functions useful for wide string
manipulation. Various methods are used for determining the lengths of the arrays, but in
all cases a wchar_t * argument points to the initial (lowest addressed) element of the
array. If an array is accessed beyond the end of an object, the behavior is undefined.
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
double wcstod(const wchar_t * restrict nptr,
wchar_t ** restrict endptr);
float wcstof(const wchar_t * restrict nptr,
<!--page 443 indent 5-->
<p><!--para 9-->
If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
- <float.h>) significant digits, the result should be correctly rounded. If the subject
+ <a href="#7.7"><float.h></a>) significant digits, the result should be correctly rounded. If the subject
sequence D has the decimal form and more than DECIMAL_DIG significant digits,
consider the two bounding, adjacent decimal strings L and U, both having
DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L <= D <= U.
<!--page 444 indent 4-->
<h6>footnotes</h6>
-<p><a name="note330">330)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+<p><small><a name="note330" href="#note330">330)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
methods may yield different results if rounding is toward positive or negative infinity. In either case,
the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
-
-<p><a name="note331">331)</a> An implementation may use the n-wchar sequence to determine extra information to be represented in
+</small>
+<p><small><a name="note331" href="#note331">331)</a> An implementation may use the n-wchar sequence to determine extra information to be represented in
the NaN's significand.
-
-<p><a name="note332">332)</a> DECIMAL_DIG, defined in <float.h>, should be sufficiently large that L and U will usually round
+</small>
+<p><small><a name="note332" href="#note332">332)</a> DECIMAL_DIG, defined in <a href="#7.7"><float.h></a>, should be sufficiently large that L and U will usually round
to the same internal floating value, but if not will round to adjacent values.
-
+</small>
<a name="7.28.4.1.2" href="#7.28.4.1.2"><h5>7.28.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
long int wcstol(
const wchar_t * restrict nptr,
wchar_t ** restrict endptr,
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcscpy(wchar_t * restrict s1,
const wchar_t * restrict s2);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcsncpy(wchar_t * restrict s1,
const wchar_t * restrict s2,
size_t n);</pre>
The wcsncpy function returns the value of s1.
<h6>footnotes</h6>
-<p><a name="note333">333)</a> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
+<p><small><a name="note333" href="#note333">333)</a> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
result will not be null-terminated.
-
+</small>
<a name="7.28.4.2.3" href="#7.28.4.2.3"><h5>7.28.4.2.3 The wmemcpy function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wmemcpy(wchar_t * restrict s1,
const wchar_t * restrict s2,
size_t n);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
size_t n);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcscat(wchar_t * restrict s1,
const wchar_t * restrict s2);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcsncat(wchar_t * restrict s1,
const wchar_t * restrict s2,
size_t n);</pre>
The wcsncat function returns the value of s1.
<h6>footnotes</h6>
-<p><a name="note334">334)</a> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
+<p><small><a name="note334" href="#note334">334)</a> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
wcslen(s1)+n+1.
-
+</small>
<a name="7.28.4.4" href="#7.28.4.4"><h5>7.28.4.4 Wide string comparison functions</h5></a>
<p><!--para 1-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wcscmp(const wchar_t *s1, const wchar_t *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wcscoll(const wchar_t *s1, const wchar_t *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wcsncmp(const wchar_t *s1, const wchar_t *s2,
size_t n);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcsxfrm(wchar_t * restrict s1,
const wchar_t * restrict s2,
size_t n);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wmemcmp(const wchar_t *s1, const wchar_t *s2,
size_t n);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcschr(const wchar_t *s, wchar_t c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcscspn(const wchar_t *s1, const wchar_t *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcsrchr(const wchar_t *s, wchar_t c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcsspn(const wchar_t *s1, const wchar_t *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcstok(wchar_t * restrict s1,
const wchar_t * restrict s2,
wchar_t ** restrict ptr);</pre>
<p><!--para 8-->
EXAMPLE
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
static wchar_t str1[] = L"?a???b,,,#c";
static wchar_t str2[] = L"\t \t";
wchar_t *t, *ptr1, *ptr2;
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wmemchr(const wchar_t *s, wchar_t c,
size_t n);</pre>
<h6>Description</h6>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcslen(const wchar_t *s);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <time.h>
- #include <wchar.h>
+ #include <a href="#7.26"><time.h></a>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcsftime(wchar_t * restrict s,
size_t maxsize,
const wchar_t * restrict format,
<a name="7.28.6" href="#7.28.6"><h4>7.28.6 Extended multibyte/wide character conversion utilities</h4></a>
<p><!--para 1-->
- The header <wchar.h> declares an extended set of functions useful for conversion
+ The header <a href="#7.28"><wchar.h></a> declares an extended set of functions useful for conversion
between multibyte characters and wide characters.
<p><!--para 2-->
Most of the following functions -- those that are listed as ''restartable'', <a href="#7.28.6.3">7.28.6.3</a> and
<!--page 456 indent 4-->
<h6>footnotes</h6>
-<p><a name="note335">335)</a> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
+<p><small><a name="note335" href="#note335">335)</a> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
character string.
-
+</small>
<a name="7.28.6.1" href="#7.28.6.1"><h5>7.28.6.1 Single-byte/wide character conversion functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h> *
+ #include <a href="#7.28"><wchar.h></a> *
wint_t btowc(int c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h> *
+ #include <a href="#7.28"><wchar.h></a> *
int wctob(wint_t c);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int mbsinit(const mbstate_t *ps);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t mbrlen(const char * restrict s,
size_t n,
mbstate_t * restrict ps);</pre>
<p><!--para 3-->
The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
or (size_t)(-1).
-
Forward references: the mbrtowc function (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
+
<p><b> Forward references</b>: the mbrtowc function (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
<!--page 458 indent 4-->
<a name="7.28.6.3.2" href="#7.28.6.3.2"><h5>7.28.6.3.2 The mbrtowc function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t mbrtowc(wchar_t * restrict pwc,
const char * restrict s,
size_t n,
<!--page 459 indent 4-->
<h6>footnotes</h6>
-<p><a name="note336">336)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+<p><small><a name="note336" href="#note336">336)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
sequence of redundant shift sequences (for implementations with state-dependent encodings).
-
+</small>
<a name="7.28.6.3.3" href="#7.28.6.3.3"><h5>7.28.6.3.3 The wcrtomb function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcrtomb(char * restrict s,
wchar_t wc,
mbstate_t * restrict ps);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t mbsrtowcs(wchar_t * restrict dst,
const char ** restrict src,
size_t len,
<!--page 461 indent 4-->
<h6>footnotes</h6>
-<p><a name="note337">337)</a> Thus, the value of len is ignored if dst is a null pointer.
-
+<p><small><a name="note337" href="#note337">337)</a> Thus, the value of len is ignored if dst is a null pointer.
+</small>
<a name="7.28.6.4.2" href="#7.28.6.4.2"><h5>7.28.6.4.2 The wcsrtombs function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcsrtombs(char * restrict dst,
const wchar_t ** restrict src,
size_t len,
<!--page 462 indent 4-->
<h6>footnotes</h6>
-<p><a name="note338">338)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
+<p><small><a name="note338" href="#note338">338)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
include those necessary to reach the initial shift state immediately before the null byte.
-
+</small>
<a name="7.29" href="#7.29"><h3>7.29 Wide character classification and mapping utilities <wctype.h></h3></a>
<a name="7.29.1" href="#7.29.1"><h4>7.29.1 Introduction</h4></a>
<p><!--para 1-->
- The header <wctype.h> defines one macro, and declares three data types and many
+ The header <a href="#7.29"><wctype.h></a> defines one macro, and declares three data types and many
functions.<sup><a href="#note339"><b>339)</b></a></sup>
<p><!--para 2-->
The types declared are
<!--page 463 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note339">339)</a> See ''future library directions'' (<a href="#7.30.13">7.30.13</a>).
-
+<p><
small><a name="note339" href="#note339">339)</a> See ''future library directions'' (<a href="#7.30.13">7.30.13</a>).
+</small>
<a name="7.29.2" href="#7.29.2"><h4>7.29.2 Wide character classification utilities</h4></a>
<p><!--para 1-->
- The header <wctype.h> declares several functions useful for classifying wide
+ The header <a href="#7.29"><wctype.h></a> declares several functions useful for classifying wide
characters.
<p><!--para 2-->
The term printing wide character refers to a member of a locale-specific set of wide
character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
iswpunct functions may differ with respect to wide characters other than L' ' that are
both printing and white-space wide characters.<sup><a href="#note340"><b>340)</b></a></sup>
-
Forward references: the wctob function (<a href="#7.28.6.1.2">7.28.6.1.2</a>).
+
<p><b> Forward references</b>: the wctob function (<a href="#7.28.6.1.2">7.28.6.1.2</a>).
<h6>footnotes</h6>
-<p><a name="note340">340)</a> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
+<p><small><a name="note340" href="#note340">340)</a> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
(which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
&& iswspace(wc) is true, but not both.
-
+</small>
<a name="7.29.2.1.1" href="#7.29.2.1.1"><h5>7.29.2.1.1 The iswalnum function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswalnum(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswalpha(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
is true.<sup><a href="#note341"><b>341)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note341">341)</a> The functions iswlower and iswupper test true or false separately for each of these additional
+<p><small><a name="note341" href="#note341">341)</a> The functions iswlower and iswupper test true or false separately for each of these additional
wide characters; all four combinations are possible.
-
+</small>
<a name="7.29.2.1.3" href="#7.29.2.1.3"><h5>7.29.2.1.3 The iswblank function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswblank(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswcntrl(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswdigit(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswgraph(wint_t wc);</pre>
iswspace is false.<sup><a href="#note342"><b>342)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note342">342)</a> Note that the behavior of the iswgraph and iswpunct functions may differ from their
+<p><small><a name="note342" href="#note342">342)</a> Note that the behavior of the iswgraph and iswpunct functions may differ from their
corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
characters other than ' '.
-
+</small>
<a name="7.29.2.1.7" href="#7.29.2.1.7"><h5>7.29.2.1.7 The iswlower function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswlower(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswprint(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswpunct(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswspace(wint_t wc);</pre>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswupper(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswxdigit(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
int iswctype(wint_t wc, wctype_t desc);</pre>
<h6>Description</h6>
<p><!--para 2-->
The iswctype function returns nonzero (true) if and only if the value of the wide
character wc has the property described by desc. If desc is zero, the iswctype
function returns zero (false).
-
Forward references: the wctype function (<a href="#7.29.2.2.2">7.29.2.2.2</a>).
+
<p><b> Forward references</b>: the wctype function (<a href="#7.29.2.2.2">7.29.2.2.2</a>).
<a name="7.29.2.2.2" href="#7.29.2.2.2"><h5>7.29.2.2.2 The wctype function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
wctype_t wctype(const char *property);</pre>
<h6>Description</h6>
<p><!--para 2-->
<a name="7.29.3" href="#7.29.3"><h4>7.29.3 Wide character case mapping utilities</h4></a>
<p><!--para 1-->
- The header <wctype.h> declares several functions useful for mapping wide characters.
+ The header <a href="#7.29"><wctype.h></a> declares several functions useful for mapping wide characters.
<a name="7.29.3.1" href="#7.29.3.1"><h5>7.29.3.1 Wide character case mapping functions</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
wint_t towlower(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
wint_t towupper(wint_t wc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
wint_t towctrans(wint_t wc, wctrans_t desc);</pre>
<h6>Description</h6>
<p><!--para 2-->
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <wctype.h>
+ #include <a href="#7.29"><wctype.h></a>
wctrans_t wctrans(const char *property);</pre>
<h6>Description</h6>
<p><!--para 2-->
cerfc clog10 clgamma
cexp2 clog1p ctgamma</pre>
and the same names suffixed with f or l may be added to the declarations in the
- <complex.h> header.
+ <a href="#7.3"><complex.h></a> header.
<a name="7.30.2" href="#7.30.2"><h4>7.30.2 Character handling <ctype.h></h4></a>
<p><!--para 1-->
Function names that begin with either is or to, and a lowercase letter may be added to
- the declarations in the <ctype.h> header.
+ the declarations in the <a href="#7.4"><ctype.h></a> header.
<a name="7.30.3" href="#7.30.3"><h4>7.30.3 Errors <errno.h></h4></a>
<p><!--para 1-->
Macros that begin with E and a digit or E and an uppercase letter may be added to the
- declarations in the <errno.h> header.
+ declarations in the <a href="#7.5"><errno.h></a> header.
<a name="7.30.4" href="#7.30.4"><h4>7.30.4 Format conversion of integer types <inttypes.h></h4></a>
<p><!--para 1-->
Macro names beginning with PRI or SCN followed by any lowercase letter or X may be
- added to the macros defined in the <inttypes.h> header.
+ added to the macros defined in the <a href="#7.8"><inttypes.h></a> header.
<a name="7.30.5" href="#7.30.5"><h4>7.30.5 Localization <locale.h></h4></a>
<p><!--para 1-->
Macros that begin with LC_ and an uppercase letter may be added to the definitions in
- the <locale.h> header.
+ the <a href="#7.11"><locale.h></a> header.
<a name="7.30.6" href="#7.30.6"><h4>7.30.6 Signal handling <signal.h></h4></a>
<p><!--para 1-->
Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
- letter may be added to the definitions in the <signal.h> header.
+ letter may be added to the definitions in the <a href="#7.14"><signal.h></a> header.
<a name="7.30.7" href="#7.30.7"><h4>7.30.7 Boolean type and values <stdbool.h></h4></a>
<p><!--para 1-->
<a name="7.30.8" href="#7.30.8"><h4>7.30.8 Integer types <stdint.h></h4></a>
<p><!--para 1-->
Typedef names beginning with int or uint and ending with _t may be added to the
- types defined in the <stdint.h> header. Macro names beginning with INT or UINT
+ types defined in the <a href="#7.20"><stdint.h></a> header. Macro names beginning with INT or UINT
and ending with _MAX, _MIN, or _C may be added to the macros defined in the
- <stdint.h> header.
+ <a href="#7.20"><stdint.h></a> header.
<!--page 471 indent 4-->
<a name="7.30.9" href="#7.30.9"><h4>7.30.9 Input/output <stdio.h></h4></a>
<a name="7.30.10" href="#7.30.10"><h4>7.30.10 General utilities <stdlib.h></h4></a>
<p><!--para 1-->
Function names that begin with str and a lowercase letter may be added to the
- declarations in the <stdlib.h> header.
+ declarations in the <a href="#7.22"><stdlib.h></a> header.
<a name="7.30.11" href="#7.30.11"><h4>7.30.11 String handling <string.h></h4></a>
<p><!--para 1-->
Function names that begin with str, mem, or wcs and a lowercase letter may be added
- to the declarations in the <string.h> header.
+ to the declarations in the <a href="#7.23"><string.h></a> header.
<a name="7.30.12" href="#7.30.12"><h4>7.30.12 Extended multibyte and wide character utilities <wchar.h></h4></a>
<p><!--para 1-->
Function names that begin with wcs and a lowercase letter may be added to the
- declarations in the <wchar.h> header.
+ declarations in the <a href="#7.28"><wchar.h></a> header.
<p><!--para 2-->
Lowercase letters may be added to the conversion specifiers and length modifiers in
fwprintf and fwscanf. Other characters may be used in extensions.
<a name="7.30.13" href="#7.30.13"><h4>7.30.13 Wide character classification and mapping utilities</h4></a>
- <wctype.h>
+ <a href="#7.29"><wctype.h></a>
<p><!--para 1-->
Function names that begin with is or to and a lowercase letter may be added to the
- declarations in the <wctype.h> header.
+ declarations in the <a href="#7.29"><wctype.h></a> header.
<!--page 472 indent 4-->
<a name="A" href="#A"><h2>Annex A</h2></a>
<pre>
(informative)
Implementation limits</pre>
- The contents of the header <limits.h> are given below, in alphabetical order. The
+ The contents of the header <a href="#7.10"><limits.h></a> are given below, in alphabetical order. The
minimum magnitudes shown shall be replaced by implementation-defined magnitudes
with the same sign. The values shall all be constant expressions suitable for use in #if
preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
#define UINT_MAX 65535
#define ULONG_MAX 4294967295
#define ULLONG_MAX 18446744073709551615</pre>
- The contents of the header <float.h> are given below. All integer values, except
+ The contents of the header <a href="#7.7"><float.h></a> are given below. All integer values, except
FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
directives; all floating values shall be constant expressions. The components are
described further in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
within the range of representable values.
<h6>footnotes</h6>
-<p><a name="note343">343)</a> Implementations that do not define __STDC_IEC_559__ are not required to conform to these
+<p><small><a name="note343" href="#note343">343)</a> Implementations that do not define __STDC_IEC_559__ are not required to conform to these
specifications.
-
+</small>
<a name="F.2" href="#F.2"><h3>F.2 Types</h3></a>
<p><!--para 1-->
The long double type should match an IEC 60559 extended format.
<h6>footnotes</h6>
-<p><a name="note344">344)</a> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
+<p><small><a name="note344" href="#note344">344)</a> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
and quadruple 128-bit IEC 60559 formats.
-
-<p><a name="note345">345)</a> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
+</small>
+<p><small><a name="note345" href="#note345">345)</a> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
all double values.
-
+</small>
<a name="F.2.1" href="#F.2.1"><h4>F.2.1 Infinities, signed zeros, and NaNs</h4></a>
<p><!--para 1-->
This specification does not define the behavior of signaling NaNs.<sup><a href="#note346"><b>346)</b></a></sup> It generally uses
the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
- functions in <math.h> provide designations for IEC 60559 NaNs and infinities.
+ functions in <a href="#7.12"><math.h></a> provide designations for IEC 60559 NaNs and infinities.
<h6>footnotes</h6>
-<p><a name="note346">346)</a> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
+<p><small><a name="note346" href="#note346">346)</a> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
sufficient for closure of the arithmetic.
-
+</small>
<a name="F.3" href="#F.3"><h3>F.3 Operators and functions</h3></a>
<p><!--para 1-->
<ul>
<li> The +, -, *, and / operators provide the IEC 60559 add, subtract, multiply, and
divide operations.
-<li> The sqrt functions in <math.h> provide the IEC 60559 square root operation.
-<li> The remainder functions in <math.h> provide the IEC 60559 remainder
- operation. The remquo functions in <math.h> provide the same operation but
+<li> The sqrt functions in <a href="#7.12"><math.h></a> provide the IEC 60559 square root operation.
+<li> The remainder functions in <a href="#7.12"><math.h></a> provide the IEC 60559 remainder
+ operation. The remquo functions in <a href="#7.12"><math.h></a> provide the same operation but
with additional information.
-<li> The rint functions in <math.h> provide the IEC 60559 operation that rounds a
+<li> The rint functions in <a href="#7.12"><math.h></a> provide the IEC 60559 operation that rounds a
floating-point number to an integer value (in the same precision). The nearbyint
- functions in <math.h> provide the nearbyinteger function recommended in the
+ functions in <a href="#7.12"><math.h></a> provide the nearbyinteger function recommended in the
Appendix to ANSI/IEEE 854.
<li> The conversions for floating types provide the IEC 60559 conversions between
floating-point precisions.
from integer to floating point.
<li> The conversions from floating to integer types provide IEC 60559-like conversions
but always round toward zero.
-<li> The lrint and llrint functions in <math.h> provide the IEC 60559
+<li> The lrint and llrint functions in <a href="#7.12"><math.h></a> provide the IEC 60559
conversions, which honor the directed rounding mode, from floating point to the
long int and long long int integer formats. The lrint and llrint
functions can be used to implement IEC 60559 conversions from floating to other
integer formats.
<li> The translation time conversion of floating constants and the strtod, strtof,
- strtold, fprintf, fscanf, and related library functions in <stdlib.h>,
+ strtold, fprintf, fscanf, and related library functions in <a href="#7.22"><stdlib.h></a>,
<!--page 523 indent 0-->
- <stdio.h>, and <wchar.h> provide IEC 60559 binary-decimal conversions. The
- strtold function in <stdlib.h> provides the conv function recommended in the
+ <a href="#7.21"><stdio.h></a>, and <a href="#7.28"><wchar.h></a> provide IEC 60559 binary-decimal conversions. The
+ strtold function in <a href="#7.22"><stdlib.h></a> provides the conv function recommended in the
Appendix to ANSI/IEEE 854.
<li> The relational and equality operators provide IEC 60559 comparisons. IEC 60559
identifies a need for additional comparison predicates to facilitate writing code that
accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
- isless, islessequal, islessgreater, and isunordered) in <math.h>
+ isless, islessequal, islessgreater, and isunordered) in <a href="#7.12"><math.h></a>
supplement the language operators to address this need. The islessgreater and
isunordered macros provide respectively a quiet version of the <> predicate and
the unordered predicate recommended in the Appendix to IEC 60559.
<li> The feclearexcept, feraiseexcept, and fetestexcept functions in
- <fenv.h> provide the facility to test and alter the IEC 60559 floating-point
+ <a href="#7.6"><fenv.h></a> provide the facility to test and alter the IEC 60559 floating-point
exception status flags. The fegetexceptflag and fesetexceptflag
- functions in <fenv.h> provide the facility to save and restore all five status flags at
+ functions in <a href="#7.6"><fenv.h></a> provide the facility to save and restore all five status flags at
one time. These functions are used in conjunction with the type fexcept_t and the
floating-point exception macros (FE_INEXACT, FE_DIVBYZERO,
- FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in <fenv.h>.
-<li> The fegetround and fesetround functions in <fenv.h> provide the facility
+ FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in <a href="#7.6"><fenv.h></a>.
+<li> The fegetround and fesetround functions in <a href="#7.6"><fenv.h></a> provide the facility
to select among the IEC 60559 directed rounding modes represented by the rounding
- direction macros in <fenv.h> (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
+ direction macros in <a href="#7.6"><fenv.h></a> (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the
IEC 60559 directed rounding modes.
<li> The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
- <fenv.h> provide a facility to manage the floating-point environment, comprising
+ <a href="#7.6"><fenv.h></a> provide a facility to manage the floating-point environment, comprising
the IEC 60559 status flags and control modes.
-<li> The copysign functions in <math.h> provide the copysign function
+<li> The copysign functions in <a href="#7.12"><math.h></a> provide the copysign function
recommended in the Appendix to IEC 60559.
-<li> The fabs functions in <math.h> provide the abs function recommended in the
+<li> The fabs functions in <a href="#7.12"><math.h></a> provide the abs function recommended in the
Appendix to IEC 60559.
<li> The unary minus (-) operator provides the unary minus (-) operation recommended
in the Appendix to IEC 60559.
-<li> The scalbn and scalbln functions in <math.h> provide the scalb function
+<li> The scalbn and scalbln functions in <a href="#7.12"><math.h></a> provide the scalb function
recommended in the Appendix to IEC 60559.
-<li> The logb functions in <math.h> provide the logb function recommended in the
+<li> The logb functions in <a href="#7.12"><math.h></a> provide the logb function recommended in the
Appendix to IEC 60559, but following the newer specifications in ANSI/IEEE 854.
-<li> The nextafter and nexttoward functions in <math.h> provide the nextafter
+<li> The nextafter and nexttoward functions in <a href="#7.12"><math.h></a> provide the nextafter
function recommended in the Appendix to IEC 60559 (but with a minor change to
<!--page 524 indent 4-->
better handle signed zeros).
-<li> The isfinite macro in <math.h> provides the finite function recommended in
+<li> The isfinite macro in <a href="#7.12"><math.h></a> provides the finite function recommended in
the Appendix to IEC 60559.
-<li> The isnan macro in <math.h> provides the isnan function recommended in the
+<li> The isnan macro in <a href="#7.12"><math.h></a> provides the isnan function recommended in the
Appendix to IEC 60559.
-<li> The signbit macro and the fpclassify macro in <math.h>, used in
+<li> The signbit macro and the fpclassify macro in <a href="#7.12"><math.h></a>, used in
conjunction with the number classification macros (FP_NAN, FP_INFINITE,
FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
function recommended in the Appendix to IEC 60559 (except that the classification
unspecified.<sup><a href="#note347"><b>347)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note347">347)</a> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
+<p><small><a name="note347" href="#note347">347)</a> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
cases where it matters, library functions can be used to effect such conversions with or without raising
the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
- <math.h>.
-
+ <a href="#7.12"><math.h></a>.
+</small>
<a name="F.5" href="#F.5"><h3>F.5 Binary-decimal conversion</h3></a>
<p><!--para 1-->
unsigned sequence.
<h6>footnotes</h6>
-<p><a name="note348">348)</a> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
+<p><small><a name="note348" href="#note348">348)</a> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
DECIMAL_DIG shall be at least 21. If IEC 60559 double (53 bits of precision) is the widest
IEC 60559 format supported, then DECIMAL_DIG shall be at least 17. (By contrast, LDBL_DIG and
DBL_DIG are 18 and 15, respectively, for these formats.)
-
+</small>
<a name="F.6" href="#F.6"><h3>F.6 The return statement</h3></a>
If the return expression is evaluated in a floating-point format different from the return
and the resulting value is returned to the caller.
<h6>footnotes</h6>
-<p><a name="note349">349)</a> Assignment removes any extra range and precision.
-
+<p><small><a name="note349" href="#note349">349)</a> Assignment removes any extra range and precision.
+</small>
<a name="F.7" href="#F.7"><h3>F.7 Contracted expressions</h3></a>
<p><!--para 1-->
<a name="F.8" href="#F.8"><h3>F.8 Floating-point environment</h3></a>
<p><!--para 1-->
- The floating-point environment defined in <fenv.h> includes the IEC 60559 floating-
+ The floating-point environment defined in <a href="#7.6"><fenv.h></a> includes the IEC 60559 floating-
point exception status flags and directed-rounding control modes. It includes also
IEC 60559 dynamic rounding precision and trap enablement modes, if the
implementation supports them.<sup><a href="#note350"><b>350)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note350">350)</a> This specification does not require dynamic rounding precision nor trap enablement modes.
-
+<p><small><a name="note350" href="#note350">350)</a> This specification does not require dynamic rounding precision nor trap enablement modes.
+</small>
<a name="F.8.1" href="#F.8.1"><h4>F.8.1 Environment management</h4></a>
<p><!--para 1-->
IEC 60559 requires that floating-point operations implicitly raise floating-point exception
status flags, and that rounding control modes can be set explicitly to affect result values of
floating-point operations. When the state for the FENV_ACCESS pragma (defined in
- <fenv.h>) is ''on'', these changes to the floating-point state are treated as side effects
+ <a href="#7.6"><fenv.h></a>) is ''on'', these changes to the floating-point state are treated as side effects
which respect sequence points.<sup><a href="#note351"><b>351)</b></a></sup>
<!--page 526 indent 4-->
<h6>footnotes</h6>
-<p><a name="note351">351)</a> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
+<p><small><a name="note351" href="#note351">351)</a> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
point control modes will be the default ones and the floating-point status flags will not be tested,
which allows certain optimizations (see <a href="#F.9">F.9</a>).
-
+</small>
<a name="F.8.2" href="#F.8.2"><h4>F.8.2 Translation</h4></a>
<p><!--para 1-->
proceed with the translation of the program.
<h6>footnotes</h6>
-<p><a name="note352">352)</a> As floating constants are converted to appropriate internal representations at translation time, their
+<p><small><a name="note352" href="#note352">352)</a> As floating constants are converted to appropriate internal representations at translation time, their
conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
(even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
strtod, provide execution-time conversion of numeric strings.
-
+</small>
<a name="F.8.3" href="#F.8.3"><h4>F.8.3 Execution</h4></a>
<p><!--para 1-->
<!--page 527 indent 4-->
<p><!--para 3-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS ON
void f(void)
{
<h6>footnotes</h6>
-<p><a name="note353">353)</a> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
+<p><small><a name="note353" href="#note353">353)</a> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
are affected by rounding modes set at execution time, and expressions such as 0.0/0.0 and
1.0/0.0 generate execution-time floating-point exceptions. The programmer can achieve the
efficiency of translation-time evaluation through static initialization, such as
<pre>
const static double one_third = 1.0/3.0;</pre>
-
+</small>
<a name="F.8.5" href="#F.8.5"><h4>F.8.5 Initialization</h4></a>
<p><!--para 1-->
EXAMPLE
<p><!--para 3-->
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS ON
void f(void)
{
<h6>footnotes</h6>
-<p><a name="note354">354)</a> Use of float_t and double_t variables increases the likelihood of translation-time computation.
+<p><small><a name="note354" href="#note354">354)</a> Use of float_t and double_t variables increases the likelihood of translation-time computation.
For example, the automatic initialization
<pre>
double_t x = 1.1e75;</pre>
could be done at translation time, regardless of the expression evaluation method.
-
+</small>
<a name="F.8.6" href="#F.8.6"><h4>F.8.6 Changing the environment</h4></a>
<p><!--para 1-->
specifications (including conformance to IEC 60559). They do not change flags or modes
(so as to be detectable by the user) in any other cases.
<p><!--para 2-->
- If the argument to the feraiseexcept function in <fenv.h> represents IEC 60559
+ If the argument to the feraiseexcept function in <a href="#7.6"><fenv.h></a> represents IEC 60559
valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
before ''inexact''.
Concern about side effects may inhibit code motion and removal of seemingly useless
code. For example, in
<pre>
- #include <fenv.h>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS ON
void f(double x)
{
<!--page 530 indent 4-->
<h6>footnotes</h6>
-<p><a name="note355">355)</a> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
+<p><small><a name="note355" href="#note355">355)</a> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
other transformations that remove arithmetic operators.
-
-<p><a name="note356">356)</a> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
+</small>
+<p><small><a name="note356" href="#note356">356)</a> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
Examples include:
<pre>
<pre>
conj(csqrt(z)) is csqrt(conj(z)),</pre>
for complex z.
-
+</small>
<a name="F.9.3" href="#F.9.3"><h4>F.9.3 Relational operators</h4></a>
<p><!--para 1-->
point exception when converted to the semantic type of the operation.
<h6>footnotes</h6>
-<p><a name="note357">357)</a> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
-
+<p><small><a name="note357" href="#note357">357)</a> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
+</small>
<a name="F.10" href="#F.10"><h3>F.10 Mathematics <math.h></h3></a>
<p><!--para 1-->
- This subclause contains specifications of <math.h> facilities that are particularly suited
+ This subclause contains specifications of <a href="#7.12"><math.h></a> facilities that are particularly suited
for IEC 60559 implementations.
<p><!--para 2-->
The Standard C macro HUGE_VAL and its float and long double analogs,
HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
infinities.
<p><!--para 3-->
- Special cases for functions in <math.h> are covered directly or indirectly by
+ Special cases for functions in <a href="#7.12"><math.h></a> are covered directly or indirectly by
IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
- other functions in <math.h> treat infinities, NaNs, signed zeros, subnormals, and
+ other functions in <a href="#7.12"><math.h></a> treat infinities, NaNs, signed zeros, subnormals, and
(provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
in a manner consistent with the basic arithmetic operations covered by IEC 60559.
<p><!--para 4-->
unspecified, unless explicitly specified otherwise.
<p><!--para 9-->
Whether or when library functions raise an undeserved ''underflow'' floating-point
- exception is unspecified.<sup><a href="#note359"><b>359)</b></a></sup> Otherwise, as implied by <a href="#F.8.6">F.8.6</a>, the <math.h> functions do
+ exception is unspecified.<sup><a href="#note359"><b>359)</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
not raise spurious floating-point exceptions (detectable by the user), other than the
''inexact'' floating-point exception.
<p><!--para 10-->
Functions with a NaN argument return a NaN result and raise no floating-point exception,
except where stated otherwise.
<p><!--para 12-->
- The specifications in the following subclauses append to the definitions in <math.h>.
+ The specifications in the following subclauses append to the definitions in <a href="#7.12"><math.h></a>.
For families of functions, the specifications apply to all of the functions even though only
the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
occurs in both an argument and the result, the result has the same sign as the argument.
for the sign.
<h6>footnotes</h6>
-<p><a name="note358">358)</a> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
+<p><small><a name="note358" href="#note358">358)</a> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
when the floating-point exception is raised.
-
-<p><a name="note359">359)</a> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
+</small>
+<p><small><a name="note359" href="#note359">359)</a> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
avoiding them would be too costly.
-
+</small>
<a name="F.10.1" href="#F.10.1"><h4>F.10.1 Trigonometric functions</h4></a>
</ul>
<h6>footnotes</h6>
-<p><a name="note360">360)</a> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y , 0) raise
+<p><small><a name="note360" href="#note360">360)</a> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y , 0) raise
the ''divide-by-zero'' floating-point exception.
-
+</small>
<a name="F.10.1.5" href="#F.10.1.5"><h5>F.10.1.5 The cos functions</h5></a>
<p><!--para 1-->
<p><!--para 3-->
modf behaves as though implemented by
<pre>
- #include <math.h>
- #include <fenv.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS ON
double modf(double value, double *iptr)
{
The double version of ceil behaves as though implemented by
<p><!--para 4-->
<pre>
- #include <math.h>
- #include <fenv.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS ON
double ceil(double x)
{
<p><!--para 3-->
The double version of round behaves as though implemented by
<pre>
- #include <math.h>
- #include <fenv.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS ON
double round(double x)
{
The double version of fmod behaves as though implemented by
<!--page 543 indent 4-->
<pre>
- #include <math.h>
- #include <fenv.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.6"><fenv.h></a>
#pragma STDC FENV_ACCESS ON
double fmod(double x, double y)
{
isnan(y)) ? x : y; }</pre>
<h6>footnotes</h6>
-<p><a name="note361">361)</a> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
+<p><small><a name="note361" href="#note361">361)</a> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
return +0; however, implementation in software might be impractical.
-
+</small>
<a name="F.10.9.3" href="#F.10.9.3"><h5>F.10.9.3 The fmin functions</h5></a>
<p><!--para 1-->
__STDC_IEC_559_COMPLEX__ shall conform to the specifications in this annex.<sup><a href="#note362"><b>362)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note362">362)</a> Implementations that do not define __STDC_IEC_559_COMPLEX__ are not required to conform
+<p><small><a name="note362" href="#note362">362)</a> Implementations that do not define __STDC_IEC_559_COMPLEX__ are not required to conform
to these specifications.
-
+</small>
<a name="G.2" href="#G.2"><h3>G.2 Types</h3></a>
<p><!--para 1-->
imaginary zero.
<h6>footnotes</h6>
-<p><
a name="note363">363)</a> See <a href="#6.3.1.2">6.3.1.2</a>.
-
+<p><
small><a name="note363" href="#note363">363)</a> See <a href="#6.3.1.2">6.3.1.2</a>.
+</small>
<a name="G.4.3" href="#G.4.3"><h4>G.4.3 Imaginary and complex</h4></a>
<p><!--para 1-->
<!--page 550 indent 4-->
<p><!--para 7-->
<pre>
- #include <math.h>
- #include <complex.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.3"><complex.h></a>
/* Multiply z * w ... */
double complex _Cmultd(double complex z, double complex w)
{
<!--page 551 indent 4-->
<p><!--para 9-->
<pre>
- #include <math.h>
- #include <complex.h>
+ #include <a href="#7.12"><math.h></a>
+ #include <a href="#7.3"><complex.h></a>
/* Divide z / w ... */
double complex _Cdivd(double complex z, double complex w)
{
<h6>footnotes</h6>
-<p><a name="note364">364)</a> These properties are already implied for those cases covered in the tables, but are required for all cases
+<p><small><a name="note364" href="#note364">364)</a> These properties are already implied for those cases covered in the tables, but are required for all cases
(at least where the state for CX_LIMITED_RANGE is ''off'').
-
+</small>
<a name="G.5.2" href="#G.5.2"><h4>G.5.2 Additive operators</h4></a>
<h6>Semantics</h6>
the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
imaginary.
<p><!--para 2-->
- This subclause contains specifications for the <complex.h> functions that are
+ This subclause contains specifications for the <a href="#7.3"><complex.h></a> functions that are
particularly suited to IEC 60559 implementations. For families of functions, the
specifications apply to all of the functions even though only the principal function is
<!--page 552 indent 4-->
<!--page 553 indent 4-->
<h6>footnotes</h6>
-<p><
a name="note365">365)</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
+<p><
small><a name="note365" href="#note365">365)</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
other part is a NaN.
-
+</small>
<a name="G.6.1" href="#G.6.1"><h4>G.6.1 Trigonometric functions</h4></a>
the parts of the result, and may also raise spurious floating-point exceptions.<sup><a href="#note366"><b>366)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note366">366)</a> This allows cpow( z , c ) to be implemented as cexp(c clog( z )) without precluding
+<p><small><a name="note366" href="#note366">366)</a> This allows cpow( z , c ) to be implemented as cexp(c clog( z )) without precluding
implementations that treat special cases more carefully.
-
+</small>
<a name="G.6.4.2" href="#G.6.4.2"><h5>G.6.4.2 The csqrt functions</h5></a>
<p><!--para 1-->
<a name="H.2.1" href="#H.2.1"><h4>H.2.1 Boolean type</h4></a>
<p><!--para 1-->
The LIA-1 data type Boolean is implemented by the C data type bool with values of
- true and false, all from <stdbool.h>.
+ true and false, all from <a href="#7.18"><stdbool.h></a>.
<a name="H.2.2" href="#H.2.2"><h4>H.2.2 Integer types</h4></a>
<p><!--para 1-->
<a name="H.3.1.1" href="#H.3.1.1"><h5>H.3.1.1 Indicators</h5></a>
<p><!--para 1-->
- C's <fenv.h> status flags are compatible with the LIA-1 indicators.
+ C's <a href="#7.6"><fenv.h></a> status flags are compatible with the LIA-1 indicators.
<p><!--para 2-->
The following mapping is for floating-point types:
undefined FE_INVALID, FE_DIVBYZERO
and ''hard to ignore'' message (see LIA-1 subclause <a href="#6.1.2">6.1.2</a>)
<p><!--para 5-->
LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
- This documentation makes that distinction because <fenv.h> covers only the floating-
+ This documentation makes that distinction because <a href="#7.6"><fenv.h></a> covers only the floating-
point indicators.
<a name="H.3.1.2" href="#H.3.1.2"><h5>H.3.1.2 Traps</h5></a>
<!--page 571 indent 4-->
<li> Whether conversion of non-integer IEC 60559 floating values to integer raises the
''inexact'' floating-point exception (<a href="#F.4">F.4</a>).
-<li> Whether or when library functions in <math.h> raise the ''inexact'' floating-point
+<li> Whether or when library functions in <a href="#7.12"><math.h></a> raise the ''inexact'' floating-point
exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
-<li> Whether or when library functions in <math.h> raise an undeserved ''underflow''
+<li> Whether or when library functions in <a href="#7.12"><math.h></a> raise an undeserved ''underflow''
floating-point exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
<li> The exponent value stored by frexp for a NaN or infinity (<a href="#F.10.3.4">F.10.3.4</a>).
<li> The numeric result returned by the lrint, llrint, lround, and llround
<p><!--para 1-->
<ul>
<li> The accuracy of the floating-point operations and of the library functions in
-
<math.h> and <complex.h> that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+
<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>).
<li> The accuracy of the conversions between floating-point internal representations and
- string representations performed by the library functions in <stdio.h>,
-
<stdlib.h>, and <wchar.h> (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+ string representations performed by the library functions in <a href="#7.21"><stdio.h></a>,
+
<a href="#7.22"><stdlib.h></a>, and <a href="#7.28"><wchar.h></a> (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
<li> The rounding behaviors characterized by non-standard values of FLT_ROUNDS
(<a href="#5.2.4.2.2">5.2.4.2.2</a>).
<li> The evaluation methods characterized by non-standard negative values of
<li> The era for the clock function (<a href="#7.26.2.1">7.26.2.1</a>).
<li> The replacement string for the %Z specifier to the strftime, and wcsftime
functions in the "C" locale (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
-<li> Whether the functions in <math.h> honor the rounding direction mode in an
+<li> Whether the functions in <a href="#7.12"><math.h></a> honor the rounding direction mode in an
IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.10">F.10</a>).
<!--page 592 indent 4-->
</ul>
<p><!--para 1-->
<ul>
<li> The values or expressions assigned to the macros specified in the headers
-
<float.h>, <limits.h>, and <stdint.h> (<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>).
+
<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>).
<li> The result of attempting to indirectly access an object with automatic or thread
storage duration from a thread other than the one with which it is associated (<a href="#6.2.4">6.2.4</a>).
<li> The number, order, and encoding of bytes in any object (when not explicitly specified
<a name="J.5.17" href="#J.5.17"><h4>J.5.17 Math error reporting</h4></a>
<p><!--para 1-->
- Functions declared in <complex.h> and <math.h> raise SIGFPE to report errors
+ Functions declared in <a href="#7.3"><complex.h></a> and <a href="#7.12"><math.h></a> raise SIGFPE to report errors
instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
<a href="#7.12">7.12</a>).
<!--page 596 indent 4-->
subclauses of clause 7.
<h6>footnotes</h6>
-<p><a name="note367">367)</a> Implementations that do not define __STDC_LIB_EXT1__ are not required to conform to these
+<p><small><a name="note367" href="#note367">367)</a> Implementations that do not define __STDC_LIB_EXT1__ are not required to conform to these
specifications.
-
+</small>
<a name="K.3" href="#K.3"><h3>K.3 Library</h3></a>
<!--page 598 indent 4-->
<h6>footnotes</h6>
-<p><a name="note368">368)</a> Future revisions of this International Standard may define meanings for other values of
+<p><small><a name="note368" href="#note368">368)</a> Future revisions of this International Standard may define meanings for other values of
__STDC_WANT_LIB_EXT1__.
-
-<p><
a name="note369">369)</a> Subclause <a href="#7.1.3">7.1.3</a> reserves certain names and patterns of names that an implementation may use in
+</small>
+<p><
small><a name="note369" href="#note369">369)</a> Subclause <a href="#7.1.3">7.1.3</a> reserves certain names and patterns of names that an implementation may use in
headers. All other names are not reserved, and a conforming implementation is not permitted to use
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
unreserved name is defined in a header when __STDC_WANT_LIB_EXT1__ is defined as 0, the
implementation is not conforming.
-
+</small>
<a name="K.3.1.2" href="#K.3.1.2"><h5>K.3.1.2 Reserved identifiers</h5></a>
<p><!--para 1-->
Implementations shall verify that the runtime-constraints for a function are not violated
by the program. If a runtime-constraint is violated, the implementation shall call the
currently registered runtime-constraint handler (see set_constraint_handler_s
- in <stdlib.h>). Multiple runtime-constraint violations in the same call to a library
+ in <a href="#7.22"><stdlib.h></a>). Multiple runtime-constraint violations in the same call to a library
function result in only one call to the runtime-constraint handler. It is unspecified which
one of the multiple runtime-constraint violations cause the handler to be called.
<p><!--para 3-->
<!--page 599 indent 4-->
<h6>footnotes</h6>
-<p><a name="note370">370)</a> Although runtime-constraints replace many cases of undefined behavior, undefined behavior still
+<p><small><a name="note370" href="#note370">370)</a> Although runtime-constraints replace many cases of undefined behavior, undefined behavior still
exists in this annex. Implementations are free to detect any case of undefined behavior and treat it as a
runtime-constraint violation by calling the runtime-constraint handler. This license comes directly
from the definition of undefined behavior.
-
+</small>
<a name="K.3.2" href="#K.3.2"><h4>K.3.2 Errors <errno.h></h4></a>
<p><!--para 1-->
- The header <errno.h> defines a type.
+ The header <a href="#7.5"><errno.h></a> defines a type.
<p><!--para 2-->
The type is
<pre>
which is type int.<sup><a href="#note371"><b>371)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note371">371)</a> As a matter of programming style, errno_t may be used as the type of something that deals only
+<p><small><a name="note371" href="#note371">371)</a> As a matter of programming style, errno_t may be used as the type of something that deals only
with the values that might be found in errno. For example, a function which returns the value of
errno might be declared as having the return type errno_t.
-
+</small>
<a name="K.3.3" href="#K.3.3"><h4>K.3.3 Common definitions <stddef.h></h4></a>
<p><!--para 1-->
- The header <stddef.h> defines a type.
+ The header <a href="#7.19"><stddef.h></a> defines a type.
<p><!--para 2-->
The type is
<pre>
which is the type size_t.<sup><a href="#note372"><b>372)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note372">372)</a> See the description of the RSIZE_MAX macro in <stdint.h>.
-
+<p><small><a name="note372" href="#note372">372)</a> See the description of the RSIZE_MAX macro in <a href="#7.20"><stdint.h></a>.
+</small>
<a name="K.3.4" href="#K.3.4"><h4>K.3.4 Integer types <stdint.h></h4></a>
<p><!--para 1-->
- The header <stdint.h> defines a macro.
+ The header <a href="#7.20"><stdint.h></a> defines a macro.
<p><!--para 2-->
The macro is
<pre>
is no object size that is considered a runtime-constraint violation.
<h6>footnotes</h6>
-<p><a name="note373">373)</a> The macro RSIZE_MAX need not expand to a constant expression.
-
+<p><small><a name="note373" href="#note373">373)</a> The macro RSIZE_MAX need not expand to a constant expression.
+</small>
<a name="K.3.5" href="#K.3.5"><h4>K.3.5 Input/output <stdio.h></h4></a>
<p><!--para 1-->
- The header <stdio.h> defines several macros and two types.
+ The header <a href="#7.21"><stdio.h></a> defines several macros and two types.
<p><!--para 2-->
The macros are
<pre>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
errno_t tmpfile_s(FILE * restrict * restrict streamptr);</pre>
Runtime-constraints
<p><!--para 2-->
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
errno_t tmpnam_s(char *s, rsize_t maxsize);</pre>
Runtime-constraints
<p><!--para 2-->
The value of the macro TMP_MAX_S shall be at least 25.
<h6>footnotes</h6>
-<p><a name="note374">374)</a> Files created using strings generated by the tmpnam_s function are temporary only in the sense that
+<p><small><a name="note374" href="#note374">374)</a> Files created using strings generated by the tmpnam_s function are temporary only in the sense that
their names should not collide with those generated by conventional naming rules for the
implementation. It is still necessary to use the remove function to remove such files when their use
is ended, and before program termination. Implementations should take care in choosing the patterns
used for names returned by tmpnam_s. For example, making a thread id part of the names avoids the
race condition and possible conflict when multiple programs run simultaneously by the same user
generate the same temporary file names.
-
-<p><a name="note375">375)</a> An implementation may have tmpnam call tmpnam_s (perhaps so there is only one naming
+</small>
+<p><small><a name="note375" href="#note375">375)</a> An implementation may have tmpnam call tmpnam_s (perhaps so there is only one naming
convention for temporary files), but this is not required.
-
+</small>
<a name="K.3.5.2" href="#K.3.5.2"><h5>K.3.5.2 File access functions</h5></a>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
errno_t fopen_s(FILE * restrict * restrict streamptr,
const char * restrict filename,
const char * restrict mode);</pre>
there was a runtime-constraint violation, fopen_s returns a nonzero value.
<h6>footnotes</h6>
-<p><a name="note376">376)</a> These are the same permissions that the file would have been created with by fopen.
-
+<p><small><a name="note376" href="#note376">376)</a> These are the same permissions that the file would have been created with by fopen.
+</small>
<a name="K.3.5.2.2" href="#K.3.5.2.2"><h5>K.3.5.2.2 The freopen_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
errno_t freopen_s(FILE * restrict * restrict newstreamptr,
const char * restrict filename,
const char * restrict mode,
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fprintf_s(FILE * restrict stream,
const char * restrict format, ...);</pre>
Runtime-constraints
<!--page 606 indent 4-->
<h6>footnotes</h6>
-<p><a name="note377">377)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note377" href="#note377">377)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
-<p><a name="note378">378)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
+</small>
+<p><small><a name="note378" href="#note378">378)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
constraint violation.
-
+</small>
<a name="K.3.5.3.2" href="#K.3.5.3.2"><h5>K.3.5.3.2 The fscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int fscanf_s(FILE * restrict stream,
const char * restrict format, ...);</pre>
Runtime-constraints
EXAMPLE 1 The call:
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
int n, i; float x; char name[50];
n = fscanf_s(stdin, "%d%f%s", &i, &x, name, (rsize_t) 50);</pre>
EXAMPLE 2 The call:
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
/* ... */
int n; char s[5];
n = fscanf_s(stdin, "%s", s, sizeof s);</pre>
<h6>footnotes</h6>
-<p><a name="note379">379)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
+<p><small><a name="note379" href="#note379">379)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
constraint violation.
-
-<p><a name="note380">380)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
+</small>
+<p><small><a name="note380" href="#note380">380)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
the format is not known at translation time. For example, an implementation may issue a diagnostic
using the hh length modifier, a length argument must follow the pointer argument. Another useful
diagnostic could flag any non-pointer argument following format that did not have a type
compatible with rsize_t.
-
+</small>
<a name="K.3.5.3.3" href="#K.3.5.3.3"><h5>K.3.5.3.3 The printf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int printf_s(const char * restrict format, ...);</pre>
Runtime-constraints
<p><!--para 2-->
value if an output error, encoding error, or runtime-constraint violation occurred.
<h6>footnotes</h6>
-<p><a name="note381">381)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note381" href="#note381">381)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
+</small>
<a name="K.3.5.3.4" href="#K.3.5.3.4"><h5>K.3.5.3.4 The scanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int scanf_s(const char * restrict format, ...);</pre>
Runtime-constraints
<p><!--para 2-->
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int snprintf_s(char * restrict s, rsize_t n,
const char * restrict format, ...);</pre>
Runtime-constraints
less than n.
<h6>footnotes</h6>
-<p><a name="note382">382)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note382" href="#note382">382)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
+</small>
<a name="K.3.5.3.6" href="#K.3.5.3.6"><h5>K.3.5.3.6 The sprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int sprintf_s(char * restrict s, rsize_t n,
const char * restrict format, ...);</pre>
Runtime-constraints
constraint violation occurred, sprintf_s returns zero.
<h6>footnotes</h6>
-<p><a name="note383">383)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note383" href="#note383">383)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
+</small>
<a name="K.3.5.3.7" href="#K.3.5.3.7"><h5>K.3.5.3.7 The sscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
int sscanf_s(const char * restrict s,
const char * restrict format, ...);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vfprintf_s(FILE * restrict stream,
const char * restrict format,
va_list arg);</pre>
value if an output error, encoding error, or runtime-constraint violation occurred.
<h6>footnotes</h6>
-<p><a name="note384">384)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note384" href="#note384">384)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
+</small>
<a name="K.3.5.3.9" href="#K.3.5.3.9"><h5>K.3.5.3.9 The vfscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vfscanf_s(FILE * restrict stream,
const char * restrict format,
va_list arg);</pre>
than provided for, or even zero, in the event of an early matching failure.
<h6>footnotes</h6>
-<p><a name="note385">385)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+<p><small><a name="note385" href="#note385">385)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
indeterminate.
-
+</small>
<a name="K.3.5.3.10" href="#K.3.5.3.10"><h5>K.3.5.3.10 The vprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vprintf_s(const char * restrict format,
va_list arg);</pre>
Runtime-constraints
value if an output error, encoding error, or runtime-constraint violation occurred.
<h6>footnotes</h6>
-<p><a name="note386">386)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note386" href="#note386">386)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
+</small>
<a name="K.3.5.3.11" href="#K.3.5.3.11"><h5>K.3.5.3.11 The vscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vscanf_s(const char * restrict format,
va_list arg);</pre>
Runtime-constraints
<!--page 614 indent 4-->
<h6>footnotes</h6>
-<p><a name="note387">387)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+<p><small><a name="note387" href="#note387">387)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
indeterminate.
-
+</small>
<a name="K.3.5.3.12" href="#K.3.5.3.12"><h5>K.3.5.3.12 The vsnprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vsnprintf_s(char * restrict s, rsize_t n,
const char * restrict format,
va_list arg);</pre>
<!--page 615 indent 4-->
<h6>footnotes</h6>
-<p><a name="note388">388)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note388" href="#note388">388)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
+</small>
<a name="K.3.5.3.13" href="#K.3.5.3.13"><h5>K.3.5.3.13 The vsprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vsprintf_s(char * restrict s, rsize_t n,
const char * restrict format,
va_list arg);</pre>
<!--page 616 indent 4-->
<h6>footnotes</h6>
-<p><a name="note389">389)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+<p><small><a name="note389" href="#note389">389)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
format string was %%n.
-
+</small>
<a name="K.3.5.3.14" href="#K.3.5.3.14"><h5>K.3.5.3.14 The vsscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
int vsscanf_s(const char * restrict s,
const char * restrict format,
va_list arg);</pre>
provided for, or even zero, in the event of an early matching failure.
<h6>footnotes</h6>
-<p><a name="note390">390)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+<p><small><a name="note390" href="#note390">390)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
indeterminate.
-
+</small>
<a name="K.3.5.4" href="#K.3.5.4"><h5>K.3.5.4 Character input/output functions</h5></a>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
+ #include <a href="#7.21"><stdio.h></a>
char *gets_s(char *s, rsize_t n);</pre>
<!--page 618 indent 4-->
<h6>footnotes</h6>
-<p><a name="note391">391)</a> The gets_s function, unlike the historical gets function, makes it a runtime-constraint violation for
+<p><small><a name="note391" href="#note391">391)</a> The gets_s function, unlike the historical gets function, makes it a runtime-constraint violation for
a line of input to overflow the buffer to store it. Unlike the fgets function, gets_s maintains a
one-to-one relationship between input lines and successful calls to gets_s. Programs that use gets
expect such a relationship.
-
+</small>
<a name="K.3.6" href="#K.3.6"><h4>K.3.6 General utilities <stdlib.h></h4></a>
<p><!--para 1-->
- The header <stdlib.h> defines three types.
+ The header <a href="#7.22"><stdlib.h></a> defines three types.
<p><!--para 2-->
The types are
<pre>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
constraint_handler_t set_constraint_handler_s(
constraint_handler_t handler);</pre>
<h6>Description</h6>
registered handler.<sup><a href="#note392"><b>392)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note392">392)</a> If the previous handler was registered by calling set_constraint_handler_s with a null
+<p><small><a name="note392" href="#note392">392)</a> If the previous handler was registered by calling set_constraint_handler_s with a null
pointer argument, a pointer to the implementation default handler is returned (not NULL).
-
+</small>
<a name="K.3.6.1.2" href="#K.3.6.1.2"><h5>K.3.6.1.2 The abort_handler_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void abort_handler_s(
const char * restrict msg,
void * restrict ptr,
<!--page 620 indent 4-->
<h6>footnotes</h6>
-<p><a name="note393">393)</a> Many implementations invoke a debugger when the abort function is called.
-
+<p><small><a name="note393" href="#note393">393)</a> Many implementations invoke a debugger when the abort function is called.
+</small>
<a name="K.3.6.1.3" href="#K.3.6.1.3"><h5>K.3.6.1.3 The ignore_handler_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void ignore_handler_s(
const char * restrict msg,
void * restrict ptr,
The ignore_handler_s function returns no value.
<h6>footnotes</h6>
-<p><a name="note394">394)</a> If the runtime-constraint handler is set to the ignore_handler_s function, any library function in
+<p><small><a name="note394" href="#note394">394)</a> If the runtime-constraint handler is set to the ignore_handler_s function, any library function in
which a runtime-constraint violation occurs will return to its caller. The caller can determine whether
a runtime-constraint violation occurred based on the library function's specification (usually, the
library function returns a nonzero errno_t).
-
+</small>
<a name="K.3.6.2" href="#K.3.6.2"><h5>K.3.6.2 Communication with the environment</h5></a>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
errno_t getenv_s(size_t * restrict len,
char * restrict value, rsize_t maxsize,
const char * restrict name);</pre>
movement of the objects passed as arguments to that call.
<h6>footnotes</h6>
-<p><a name="note395">395)</a> That is, if the value passed is p, then the following expressions are always valid and nonzero:
+<p><small><a name="note395" href="#note395">395)</a> That is, if the value passed is p, then the following expressions are always valid and nonzero:
<pre>
((char *)p - (char *)base) % size == 0
(char *)p >= (char *)base
(char *)p < (char *)base + nmemb * size</pre>
-
+</small>
<a name="K.3.6.3.1" href="#K.3.6.3.1"><h5>K.3.6.3.1 The bsearch_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
void *bsearch_s(const void *key, const void *base,
rsize_t nmemb, rsize_t size,
int (*compar)(const void *k, const void *y,
compare as equal, which element is matched is unspecified.
<h6>footnotes</h6>
-<p><a name="note396">396)</a> In practice, this means that the entire array has been sorted according to the comparison function.
-
-<p><a name="note397">397)</a> The context argument is for the use of the comparison function in performing its duties. For
+<p><small><a name="note396" href="#note396">396)</a> In practice, this means that the entire array has been sorted according to the comparison function.
+</small>
+<p><small><a name="note397" href="#note397">397)</a> The context argument is for the use of the comparison function in performing its duties. For
example, it might specify a collating sequence used by the comparison function.
-
+</small>
<a name="K.3.6.3.2" href="#K.3.6.3.2"><h5>K.3.6.3.2 The qsort_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
int (*compar)(const void *x, const void *y,
void *context),
<!--page 624 indent 4-->
<h6>footnotes</h6>
-<p><a name="note398">398)</a> The context argument is for the use of the comparison function in performing its duties. For
+<p><small><a name="note398" href="#note398">398)</a> The context argument is for the use of the comparison function in performing its duties. For
example, it might specify a collating sequence used by the comparison function.
-
+</small>
<a name="K.3.6.4" href="#K.3.6.4"><h5>K.3.6.4 Multibyte/wide character conversion functions</h5></a>
<p><!--para 1-->
category causes the conversion state of these functions to be indeterminate.
<h6>footnotes</h6>
-<p><a name="note399">399)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+<p><small><a name="note399" href="#note399">399)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
character codes, but are grouped with an adjacent multibyte character.
-
+</small>
<a name="K.3.6.4.1" href="#K.3.6.4.1"><h5>K.3.6.4.1 The wctomb_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
errno_t wctomb_s(int * restrict status,
char * restrict s,
rsize_t smax,
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
errno_t mbstowcs_s(size_t * restrict retval,
wchar_t * restrict dst, rsize_t dstmax,
const char * restrict src, rsize_t len);</pre>
encoding error occurred. Otherwise, a nonzero value is returned.
<h6>footnotes</h6>
-<p><a name="note400">400)</a> Thus, the value of len is ignored if dst is a null pointer.
-
-<p><a name="note401">401)</a> This allows an implementation to attempt converting the multibyte string before discovering a
+<p><small><a name="note400" href="#note400">400)</a> Thus, the value of len is ignored if dst is a null pointer.
+</small>
+<p><small><a name="note401" href="#note401">401)</a> This allows an implementation to attempt converting the multibyte string before discovering a
terminating null character did not occur where required.
-
+</small>
<a name="K.3.6.5.2" href="#K.3.6.5.2"><h5>K.3.6.5.2 The wcstombs_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
- #include <stdlib.h>
+ #include <a href="#7.22"><stdlib.h></a>
errno_t wcstombs_s(size_t * restrict retval,
char * restrict dst, rsize_t dstmax,
const wchar_t * restrict src, rsize_t len);</pre>
encoding error occurred. Otherwise, a nonzero value is returned.
<h6>footnotes</h6>
-<p><a name="note402">402)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
+<p><small><a name="note402" href="#note402">402)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
include those necessary to reach the initial shift state immediately before the null byte. However, if
the conversion stops before a terminating null wide character has been reached, the result will be null
terminated, but might not end in the initial shift state.
-
-<p><a name="note403">403)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
+</small>
+<p><small><a name="note403" href="#note403">403)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
runtime-constraint violation.
-
+</small>
<a name="K.3.7" href="#K.3.7"><h4>K.3.7 String handling <string.h></h4></a>
<p><!--para 1-->
- The header <string.h> defines two types.
+ The header <a href="#7.23"><string.h></a> defines two types.
<p><!--para 2-->
The types are
<pre>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t memcpy_s(void * restrict s1, rsize_t s1max,
const void * restrict s2, rsize_t n);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t memmove_s(void *s1, rsize_t s1max,
const void *s2, rsize_t n);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t strcpy_s(char * restrict s1,
rsize_t s1max,
const char * restrict s2);</pre>
Otherwise, a nonzero value is returned.
<h6>footnotes</h6>
-<p><a name="note404">404)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
+<p><small><a name="note404" href="#note404">404)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
any of those characters are null. Such an approach might write a character to every element of s1
before discovering that the first element should be set to the null character.
-
-<p><a name="note405">405)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
+</small>
+<p><small><a name="note405" href="#note405">405)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
within the array pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.7.1.4" href="#K.3.7.1.4"><h5>K.3.7.1.4 The strncpy_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t strncpy_s(char * restrict s1,
rsize_t s1max,
const char * restrict s2,
will not be null terminated or that characters will be written past the end of the destination array.
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
/* ... */
char src1[100] = "hello";
char src2[7] = {'g', 'o', 'o', 'd', 'b', 'y', 'e'};
<h6>footnotes</h6>
-<p><a name="note406">406)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
+<p><small><a name="note406" href="#note406">406)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
any of those characters are null. Such an approach might write a character to every element of s1
before discovering that the first element should be set to the null character.
-
-<p><a name="note407">407)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
+</small>
+<p><small><a name="note407" href="#note407">407)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
within the array pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.7.2" href="#K.3.7.2"><h5>K.3.7.2 Concatenation functions</h5></a>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t strcat_s(char * restrict s1,
rsize_t s1max,
const char * restrict s2);</pre>
Otherwise, a nonzero value is returned.
<h6>footnotes</h6>
-<p><a name="note408">408)</a> Zero means that s1 was not null terminated upon entry to strcat_s.
-
-<p><a name="note409">409)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
+<p><small><a name="note408" href="#note408">408)</a> Zero means that s1 was not null terminated upon entry to strcat_s.
+</small>
+<p><small><a name="note409" href="#note409">409)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
any of those characters are null. Such an approach might write a character to every element of s1
before discovering that the first element should be set to the null character.
-
-<p><a name="note410">410)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
+</small>
+<p><small><a name="note410" href="#note410">410)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
appended to the string pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.7.2.2" href="#K.3.7.2.2"><h5>K.3.7.2.2 The strncat_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t strncat_s(char * restrict s1,
rsize_t s1max,
const char * restrict s2,
will not be null terminated or that characters will be written past the end of the destination array.
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
/* ... */
char s1[100] = "good";
char s2[6] = "hello";
<h6>footnotes</h6>
-<p><a name="note411">411)</a> Zero means that s1 was not null terminated upon entry to strncat_s.
-
-<p><a name="note412">412)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
+<p><small><a name="note411" href="#note411">411)</a> Zero means that s1 was not null terminated upon entry to strncat_s.
+</small>
+<p><small><a name="note412" href="#note412">412)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
any of those characters are null. Such an approach might write a character to every element of s1
before discovering that the first element should be set to the null character.
-
-<p><a name="note413">413)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
+</small>
+<p><small><a name="note413" href="#note413">413)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
appended to the string pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.7.3" href="#K.3.7.3"><h5>K.3.7.3 Search functions</h5></a>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
char *strtok_s(char * restrict s1,
rsize_t * restrict s1max,
const char * restrict s2,
EXAMPLE
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
static char str1[] = "?a???b,,,#c";
static char str2[] = "\t \t";
char *t, *ptr1, *ptr2;
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)</pre>
Runtime-constraints
<p><!--para 2-->
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
errno_t strerror_s(char *s, rsize_t maxsize,
errno_t errnum);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
size_t strerrorlen_s(errno_t errnum);</pre>
<h6>Description</h6>
<p><!--para 2-->
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <string.h>
+ #include <a href="#7.23"><string.h></a>
size_t strnlen_s(const char *s, size_t maxsize);</pre>
<h6>Description</h6>
<p><!--para 2-->
<!--page 638 indent 4-->
<h6>footnotes</h6>
-<p><a name="note414">414)</a> Note that the strnlen_s function has no runtime-constraints. This lack of runtime-constraints
+<p><small><a name="note414" href="#note414">414)</a> Note that the strnlen_s function has no runtime-constraints. This lack of runtime-constraints
along with the values returned for a null pointer or an unterminated string argument make
strnlen_s useful in algorithms that gracefully handle such exceptional data.
-
+</small>
<a name="K.3.8" href="#K.3.8"><h4>K.3.8 Date and time <time.h></h4></a>
<p><!--para 1-->
- The header <time.h> defines two types.
+ The header <a href="#7.26"><time.h></a> defines two types.
<p><!--para 2-->
The types are
<pre>
their normal rages.<sup><a href="#note415"><b>415)</b></a></sup>
<h6>footnotes</h6>
-<p><
a name="note415">415)</a> The normal ranges are defined in <a href="#7.26.1">7.26.1</a>.
-
+<p><
small><a name="note415" href="#note415">415)</a> The normal ranges are defined in <a href="#7.26.1">7.26.1</a>.
+</small>
<a name="K.3.8.2" href="#K.3.8.2"><h5>K.3.8.2 Time conversion functions</h5></a>
<p><!--para 1-->
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
errno_t asctime_s(char *s, rsize_t maxsize,
const struct tm *timeptr);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
errno_t ctime_s(char *s, rsize_t maxsize,
const time_t *timer);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
struct tm *gmtime_s(const time_t * restrict timer,
struct tm * restrict result);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <time.h>
+ #include <a href="#7.26"><time.h></a>
struct tm *localtime_s(const time_t * restrict timer,
struct tm * restrict result);</pre>
Runtime-constraints
<a name="K.3.9" href="#K.3.9"><h4>K.3.9 Extended multibyte and wide character utilities <wchar.h></h4></a>
<p><!--para 1-->
- The header <wchar.h> defines two types.
+ The header <a href="#7.28"><wchar.h></a> defines two types.
<p><!--para 2-->
The types are
<pre>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int fwprintf_s(FILE * restrict stream,
const wchar_t * restrict format, ...);</pre>
Runtime-constraints
negative value if an output error, encoding error, or runtime-constraint violation occurred.
<h6>footnotes</h6>
-<p><a name="note416">416)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note416" href="#note416">416)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.2" href="#K.3.9.1.2"><h5>K.3.9.1.2 The fwscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int fwscanf_s(FILE * restrict stream,
const wchar_t * restrict format, ...);</pre>
Runtime-constraints
than provided for, or even zero, in the event of an early matching failure.
<h6>footnotes</h6>
-<p><a name="note417">417)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
+<p><small><a name="note417" href="#note417">417)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
the format is not known at translation time. For example, an implementation may issue a diagnostic
using the hh length modifier, a length argument must follow the pointer argument. Another useful
diagnostic could flag any non-pointer argument following format that did not have a type
compatible with rsize_t.
-
+</small>
<a name="K.3.9.1.3" href="#K.3.9.1.3"><h5>K.3.9.1.3 The snwprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int snwprintf_s(wchar_t * restrict s,
rsize_t n,
const wchar_t * restrict format, ...);</pre>
nonnegative and less than n.
<h6>footnotes</h6>
-<p><a name="note418">418)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note418" href="#note418">418)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.4" href="#K.3.9.1.4"><h5>K.3.9.1.4 The swprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int swprintf_s(wchar_t * restrict s, rsize_t n,
const wchar_t * restrict format, ...);</pre>
Runtime-constraints
violation occurred, swprintf_s returns zero.
<h6>footnotes</h6>
-<p><a name="note419">419)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note419" href="#note419">419)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.5" href="#K.3.9.1.5"><h5>K.3.9.1.5 The swscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int swscanf_s(const wchar_t * restrict s,
const wchar_t * restrict format, ...);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vfwprintf_s(FILE * restrict stream,
const wchar_t * restrict format,
va_list arg);</pre>
negative value if an output error, encoding error, or runtime-constraint violation occurred.
<h6>footnotes</h6>
-<p><a name="note420">420)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note420" href="#note420">420)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.7" href="#K.3.9.1.7"><h5>K.3.9.1.7 The vfwscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <stdio.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.21"><stdio.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vfwscanf_s(FILE * restrict stream,
const wchar_t * restrict format, va_list arg);</pre>
than provided for, or even zero, in the event of an early matching failure.
<h6>footnotes</h6>
-<p><a name="note421">421)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+<p><small><a name="note421" href="#note421">421)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
value of arg after the return is indeterminate.
-
+</small>
<a name="K.3.9.1.8" href="#K.3.9.1.8"><h5>K.3.9.1.8 The vsnwprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vsnwprintf_s(wchar_t * restrict s,
rsize_t n,
const wchar_t * restrict format,
less than n.
<h6>footnotes</h6>
-<p><a name="note422">422)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note422" href="#note422">422)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.9" href="#K.3.9.1.9"><h5>K.3.9.1.9 The vswprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vswprintf_s(wchar_t * restrict s,
rsize_t n,
const wchar_t * restrict format,
violation occurred, vswprintf_s returns zero.
<h6>footnotes</h6>
-<p><a name="note423">423)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note423" href="#note423">423)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.10" href="#K.3.9.1.10"><h5>K.3.9.1.10 The vswscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vswscanf_s(const wchar_t * restrict s,
const wchar_t * restrict format,
va_list arg);</pre>
than provided for, or even zero, in the event of an early matching failure.
<h6>footnotes</h6>
-<p><a name="note424">424)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+<p><small><a name="note424" href="#note424">424)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
value of arg after the return is indeterminate.
-
+</small>
<a name="K.3.9.1.11" href="#K.3.9.1.11"><h5>K.3.9.1.11 The vwprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vwprintf_s(const wchar_t * restrict format,
va_list arg);</pre>
Runtime-constraints
<!--page 651 indent 4-->
<h6>footnotes</h6>
-<p><a name="note425">425)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note425" href="#note425">425)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.12" href="#K.3.9.1.12"><h5>K.3.9.1.12 The vwscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <stdarg.h>
- #include <wchar.h>
+ #include <a href="#7.16"><stdarg.h></a>
+ #include <a href="#7.28"><wchar.h></a>
int vwscanf_s(const wchar_t * restrict format,
va_list arg);</pre>
Runtime-constraints
than provided for, or even zero, in the event of an early matching failure.
<h6>footnotes</h6>
-<p><a name="note426">426)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+<p><small><a name="note426" href="#note426">426)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
value of arg after the return is indeterminate.
-
+</small>
<a name="K.3.9.1.13" href="#K.3.9.1.13"><h5>K.3.9.1.13 The wprintf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wprintf_s(const wchar_t * restrict format, ...);</pre>
Runtime-constraints
<p><!--para 2-->
negative value if an output error, encoding error, or runtime-constraint violation occurred.
<h6>footnotes</h6>
-<p><a name="note427">427)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+<p><small><a name="note427" href="#note427">427)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
example, if the entire format string was L"%%n".
-
+</small>
<a name="K.3.9.1.14" href="#K.3.9.1.14"><h5>K.3.9.1.14 The wscanf_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
int wscanf_s(const wchar_t * restrict format, ...);</pre>
Runtime-constraints
<p><!--para 2-->
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wcscpy_s(wchar_t * restrict s1,
rsize_t s1max,
const wchar_t * restrict s2);</pre>
<!--page 654 indent 5-->
<h6>footnotes</h6>
-<p><a name="note428">428)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
+<p><small><a name="note428" href="#note428">428)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
if any of those wide characters are null. Such an approach might write a wide character to every
element of s1 before discovering that the first element should be set to the null wide character.
-
-<p><a name="note429">429)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
+</small>
+<p><small><a name="note429" href="#note429">429)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
fit within the array pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.9.2.1.2" href="#K.3.9.2.1.2"><h5>K.3.9.2.1.2 The wcsncpy_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 7-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wcsncpy_s(wchar_t * restrict s1,
rsize_t s1max,
const wchar_t * restrict s2,
<!--page 655 indent 5-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
/* ... */
wchar_t src1[100] = L"hello";
wchar_t src2[7] = {L'g', L'o', L'o', L'd', L'b', L'y', L'e'};
<h6>footnotes</h6>
-<p><a name="note430">430)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
+<p><small><a name="note430" href="#note430">430)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
if any of those wide characters are null. Such an approach might write a wide character to every
element of s1 before discovering that the first element should be set to the null wide character.
-
-<p><a name="note431">431)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
+</small>
+<p><small><a name="note431" href="#note431">431)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
fit within the array pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.9.2.1.3" href="#K.3.9.2.1.3"><h5>K.3.9.2.1.3 The wmemcpy_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 14-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wmemcpy_s(wchar_t * restrict s1,
rsize_t s1max,
const wchar_t * restrict s2,
<p><!--para 19-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
const wchar_t *s2, rsize_t n);</pre>
Runtime-constraints
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wcscat_s(wchar_t * restrict s1,
rsize_t s1max,
const wchar_t * restrict s2);</pre>
Otherwise, a nonzero value is returned.
<h6>footnotes</h6>
-<p><a name="note432">432)</a> Zero means that s1 was not null terminated upon entry to wcscat_s.
-
-<p><a name="note433">433)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
+<p><small><a name="note432" href="#note432">432)</a> Zero means that s1 was not null terminated upon entry to wcscat_s.
+</small>
+<p><small><a name="note433" href="#note433">433)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
checking if any of those wide characters are null. Such an approach might write a wide character to
every element of s1 before discovering that the first element should be set to the null wide character.
-
-<p><a name="note434">434)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
+</small>
+<p><small><a name="note434" href="#note434">434)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.9.2.2.2" href="#K.3.9.2.2.2"><h5>K.3.9.2.2.2 The wcsncat_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 8-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wcsncat_s(wchar_t * restrict s1,
rsize_t s1max,
const wchar_t * restrict s2,
array.
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
/* ... */
wchar_t s1[100] = L"good";
wchar_t s2[6] = L"hello";
<!--page 659 indent 4-->
<h6>footnotes</h6>
-<p><a name="note435">435)</a> Zero means that s1 was not null terminated upon entry to wcsncat_s.
-
-<p><a name="note436">436)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
+<p><small><a name="note435" href="#note435">435)</a> Zero means that s1 was not null terminated upon entry to wcsncat_s.
+</small>
+<p><small><a name="note436" href="#note436">436)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
checking if any of those wide characters are null. Such an approach might write a wide character to
every element of s1 before discovering that the first element should be set to the null wide character.
-
-<p><a name="note437">437)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
+</small>
+<p><small><a name="note437" href="#note437">437)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
-
+</small>
<a name="K.3.9.2.3" href="#K.3.9.2.3"><h5>K.3.9.2.3 Wide string search functions</h5></a>
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
wchar_t *wcstok_s(wchar_t * restrict s1,
rsize_t * restrict s1max,
const wchar_t * restrict s2,
EXAMPLE
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
static wchar_t str1[] = L"?a???b,,,#c";
static wchar_t str2[] = L"\t \t";
wchar_t *t, *ptr1, *ptr2;
<p><!--para 1-->
<pre>
#define __STDC_WANT_LIB_EXT1__ 1
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
size_t wcsnlen_s(const wchar_t *s, size_t maxsize);</pre>
<h6>Description</h6>
<p><!--para 2-->
maxsize wide characters of s shall be accessed by wcsnlen_s.
<h6>footnotes</h6>
-<p><a name="note438">438)</a> Note that the wcsnlen_s function has no runtime-constraints. This lack of runtime-constraints
+<p><small><a name="note438" href="#note438">438)</a> Note that the wcsnlen_s function has no runtime-constraints. This lack of runtime-constraints
along with the values returned for a null pointer or an unterminated wide string argument make
wcsnlen_s useful in algorithms that gracefully handle such exceptional data.
-
+</small>
<a name="K.3.9.3" href="#K.3.9.3"><h5>K.3.9.3 Extended multibyte/wide character conversion utilities</h5></a>
<h6>Synopsis</h6>
<p><!--para 2-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wcrtomb_s(size_t * restrict retval,
char * restrict s, rsize_t smax,
wchar_t wc, mbstate_t * restrict ps);</pre>
<h6>Synopsis</h6>
<p><!--para 2-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t mbsrtowcs_s(size_t * restrict retval,
wchar_t * restrict dst, rsize_t dstmax,
const char ** restrict src, rsize_t len,
encoding error occurred. Otherwise, a nonzero value is returned.
<h6>footnotes</h6>
-<p><a name="note439">439)</a> Thus, the value of len is ignored if dst is a null pointer.
-
-<p><a name="note440">440)</a> This allows an implementation to attempt converting the multibyte string before discovering a
+<p><small><a name="note439" href="#note439">439)</a> Thus, the value of len is ignored if dst is a null pointer.
+</small>
+<p><small><a name="note440" href="#note440">440)</a> This allows an implementation to attempt converting the multibyte string before discovering a
terminating null character did not occur where required.
-
+</small>
<a name="K.3.9.3.2.2" href="#K.3.9.3.2.2"><h5>K.3.9.3.2.2 The wcsrtombs_s function</h5></a>
<h6>Synopsis</h6>
<p><!--para 11-->
<pre>
- #include <wchar.h>
+ #include <a href="#7.28"><wchar.h></a>
errno_t wcsrtombs_s(size_t * restrict retval,
char * restrict dst, rsize_t dstmax,
const wchar_t ** restrict src, rsize_t len,
<!--page 666 indent 4-->
<h6>footnotes</h6>
-<p><a name="note441">441)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
+<p><small><a name="note441" href="#note441">441)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
include those necessary to reach the initial shift state immediately before the null byte. However, if
the conversion stops before a terminating null wide character has been reached, the result will be null
terminated, but might not end in the initial shift state.
-
-<p><a name="note442">442)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
+</small>
+<p><small><a name="note442" href="#note442">442)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
runtime-constraint violation.
-
+</small>
<a name="L" href="#L"><h2>Annex L</h2></a>
<pre>
specifications in this annex.<sup><a href="#note443"><b>443)</b></a></sup>
<h6>footnotes</h6>
-<p><a name="note443">443)</a> Implementations that do not define __STDC_ANALYZABLE__ are not required to conform to these
+<p><small><a name="note443" href="#note443">443)</a> Implementations that do not define __STDC_ANALYZABLE__ are not required to conform to these
specifications.
-
+</small>
<a name="L.2" href="#L.2"><h3>L.2 Definitions</h3></a>
% (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>
%: (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>
%:%: (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>
- %= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
<assert.h> header, <a href="#7.2">7.2</a>
- %> (alternative spelling of }), <a href="#6.4.6">6.4.6</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>,
+ %= (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>
+ %> (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>,
& (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.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
- & (bitwise AND operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
<ctype.h> header, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>
- && (logical AND operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>
<errno.h> header, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>
- &= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
<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>, <a href="#F">F</a>,
+ & (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.30.2">7.30.2</a>
+ && (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.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>
+ &= (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>, <a href="#F">F</a>,
' ' (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="#H">H</a>
- <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.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>,
+ <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.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>,
( ) (cast operator), <a href="#6.5.4">6.5.4</a> <a href="#7.28.4.1.1">7.28.4.1.1</a>
- ( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a>
<inttypes.h> header, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>
- ( ) (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>
<iso646.h> header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
- ( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>
<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>
- * (asterisk punctuator), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a>
<locale.h> header, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>
- * (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
<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.24">7.24</a>, <a href="#F">F</a>,
+ ( ) (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.30.4">7.30.4</a>
+ ( ) (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>
+ ( ){ } (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>
+ * (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.30.5">7.30.5</a>
+ * (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.24">7.24</a>, <a href="#F">F</a>,
* (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>
- <a href="#G.5.1">G.5.1</a>
<setjmp.h> header, <a href="#7.13">7.13</a>
- *= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
<signal.h> header, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>
- + (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>,
<stdalign.h> header, <a href="#4">4</a>, <a href="#7.15">7.15</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>
<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>
- + (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a>
<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>
- ++ (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>
<stdbool.h> header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</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>
<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>,
+ <a href="#G.5.1">G.5.1</a>
<a href="#7.13"><setjmp.h></a> header, <a href="#7.13">7.13</a>
+ *= (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.30.6">7.30.6</a>
+ + (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>
+ <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>
+ + (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>
+ ++ (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.18"><stdbool.h></a> header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</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>
<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>,
+= (addition assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
<!--page 672 indent 0-->
<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> \x hexadecimal digits (hexadecimal-character
-
<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>, escape sequence), <a href="#6.4.4.4">6.4.4.4</a>
+
<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>, escape sequence), <a href="#6.4.4.4">6.4.4.4</a>
<a href="#7.20">7.20</a>, <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</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>
-
<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.30.9">7.30.9</a>, <a href="#F">F</a>, ^= (bitwise exclusive OR assignment operator),
+
<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.30.9">7.30.9</a>, <a href="#F">F</a>, ^= (bitwise exclusive OR assignment operator),
<a href="#K.3.5">K.3.5</a> <a href="#6.5.16.2">6.5.16.2</a>
-
<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.30.10">7.30.10</a>, <a href="#F">F</a>, __alignas_is_defined macro, <a href="#7.15">7.15</a>
+
<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.30.10">7.30.10</a>, <a href="#F">F</a>, __alignas_is_defined macro, <a href="#7.15">7.15</a>
<a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a> __bool_true_false_are_defined
-
<string.h> header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a> macro, <a href="#7.18">7.18</a>
-
<tgmath.h> header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a> __cplusplus macro, <a href="#6.10.8">6.10.8</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.25">7.25</a> __DATE__ macro, <a href="#6.10.8.1">6.10.8.1</a>
-
<time.h> header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</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>
-
<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.27">7.27</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>
-
<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.28">7.28</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>
+
<a href="#7.23"><string.h></a> header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a> macro, <a href="#7.18">7.18</a>
+
<a href="#7.24"><tgmath.h></a> header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a> __cplusplus macro, <a href="#6.10.8">6.10.8</a>
+
<a href="#7.25"><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.25">7.25</a> __DATE__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+
<a href="#7.26"><time.h></a> header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</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>
+
<a href="#7.27"><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.27">7.27</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>
+
<a href="#7.28"><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.28">7.28</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>
<a href="#7.30.12">7.30.12</a>, <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a> __STDC_, <a href="#6.11.9">6.11.9</a>
-
<wctype.h> header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a> __STDC__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+
<a href="#7.29"><wctype.h></a> header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a> __STDC__ macro, <a href="#6.10.8.1">6.10.8.1</a>
= (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_ANALYZABLE__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#L.1">L.1</a>
= (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a> __STDC_HOSTED__ macro, <a href="#6.10.8.1">6.10.8.1</a>
== (equality operator), <a href="#6.5.9">6.5.9</a> __STDC_IEC_559__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#F.1">F.1</a>
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> goto, <a href="#6.8.6.1">6.8.6.1</a>
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> if, <a href="#6.8.4.1">6.8.4.1</a>
standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a> iteration, <a href="#6.8.5">6.8.5</a>
-
<assert.h>, <a href="#7.2">7.2</a> jump, <a href="#6.8.6">6.8.6</a>
-
<complex.h>, <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>, labeled, <a href="#6.8.1">6.8.1</a>
+
<a href="#7.2"><assert.h></a>, <a href="#7.2">7.2</a> jump, <a href="#6.8.6">6.8.6</a>
+
<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>, labeled, <a href="#6.8.1">6.8.1</a>
<a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a> null, <a href="#6.8.3">6.8.3</a>
-
<ctype.h>, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a> return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
-
<errno.h>, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a> selection, <a href="#6.8.4">6.8.4</a>
-
<fenv.h>, <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>, <a href="#F">F</a>, <a href="#H">H</a> sequencing, <a href="#6.8">6.8</a>
-
<float.h>, <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>, switch, <a href="#6.8.4.2">6.8.4.2</a>
+
<a href="#7.4"><ctype.h></a>, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a> return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
+
<a href="#7.5"><errno.h></a>, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a> selection, <a href="#6.8.4">6.8.4</a>
+
<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>, <a href="#F">F</a>, <a href="#H">H</a> sequencing, <a href="#6.8">6.8</a>
+
<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>, switch, <a href="#6.8.4.2">6.8.4.2</a>
<a href="#7.28.4.1.1">7.28.4.1.1</a> while, <a href="#6.8.5.1">6.8.5.1</a>
-
<inttypes.h>, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a> static assertions, <a href="#6.7.10">6.7.10</a>
-
<iso646.h>, <a href="#4">4</a>, <a href="#7.9">7.9</a> static storage duration, <a href="#6.2.4">6.2.4</a>
-
<limits.h>, <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> 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>
-
<locale.h>, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a> 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>
-
<math.h>, <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.24">7.24</a>, <a href="#F">F</a>, <a href="#F.10">F.10</a>, static_assert declaration, <a href="#6.7.10">6.7.10</a>
+
<a href="#7.8"><inttypes.h></a>, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a> static assertions, <a href="#6.7.10">6.7.10</a>
+
<a href="#7.9"><iso646.h></a>, <a href="#4">4</a>, <a href="#7.9">7.9</a> static storage duration, <a href="#6.2.4">6.2.4</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> 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>
+
<a href="#7.11"><locale.h></a>, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a> 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>
+
<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.24">7.24</a>, <a href="#F">F</a>, <a href="#F.10">F.10</a>, static_assert declaration, <a href="#6.7.10">6.7.10</a>
<a href="#J.5.17">J.5.17</a> static_assert macro, <a href="#7.2">7.2</a>
-
<setjmp.h>, <a href="#7.13">7.13</a> stdalign.h header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
-
<signal.h>, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a> 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>
-
<stdalign.h>, <a href="#4">4</a>, <a href="#7.15">7.15</a> 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>
-
<stdarg.h>, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a> stdbool.h header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>
-
<stdatomic.h>, <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> STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>
-
<stdbool.h>, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a> 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>,
-
<stddef.h>, <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>, <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>
+
<a href="#7.13"><setjmp.h></a>, <a href="#7.13">7.13</a> stdalign.h header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
+
<a href="#7.14"><signal.h></a>, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a> 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>
+
<a href="#7.15"><stdalign.h></a>, <a href="#4">4</a>, <a href="#7.15">7.15</a> 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>
+
<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> stdbool.h header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</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> STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>
+
<a href="#7.18"><stdbool.h></a>, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a> 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>,
+
<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>, <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>
<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> 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>
-
<stdint.h>, <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>, 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>,
+
<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>, 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>,
<a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a> <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.28.2.12">7.28.2.12</a>, <a href="#7.28.3.7">7.28.3.7</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
-
<stdio.h>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a> <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>
-
<stdlib.h>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>, 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>,
+
<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.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a> <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>
+
<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.30.10">7.30.10</a>, <a href="#F">F</a>, 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>,
<a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a> <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>
-
<string.h>, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a> 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.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>
-
<tgmath.h>, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a> 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.30.10">7.30.10</a>, <a href="#F">F</a>,
-
<threads.h>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a> <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>
-
<time.h>, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a> 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>,
-
<uchar.h>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a> <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.28.2.11">7.28.2.11</a>, <a href="#7.28.3.9">7.28.3.9</a>
-
<wchar.h>, <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.28">7.28</a>, <a href="#7.30.12">7.30.12</a>, storage duration, <a href="#6.2.4">6.2.4</a>
+
<a href="#7.23"><string.h></a>, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a> 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.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>
+
<a href="#7.24"><tgmath.h></a>, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a> 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.30.10">7.30.10</a>, <a href="#F">F</a>,
+
<a href="#7.25"><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.25">7.25</a> <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>
+
<a href="#7.26"><time.h></a>, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a> 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>,
+
<a href="#7.27"><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.27">7.27</a> <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.28.2.11">7.28.2.11</a>, <a href="#7.28.3.9">7.28.3.9</a>
+
<a href="#7.28"><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.28">7.28</a>, <a href="#7.30.12">7.30.12</a>, storage duration, <a href="#6.2.4">6.2.4</a>
<a href="#F">F</a>, <a href="#K.3.9">K.3.9</a> storage order of array, <a href="#6.5.2.1">6.5.2.1</a>
-
<wctype.h>, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a> 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"><wctype.h></a>, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a> 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>
standard input stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a> storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a>
standard integer types, <a href="#6.2.5">6.2.5</a> strcat function, <a href="#7.23.3.1">7.23.3.1</a>
standard output stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a> strcat_s function, <a href="#K.3.7.2.1">K.3.7.2.1</a>
projects / c-standard / blobdiff