Programming languages — C

(cover sheet to be replaced by ISO)

This is a working document of SC22/WG14
This version of the document is intended to be the version that is to go into ballot for C17.

• It is based on the transformed LATEXversion of the document that has been proofread by the
  members of WG14 and that has been approved by teleconference in June 2017.
• It applies all TCs of closed DRs up to April 2017.
• It applies the changes that have been voted in Markham.
• It updates some normative references.
• It provides the minimal changes required for a new version of the standard.
• It integrates some editorial changes that had been found during the revision process.

A brief explanation of the changes could still be added to the foreword.

Document conventions
This document classifies identifiers into different categories. This categorization is important to
produce a correct index.
The classes are

• Normal identifiers, toto.
• keywords, while
• symbols with external linkage of the C library, malloc
• types, size_t
• predefined macros that alias language features, complex
• other predefined macros, EOF
• pragmas and their particles, STDC
• tag names and members of struct, union or enum, tv_sec
• name fragments, usually reserved prefixes, atomic_
• character literals, ’a’ or ’ ’ , and wide character literals, L’Ä’, string literals of char type,
  "string" and u8"ströng", and string literals of wide character type, L"ströng", character
  sequences thompson\0, %zu or wide character sequences hello. Space in these are visible
  spaces “ ” such as in "a b c d".
• abstract values are written as mathematical expressions, such as 0, x, 65535 or 2n − 1.

The classification is not always unique, we have identifiers that can refer to a library function in
math.h or to a type generic macro in tgmath.h. Currently we give preference to the fact of being a
library function, e.g we have sqrt.

Abstract

(Cover sheet to be provided by ISO Secretariat.)

This International Standard specifies the form and establishes the interpretation of programs
expressed in the programming language C. Its purpose is to promote portability, reliability, main-
tainability, and efficient execution of C language programs on a variety of computing systems.

Clauses are included that detail the C language itself and the contents of the C language
execution library. Annexes summarize aspects of both of them, and enumerate factors that
influence the portability of C programs.

Although this International Standard is intended to guide knowledgeable C language pro-
grammers as well as implementors of C language translation systems, the document itself is not
designed to serve as a tutorial.

Recipients of this draft are invited to submit, with their comments, notification of any relevant
patent rights of which they are aware and to provide supporting documentation.

Contents

• Foreword
• Introduction
• 1 Scope
• 2 Normative references
• 3 Terms, definitions, and symbols
• 4 Conformance
• 5 Environment
  • 5.1 Conceptual models
    • 5.1.1 Translation environment
    • 5.1.2 Execution environments
  • 5.2 Environmental considerations
    • 5.2.1 Character sets
    • 5.2.2 Character display semantics
    • 5.2.3 Signals and interrupts
    • 5.2.4 Environmental limits
• 6 Language
  • 6.1 Notation
  • 6.2 Concepts
    • 6.2.1 Scopes of identifiers
    • 6.2.2 Linkages of identifiers
    • 6.2.3 Name spaces of identifiers
    • 6.2.4 Storage durations of objects
    • 6.2.5 Types
    • 6.2.6 Representations of types
    • 6.2.7 Compatible type and composite type
    • 6.2.8 Alignment of objects
  • 6.3 Conversions
    • 6.3.1 Arithmetic operands
    • 6.3.2 Other operands
  • 6.4 Lexical elements
    • 6.4.1 Keywords
    • 6.4.2 Identifiers
    • 6.4.3 Universal character names
    • 6.4.4 Constants
    • 6.4.5 String literals
    • 6.4.6 Punctuators
    • 6.4.7 Header names
    • 6.4.8 Preprocessing numbers
    • 6.4.9 Comments
  • 6.5 Expressions
    • 6.5.1 Primary expressions
    • 6.5.2 Postfix operators
    • 6.5.3 Unary operators
    • 6.5.4 Cast operators
    • 6.5.5 Multiplicative operators
    • 6.5.6 Additive operators
    • 6.5.7 Bitwise shift operators
    • 6.5.8 Relational operators
    • 6.5.9 Equality operators
    • 6.5.10 Bitwise AND operator
    • 6.5.11 Bitwise exclusive OR operator
    • 6.5.12 Bitwise inclusive OR operator
    • 6.5.13 Logical AND operator
    • 6.5.14 Logical OR operator
    • 6.5.15 Conditional operator
    • 6.5.16 Assignment operators
    • 6.5.17 Comma operator
  • 6.6 Constant expressions
  • 6.7 Declarations
    • 6.7.1 Storage-class specifiers
    • 6.7.2 Type specifiers
    • 6.7.3 Type qualifiers
    • 6.7.4 Function specifiers
    • 6.7.5 Alignment specifier
    • 6.7.6 Declarators
    • 6.7.7 Type names
    • 6.7.8 Type definitions
    • 6.7.9 Initialization
    • 6.7.10 Static assertions
  • 6.8 Statements and blocks
    • 6.8.1 Labeled statements
    • 6.8.2 Compound statement
    • 6.8.3 Expression and null statements
    • 6.8.4 Selection statements
    • 6.8.5 Iteration statements
    • 6.8.6 Jump statements
  • 6.9 External definitions
    • 6.9.1 Function definitions
    • 6.9.2 External object definitions
  • 6.10 Preprocessing directives
    • 6.10.1 Conditional inclusion
    • 6.10.2 Source file inclusion
    • 6.10.3 Macro replacement
    • 6.10.4 Line control
    • 6.10.5 Error directive
    • 6.10.6 Pragma directive
    • 6.10.7 Null directive
    • 6.10.8 Predefined macro names
    • 6.10.9 Pragma operator
  • 6.11 Future language directions
    • 6.11.1 Floating types
    • 6.11.2 Linkages of identifiers
    • 6.11.3 External names
    • 6.11.4 Character escape sequences
    • 6.11.5 Storage-class specifiers
    • 6.11.6 Function declarators
    • 6.11.7 Function definitions
    • 6.11.8 Pragma directives
    • 6.11.9 Predefined macro names
• 7 Library
  • 7.1 Introduction
    • 7.1.1 Definitions of terms
    • 7.1.2 Standard headers
    • 7.1.3 Reserved identifiers
    • 7.1.4 Use of library functions
  • 7.2 Diagnostics <assert.h>
    • 7.2.1 Program diagnostics
  • 7.3 Complex arithmetic <complex.h>
    • 7.3.1 Introduction
    • 7.3.2 Conventions
    • 7.3.3 Branch cuts
    • 7.3.4 The CX_LIMITED_RANGE pragma
    • 7.3.5 Trigonometric functions
    • 7.3.6 Hyperbolic functions
    • 7.3.7 Exponential and logarithmic functions
    • 7.3.8 Power and absolute-value functions
    • 7.3.9 Manipulation functions
  • 7.4 Character handling <ctype.h>
    • 7.4.1 Character classification functions
    • 7.4.2 Character case mapping functions
  • 7.5 Errors <errno.h>
  • 7.6 Floating-point environment <fenv.h>
    • 7.6.1 The FENV_ACCESS pragma
    • 7.6.2 Floating-point exceptions
    • 7.6.3 Rounding
    • 7.6.4 Environment
  • 7.7 Characteristics of floating types <float.h>
  • 7.8 Format conversion of integer types <inttypes.h>
    • 7.8.1 Macros for format specifiers
    • 7.8.2 Functions for greatest-width integer types
  • 7.9 Alternative spellings <iso646.h>
  • 7.10 Sizes of integer types <limits.h>
  • 7.11 Localization <locale.h>
    • 7.11.1 Locale control
    • 7.11.2 Numeric formatting convention inquiry
  • 7.12 Mathematics <math.h>
    • 7.12.1 Treatment of error conditions
    • 7.12.2 The FP_CONTRACT pragma
    • 7.12.3 Classification macros
    • 7.12.4 Trigonometric functions
    • 7.12.5 Hyperbolic functions
    • 7.12.6 Exponential and logarithmic functions
    • 7.12.7 Power and absolute-value functions
    • 7.12.8 Error and gamma functions
    • 7.12.9 Nearest integer functions
    • 7.12.10 Remainder functions
    • 7.12.11 Manipulation functions
    • 7.12.12 Maximum, minimum, and positive difference functions
    • 7.12.13 Floating multiply-add
    • 7.12.14 Comparison macros
  • 7.13 Nonlocal jumps <setjmp.h>
    • 7.13.1 Save calling environment
    • 7.13.2 Restore calling environment
  • 7.14 Signal handling <signal.h>
    • 7.14.1 Specify signal handling
    • 7.14.2 Send signal
  • 7.15 Alignment <stdalign.h>
  • 7.16 Variable arguments <stdarg.h>
    • 7.16.1 Variable argument list access macros
  • 7.17 Atomics <stdatomic.h>
    • 7.17.1 Introduction
    • 7.17.2 Initialization
    • 7.17.3 Order and consistency
    • 7.17.4 Fences
    • 7.17.5 Lock-free property
    • 7.17.6 Atomic integer types
    • 7.17.7 Operations on atomic types
    • 7.17.8 Atomic flag type and operations
  • 7.18 Boolean type and values <stdbool.h>
  • 7.19 Common definitions <stddef.h>
  • 7.20 Integer types <stdint.h>
    • 7.20.1 Integer types
    • 7.20.2 Limits of specified-width integer types
    • 7.20.3 Limits of other integer types
    • 7.20.4 Macros for integer constants
  • 7.21 Input/output <stdio.h>
    • 7.21.1 Introduction
    • 7.21.2 Streams
    • 7.21.3 Files
    • 7.21.4 Operations on files
    • 7.21.5 File access functions
    • 7.21.6 Formatted input/output functions
    • 7.21.7 Character input/output functions
    • 7.21.8 Direct input/output functions
    • 7.21.9 File positioning functions
    • 7.21.10 Error-handling functions
  • 7.22 General utilities <stdlib.h>
    • 7.22.1 Numeric conversion functions
    • 7.22.2 Pseudo-random sequence generation functions
    • 7.22.3 Memory management functions
    • 7.22.4 Communication with the environment
    • 7.22.5 Searching and sorting utilities
    • 7.22.6 Integer arithmetic functions
    • 7.22.7 Multibyte/wide character conversion functions
    • 7.22.8 Multibyte/wide string conversion functions
  • 7.23 _Noreturn <stdnoreturn.h>
  • 7.24 String handling <string.h>
    • 7.24.1 String function conventions
    • 7.24.2 Copying functions
    • 7.24.3 Concatenation functions
    • 7.24.4 Comparison functions
    • 7.24.5 Search functions
    • 7.24.6 Miscellaneous functions
  • 7.25 Type-generic math <tgmath.h>
  • 7.26 Threads <threads.h>
    • 7.26.1 Introduction
    • 7.26.2 Initialization functions
    • 7.26.3 Condition variable functions
    • 7.26.4 Mutex functions
    • 7.26.5 Thread functions
    • 7.26.6 Thread-specific storage functions
  • 7.27 Date and time <time.h>
    • 7.27.1 Components of time
    • 7.27.2 Time manipulation functions
    • 7.27.3 Time conversion functions
  • 7.28 Unicode utilities <uchar.h>
    • 7.28.1 Restartable multibyte/wide character conversion functions
  • 7.29 Extended multibyte and wide character utilities <wchar.h>
    • 7.29.1 Introduction
    • 7.29.2 Formatted wide character input/output functions
    • 7.29.3 Wide character input/output functions
    • 7.29.4 General wide string utilities
      • 7.29.4.1 Wide string numeric conversion functions
      • 7.29.4.2 Wide string copying functions
      • 7.29.4.3 Wide string concatenation functions
      • 7.29.4.4 Wide string comparison functions
      • 7.29.4.5 Wide string search functions
      • 7.29.4.6 Miscellaneous functions
    • 7.29.5 Wide character time conversion functions
    • 7.29.6 Extended multibyte/wide character conversion utilities
      • 7.29.6.1 Single-byte/wide character conversion functions
      • 7.29.6.2 Conversion state functions
      • 7.29.6.3 Restartable multibyte/wide character conversion functions
      • 7.29.6.4 Restartable multibyte/wide string conversion functions
  • 7.30 Wide character classification and mapping utilities <wctype.h>
    • 7.30.1 Introduction
    • 7.30.2 Wide character classification utilities
      • 7.30.2.1 Wide character classification functions
      • 7.30.2.2 Extensible wide character classification functions
    • 7.30.3 Wide character case mapping utilities
      • 7.30.3.1 Wide character case mapping functions
      • 7.30.3.2 Extensible wide character case mapping functions
  • 7.31 Future library directions
    • 7.31.1 Complex arithmetic <complex.h>
    • 7.31.2 Character handling <ctype.h>
    • 7.31.3 Errors <errno.h>
    • 7.31.4 Floating-point environment <fenv.h>
    • 7.31.5 Format conversion of integer types <inttypes.h>
    • 7.31.6 Localization <locale.h>
    • 7.31.7 Signal handling <signal.h>
    • 7.31.8 Atomics <stdatomic.h>
    • 7.31.9 Boolean type and values <stdbool.h>
    • 7.31.10 Integer types <stdint.h>
    • 7.31.11 Input/output <stdio.h>
    • 7.31.12 General utilities <stdlib.h>
    • 7.31.13 String handling <string.h>
    • 7.31.14 Date and time <time.h>
    • 7.31.15 Threads <threads.h>
    • 7.31.16 Extended multibyte and wide character utilities <wchar.h>
    • 7.31.17 Wide character classification and mapping utilities <wctype.h>
• Annex A (informative) Language syntax summary
  • A.1 Lexical grammar
  • A.2 Phrase structure grammar
  • A.3 Preprocessing directives
  • A.4 Floating-point subject sequence
• Annex B (informative) Library summary
  • B.1 Diagnostics <assert.h>
  • B.2 Complex <complex.h>
  • B.3 Character handling <ctype.h>
  • B.4 Errors <errno.h>
  • B.5 Floating-point environment <fenv.h>
  • B.6 Characteristics of floating types <float.h>
  • B.7 Format conversion of integer types <inttypes.h>
  • B.8 Alternative spellings <iso646.h>
  • B.9 Sizes of integer types <limits.h>
  • B.10 Localization <locale.h>
  • B.11 Mathematics <math.h>
  • B.12 Nonlocal jumps <setjmp.h>
  • B.13 Signal handling <signal.h>
  • B.14 Alignment <stdalign.h>
  • B.15 Variable arguments <stdarg.h>
  • B.16 Atomics <stdatomic.h>
  • B.17 Boolean type and values <stdbool.h>
  • B.18 Common definitions <stddef.h>
  • B.19 Integer types <stdint.h>
  • B.20 Input/output <stdio.h>
  • B.21 General utilities <stdlib.h>
  • B.22 _Noreturn <stdnoreturn.h>
  • B.23 String handling <string.h>
  • B.24 Type-generic math <tgmath.h>
  • B.25 Threads <threads.h>
  • B.26 Date and time <time.h>
  • B.27 Unicode utilities <uchar.h>
  • B.28 Extended multibyte/wide character utilities <wchar.h>
  • B.29 Wide character classification and mapping utilities <wctype.h>
• Annex C (informative) Sequence points
• Annex D (normative) Universal character names for identifiers
  • D.1 Ranges of characters allowed
  • D.2 Ranges of characters disallowed initially
• Annex E (informative) Implementation limits
• Annex F (normative) IEC 60559 floating-point arithmetic
  • F.1 Introduction
  • F.2 Types
  • F.3 Operators and functions
  • F.4 Floating to integer conversion
  • F.5 Binary-decimal conversion
  • F.6 The return statement
  • F.7 Contracted expressions
  • F.8 Floating-point environment
  • F.9 Optimization
  • F.10 Mathematics <math.h>
    • F.10.1 Trigonometric functions
    • F.10.2 Hyperbolic functions
    • F.10.3 Exponential and logarithmic functions
    • F.10.4 Power and absolute value functions
    • F.10.5 Error and gamma functions
    • F.10.6 Nearest integer functions
    • F.10.7 Remainder functions
    • F.10.8 Manipulation functions
    • F.10.9 Maximum, minimum, and positive difference functions
    • F.10.10 Floating multiply-add
    • F.10.11 Comparison macros
• Annex G (normative) IEC 60559-compatible complex arithmetic
  • G.1 Introduction
  • G.2 Types
  • G.3 Conventions
  • G.4 Conversions
    • G.4.1 Imaginary types
    • G.4.2 Real and imaginary
    • G.4.3 Imaginary and complex
  • G.5 Binary operators
    • G.5.1 Multiplicative operators
    • G.5.2 Additive operators
  • G.6 Complex arithmetic <complex.h>
    • G.6.1 Trigonometric functions
    • G.6.2 Hyperbolic functions
    • G.6.3 Exponential and logarithmic functions
    • G.6.4 Power and absolute-value functions
  • G.7 Type-generic math <tgmath.h>
• Annex H (informative) Language independent arithmetic
  • H.1 Introduction
  • H.2 Types
    • H.2.1 Boolean type
    • H.2.2 Integer types
    • H.2.3 Floating-point types
    • H.2.4 Type conversions
  • H.3 Notification
    • H.3.1 Notification alternatives
• Annex I (informative) Common warnings
• Annex J (informative) Portability issues
  • J.1 Unspecified behavior
  • J.2 Undefined behavior
  • J.3 Implementation-defined behavior
    • J.3.1 Translation
    • J.3.2 Environment
    • J.3.3 Identifiers
    • J.3.4 Characters
    • J.3.5 Integers
    • J.3.6 Floating point
    • J.3.7 Arrays and pointers
    • J.3.8 Hints
    • J.3.9 Structures, unions, enumerations, and bit-fields
    • J.3.10 Qualifiers
    • J.3.11 Preprocessing directives
    • J.3.12 Library functions
    • J.3.13 Architecture
  • J.4 Locale-specific behavior
  • J.5 Common extensions
    • J.5.1 Environment arguments
    • J.5.2 Specialized identifiers
    • J.5.3 Lengths and cases of identifiers
    • J.5.4 Scopes of identifiers
    • J.5.5 Writable string literals
    • J.5.6 Other arithmetic types
    • J.5.7 Function pointer casts
    • J.5.8 Extended bit-field types
    • J.5.9 The fortran keyword
    • J.5.10 The asm keyword
    • J.5.11 Multiple external definitions
    • J.5.12 Predefined macro names
    • J.5.13 Floating-point status flags
    • J.5.14 Extra arguments for signal handlers
    • J.5.15 Additional stream types and file-opening modes
    • J.5.16 Defined file position indicator
    • J.5.17 Math error reporting
• Annex K (normative) Bounds-checking interfaces
  • K.1 Background
  • K.2 Scope
  • K.3 Library
    • K.3.1 Introduction
      • K.3.1.1 Standard headers
      • K.3.1.2 Reserved identifiers
      • K.3.1.3 Use of errno
      • K.3.1.4 Runtime-constraint violations
    • K.3.2 Errors <errno.h>
    • K.3.3 Common definitions <stddef.h>
    • K.3.4 Integer types <stdint.h>
    • K.3.5 Input/output <stdio.h>
      • K.3.5.1 Operations on files
      • K.3.5.2 File access functions
      • K.3.5.3 Formatted input/output functions
      • K.3.5.4 Character input/output functions
    • K.3.6 General utilities <stdlib.h>
      • K.3.6.1 Runtime-constraint handling
      • K.3.6.2 Communication with the environment
      • K.3.6.3 Searching and sorting utilities
      • K.3.6.4 Multibyte/wide character conversion functions
      • K.3.6.5 Multibyte/wide string conversion functions
    • K.3.7 String handling <string.h>
      • K.3.7.1 Copying functions
      • K.3.7.2 Concatenation functions
      • K.3.7.3 Search functions
      • K.3.7.4 Miscellaneous functions
    • K.3.8 Date and time <time.h>
      • K.3.8.1 Components of time
      • K.3.8.2 Time conversion functions
    • K.3.9 Extended multibyte and wide character utilities <wchar.h>
      • K.3.9.1 Formatted wide character input/output functions
      • K.3.9.2 General wide string utilities
      • K.3.9.3 Extended multibyte/wide character conversion utilities
• Annex L (normative) Analyzability
  • L.1 Scope
  • L.2 Definitions
  • L.3 Requirements
• Bibliography

Foreword

• conditional (optional) features (including some that were previously mandatory)
• support for multiple threads of execution including an improved memory sequencing model,
  atomic objects, and thread-local storage (<stdatomic.h> and <threads.h>)
• additional floating-point characteristic macros (<float.h>)
• querying and specifying alignment of objects (<stdalign.h>, <stdlib.h>)
• Unicode characters and strings (<uchar.h>) (originally specified in ISO/IEC TR 19769:2004)
• type-generic expressions
• static assertions
• anonymous structures and unions
• no-return functions
• macros to create complex numbers (<complex.h>)
• support for opening files for exclusive access
• removed the gets function (<stdio.h>)
• added the aligned_alloc, at_quick_exit, and quick_exit functions (<stdlib.h>)
• (conditional) support for bounds-checking interfaces (originally specified in ISO/IEC TR 24731–
  1:2007)
• (conditional) support for analyzability

• restricted character set support via digraphs and <iso646.h> (originally specified in
  ISO/IEC 9899:1990/Amd.1:1995)
• wide character library support in <wchar.h> and <wctype.h> (originally specified in
  ISO/IEC 9899:1990/Amd.1:1995)
• more precise aliasing rules via effective type
• restricted pointers
• variable length arrays
• flexible array members
• static and type qualifiers in parameter array declarators
• complex (and imaginary) support in <complex.h>
• type-generic math macros in <tgmath.h>
• the long long int type and library functions
• extended integer types
• increased minimum translation limits
• additional floating-point characteristics in <float.h>
• remove implicit int
• reliable integer division
• universal character names (\u and \U)
• extended identifiers
• hexadecimal floating-point constants and %a and %A printf/scanf conversion specifiers
• compound literals
• designated initializers
• // comments
• specified width integer types and corresponding library functions in <inttypes.h> and
  <stdint.h>
• remove implicit function declaration
• preprocessor arithmetic done in intmax_t/uintmax_t
• mixed declarations and statements
• new block scopes for selection and iteration statements
• integer constant type rules
• integer promotion rules
• macros with a variable number of arguments
• the vscanf family of functions in <stdio.h> and <wchar.h>
• additional math library functions in <math.h>
• treatment of error conditions by math library functions (math_errhandling)
• floating-point environment access in <fenv.h>
• IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
• trailing comma allowed in enum declaration
• %lf conversion specifier allowed in printf
• inline functions
• the snprintf family of functions in <stdio.h>
• boolean type in <stdbool.h>
• idempotent type qualifiers
• empty macro arguments
• new structure type compatibility rules (tag compatibility)
• additional predefined macro names
• _Pragma preprocessing operator
• standard pragmas
• __func__ predefined identifier
• va_copy macro
• additional strftime conversion specifiers
• LIA compatibility annex
• deprecate ungetc at the beginning of a binary file
• remove deprecation of aliased array parameters
• conversion of array to pointer not limited to lvalues
• relaxed constraints on aggregate and union initialization
• relaxed restrictions on portable header names
• return without expression not permitted in function that returns a value (and vice versa)

Introduction

• preliminary elements (clauses 1–4);
• the characteristics of environments that translate and execute C programs (clause 5);
• the language syntax, constraints, and semantics (clause 6);
• the library facilities (clause 7).

Programming languages — C

1. Scope

• the representation of C programs;
• the syntax and constraints of the C language;
• the semantic rules for interpreting C programs;
• the representation of input data to be processed by C programs;
• the representation of output data produced by C programs;
• the restrictions and limits imposed by a conforming implementation of C.

• the mechanism by which C programs are transformed for use by a data-processing system;
• the mechanism by which C programs are invoked for use by a data-processing system;
• the mechanism by which input data are transformed for use by a C program;
• the mechanism by which output data are transformed after being produced by a C program;
• the size or complexity of a program and its data that will exceed the capacity of any specific
  data-processing system or the capacity of a particular processor;
• all minimal requirements of a data-processing system that is capable of supporting a conform-
  ing implementation.

2. Normative references

3. Terms, definitions, and symbols

3.1

3.2

3.3

3.4

3.4.1

3.4.2

3.4.3

3.4.4

3.5

3.6

3.7

3.7.1

3.7.2

3.7.3

3.8

3.9

3.10

3.11

3.12

3.13

3.14

    struct {
          char a;
          int b:5, c:11,:0, d:8;
          struct { int ee:8; } e;
    }
  

contains four separate memory locations: The member a, and bit-fields d and e.ee are each separate memory locations,
and can be modified concurrently without interfering with each other. The bit-fields b and c together constitute the fourth
memory location. The bit-fields b and c cannot be concurrently modified, but b and a, for example, can be.

3.15

3.16

3.17

3.18

3.19

3.19.1

3.19.2

3.19.3

3.19.4

3.19.5

3.20

3.21

4. Conformance

Forward references: conditional inclusion (6.10.1), error directive (6.10.5), characteristics of floating
types <float.h> (7.7), alternative spellings <iso646.h> (7.9), sizes of integer types <limits.h>
(7.10), alignment <stdalign.h> (7.15), variable arguments <stdarg.h> (7.16), boolean type and
values <stdbool.h> (7.18), common definitions <stddef.h> (7.19), integer types <stdint.h> (7.20),
<stdnoreturn.h> (7.23).

      #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
         /* ... */
         fesetround(FE_UPWARD);
         /* ... */
      #endif
    

5. Environment

Forward references: In this clause, only a few of many possible forward references have been
noted.

5.1 Conceptual models

5.1.1 Translation environment

5.1.1.1 Program structure

Forward references: linkages of identifiers (6.2.2), external definitions (6.9), preprocessing direc-
tives (6.10).

5.1.1.2 Translation phases

1. Physical source file multibyte characters are mapped, in an implementation-defined manner, to the source character set (introducing new-line characters for end-of-line indicators) if necessary. Trigraph sequences are replaced by corresponding single-character internal representations.
2. Each instance of a backslash character (\ ) immediately followed by a new-line character is
   deleted, splicing physical source lines to form logical source lines. Only the last backslash on
   any physical source line shall be eligible for being part of such a splice. A source file that is
   not empty shall end in a new-line character, which shall not be immediately preceded by a
   backslash character before any such splicing takes place.
3. The source file is decomposed into preprocessing tokens7) and sequences of white-space
   characters (including comments). A source file shall not end in a partial preprocessing token or
   in a partial comment. Each comment is replaced by one space character. New-line characters
   are retained. Whether each nonempty sequence of white-space characters other than new-line
   is retained or replaced by one space character is implementation-defined.
4. Preprocessing directives are executed, macro invocations are expanded, and _Pragma unary
   operator expressions are executed. If a character sequence that matches the syntax of a univer-
   sal character name is produced by token concatenation (6.10.3.3), the behavior is undefined. A
   #include preprocessing directive causes the named header or source file to be processed from
   phase 1 through phase 4, recursively. All preprocessing directives are then deleted.
5. Each source character set member and escape sequence in character constants and string
   literals is converted to the corresponding member of the execution character set; if there is no
   corresponding member, it is converted to an implementation-defined member other than the
   null (wide) character.8)
6. Adjacent string literal tokens are concatenated.
7. White-space characters separating tokens are no longer significant. Each preprocessing token
   is converted into a token. The resulting tokens are syntactically and semantically analyzed
   and translated as a translation unit.
8. All external object and function references are resolved. Library components are linked to
   satisfy external references to functions and objects not defined in the current translation. All
   such translator output is collected into a program image which contains information needed
   for execution in its execution environment.

Forward references: universal character names (6.4.3), lexical elements (6.4), preprocessing direc-
tives (6.10), trigraph sequences (5.2.1.1), external definitions (6.9).

5.1.1.3 Diagnostics

    char i;
    int i;
  

because in those cases where wording in this International Standard describes the behavior for a construct as being both a
constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.

5.1.2 Execution environments

Forward references: storage durations of objects (6.2.4), initialization (6.7.9).

5.1.2.1 Freestanding environment

5.1.2.2 Hosted environment

5.1.2.2.1 Program startup

    int main(void) { /* ... */ }
  

or with two parameters (referred to here as argc and argv, though any names may be used, as they
are local to the function in which they are declared):

    int main(int argc, char *argv[]) { /* ... */ }
  

or equivalent;10) or in some other implementation-defined manner.

• The value of argc shall be nonnegative.
• argv[argc] shall be a null pointer.
• If the value of argc is greater than zero, the array members argv[0] through argv[argc-1]
  inclusive shall contain pointers to strings, which are given implementation-defined values
  by the host environment prior to program startup. The intent is to supply to the program
  information determined prior to program startup from elsewhere in the hosted environment.
  If the host environment is not capable of supplying strings with letters in both uppercase and
  lowercase, the implementation shall ensure that the strings are received in lowercase.
• If the value of argc is greater than zero, the string pointed to by argv[0] represents the
  program name; argv[0][0] shall be the null character if the program name is not available
  from the host environment. If the value of argc is greater than one, the strings pointed to by
  argv[1] through argv[argc-1] represent the program parameters.
• The parameters argc and argv and the strings pointed to by the argv array shall be modifiable
  by the program, and retain their last-stored values between program startup and program
  termination.

      ** argv, and so
    

5.1.2.2.2 Program execution

5.1.2.2.3 Program termination

Forward references: definition of terms (7.1.1), the exit function (7.22.4.4).

5.1.2.3 Program execution

Value computation for an lvalue expression includes determining the identity of the designated
object.

• Accesses to volatile objects are evaluated strictly according to the rules of the abstract machine.
• At program termination, all data written into files shall be identical to the result that execution
  of the program according to the abstract semantics would have produced.
• The input and output dynamics of interactive devices shall take place as specified in 7.21.3.
  The intent of these requirements is that unbuffered or line-buffered output appear as soon as
  possible, to ensure that prompting messages actually appear prior to a program waiting for
  input.

This is the observable behavior of the program.

    char c1, c2;
    /* ... */
    c1 = c1 + c2;
  

the “integer promotions” require that the abstract machine promote the value of each variable to int size and then add
the two ints and truncate the sum. Provided the addition of two chars can be done without overflow, or with overflow
wrapping silently to produce the correct result, the actual execution need only produce the same result, possibly omitting the
promotions.

    float f1, f2;
    double d;
    /* ... */
    f1 = f2 * d;
  

the multiplication may be executed using single-precision arithmetic if the implementation can ascertain that the result would
be the same as if it were executed using double-precision arithmetic (for example, if d were replaced by the constant 2.0,
which has type double).

    double d1, d2;
    float f;
    d1 = f = expression;
    d2 = (float) expression;
  

the values assigned to d1 and d2 are required to have been converted to float.

    double x, y, z;
    /* ... */
    x = (x * y) * z;        // not equivalent to x *= y * z;
    z = (x - y) + y;        // not equivalent to z = x;
    z = x + x * y;          // not equivalent to z = x * (1.0 + y);
    y = x / 5.0;            // not equivalent to y = x * 0.2;
  

    int a, b;
    /* ... */
    a = a + 32760 + b + 5;
  

the expression statement behaves exactly the same as

    a = (((a + 32760) + b) + 5);
  

due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is next added to b, and
that result is then added to 5 which results in the value assigned to a. On a machine in which overflows produce an explicit
trap and in which the range of values representable by an int is [−32768, +32767], the implementation cannot rewrite this
expression as

    a = ((a + b) + 32765);
  

since if the values for a and b were, respectively, −32754 and −15, the sum a + b would produce a trap while the original
expression would not; nor can the expression be rewritten either as

    a = ((a + 32765) + b);
  

or

    a = (a + (b + 32765));
  

since the values for a and b might have been, respectively, 4 and −8 or −17 and 12. However, on a machine in which
overflow silently generates some value and where positive and negative overflows cancel, the above expression statement
can be rewritten by the implementation in any of the above ways because the same result will occur.

    #include <stdio.h>
    int sum;
    char *p;
    /* ... */
    sum = sum * 10 - ’0’ + (*p++ = getchar());
  

the expression statement is grouped as if it were written as

    sum = (((sum * 10) - ’0’) + ((*(p++)) = (getchar())));
  

but the actual increment of p can occur at any time between the previous sequence point and the next sequence point (the ;),
and the call to getchar can occur at any point prior to the need of its returned value.

Forward references: expressions (6.5), type qualifiers (6.7.3), statements (6.8), floating-point envi-
ronment <fenv.h> (7.6), the signal function (7.14), files (7.21.3).

5.1.2.4 Multi-threaded executions and data races

• the value of A is used as an operand of B, unless:
  • B is an invocation of the kill_dependency macro,
  • A is the left operand of a && or || operator,
  • A is the left operand of a ?: operator, or
  • A is the left operand of a , operator;

  or

• A writes a scalar object or bit-field M , B reads from M the value written by A, and A is
  sequenced before B, or
• for some evaluation X, A carries a dependency to X and X carries a dependency to B.

• A performs a release operation on an atomic object M , and, in another thread, B performs a
  consume operation on M and reads a value written by any side effect in the release sequence
  headed by A, or
• for some evaluation X, A is dependency-ordered before X and X carries a dependency to B.

• A synchronizes with X and X is sequenced before B,
• A is sequenced before X and X inter-thread happens before B, or
• A inter-thread happens before X and X inter-thread happens before B.

• A happens before B, and
• there is no other side effect X to M such that A happens before X and X happens before B.

The value of a non-atomic scalar object M , as determined by evaluation B, shall be the value stored
by the visible side effect A.

5.2 Environmental considerations

5.2.1 Character sets

    A   B    C   D   E   F    G   H   I    J   K   L   M
    N   O    P   Q   R   S    T   U   V    W   X   Y   Z
  

the 26 lowercase letters of the Latin alphabet

    a   b    c   d   e   f    g   h   i    j   k   l   m
    n   o    p   q   r   s    t   u   v    w   x   y   z
  

the 10 decimal digits

    0   1    2   3   4   5    6   7   8    9
  

the following 29 graphic characters

    !   "    #   %   &   ’    (   )   *    +   ,   -   .    /   :
    ;   <    =   >   ?   [    \   ]   ^    _   {   |   }    ~
  

the space character, and control characters representing horizontal tab, vertical tab, and form feed.
The representation of each member of the source and execution basic character sets shall fit in a byte.
In both the source and execution basic character sets, the value of each character after 0 in the above
list of decimal digits shall be one greater than the value of the previous. In source files, there shall
be some way of indicating the end of each line of text; this International Standard treats such an
end-of-line indicator as if it were a single new-line character. In the basic execution character set,
there shall be control characters representing alert, backspace, carriage return, and new line. If any
other characters are encountered in a source file (except in an identifier, a character constant, a string
literal, a header name, a comment, or a preprocessing token that is never converted to a token), the
behavior is undefined.

Forward references: universal character names (6.4.3), character constants (6.4.4.4), preprocessing
directives (6.10), string literals (6.4.5), comments (6.4.9), string (7.1.1).

5.2.1.1 Trigraph sequences

    ??=     #                    ??) ]                           ??! |
    ??(     [                    ??’ ^                           ??> }
    ??/     \                    ??< {                           ??- ~
  

No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed above is not
changed.

    ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)
  

becomes

    #define arraycheck(a, b) a[b] || b[a]
  

    printf("Eh???/n");
  

becomes (after replacement of the trigraph sequence ??/)

    printf("Eh?\n");
  

5.2.1.2 Multibyte characters

• The basic character set shall be present and each character shall be encoded as a single byte.
• The presence, meaning, and representation of any additional members is locale-specific.
• A multibyte character set may have a state-dependent encoding, wherein each sequence of
  multibyte characters begins in an initial shift state and enters other locale-specific shift states
  when specific multibyte characters are encountered in the sequence. While in the initial shift
  state, all single-byte characters retain their usual interpretation and do not alter the shift state.
  The interpretation for subsequent bytes in the sequence is a function of the current shift state.
• A byte with all bits zero shall be interpreted as a null character independent of shift state. Such
  a byte shall not occur as part of any other multibyte character.

• An identifier, comment, string literal, character constant, or header name shall begin and end
  in the initial shift state.
• An identifier, comment, string literal, character constant, or header name shall consist of a
  sequence of valid multibyte characters.

5.2.2 Character display semantics

\a (alert) Produces an audible or visible alert without changing the active position.

\b (backspace) Moves the active position to the previous position on the current line. If the active
position is at the initial position of a line, the behavior of the display device is unspecified.

\f (form feed) Moves the active position to the initial position at the start of the next logical page.

\n (new line) Moves the active position to the initial position of the next line.

\r (carriage return) Moves the active position to the initial position of the current line.

\t (horizontal tab) Moves the active position to the next horizontal tabulation position on the current
line. If the active position is at or past the last defined horizontal tabulation position, the behavior
of the display device is unspecified.

\v (vertical tab) Moves the active position to the initial position of the next vertical tabulation
position. If the active position is at or past the last defined vertical tabulation position, the
behavior of the display device is unspecified.

Forward references: the isprint function (7.4.1.8), the fputc function (7.21.7.3).

5.2.3 Signals and interrupts

5.2.4 Environmental limits

5.2.4.1 Translation limits

• 127 nesting levels of blocks
• 63 nesting levels of conditional inclusion
• 12 pointer, array, and function declarators (in any combinations) modifying an arithmetic,
  structure, union, or void type in a declaration
• 63 nesting levels of parenthesized declarators within a full declarator
• 63 nesting levels of parenthesized expressions within a full expression
• 63 significant initial characters in an internal identifier or a macro name(each universal charac-
  ter name or extended source character is considered a single character)
• 31 significant initial characters in an external identifier (each universal character name specify-
  ing a short identifier of 0000FFFF or less is considered 6 characters, each universal character
  name specifying a short identifier of 00010000 or more is considered 10 characters, and each
  extended source character is considered the same number of characters as the corresponding
  universal character name, if any)19)
• 4095 external identifiers in one translation unit
• 511 identifiers with block scope declared in one block
• 4095 macro identifiers simultaneously defined in one preprocessing translation unit
• 127 parameters in one function definition
• 127 arguments in one function call
• 127 parameters in one macro definition
• 127 arguments in one macro invocation
• 4095 characters in a logical source line
• 4095 characters in a string literal (after concatenation)
• 65535 bytes in an object (in a hosted environment only)
• 15 nesting levels for #included files
• 1023 case labels for a switch statement (excluding those for any nested switch statements)
• 1023 members in a single structure or union
• 1023 enumeration constants in a single enumeration
• 63 levels of nested structure or union definitions in a single struct-declaration-list

5.2.4.2 Numerical limits

Forward references: integer types <stdint.h> (7.20).

5.2.4.2.1 Sizes of integer types <limits.h>

• number of bits for smallest object that is not a bit-field (byte)

          CHAR_BIT                                     8
        

• minimum value for an object of type signed char

          SCHAR_MIN                                 -127 // −(27 − 1)
        

• maximum value for an object of type signed char

          SCHAR_MAX                    +127 // 27 − 1
        

• maximum value for an object of type unsigned char

          UCHAR_MAX                     255 // 28 − 1
        

• minimum value for an object of type char

          CHAR_MIN                  see below
        

• maximum value for an object of type char

          CHAR_MAX                  see below
        

• maximum number of bytes in a multibyte character, for any supported locale

          MB_LEN_MAX                       1
        

• minimum value for an object of type short int

          SHRT_MIN                   -32767 // −(215 − 1)
        

• maximum value for an object of type short int

          SHRT_MAX                   +32767 // 215 − 1
        

• maximum value for an object of type unsigned short int

          USHRT_MAX                   65535 // 216 − 1
        

• minimum value for an object of type int

          INT_MIN                    -32767 // −(215 − 1)
        

• maximum value for an object of type int

          INT_MAX                    +32767 // 215 − 1
        

• maximum value for an object of type unsigned int

          UINT_MAX                    65535 // 216 − 1
        

• minimum value for an object of type long int

          LONG_MIN              -2147483647 // −(231 − 1)
        

• maximum value for an object of type long int

          LONG_MAX              +2147483647 // 231 − 1
        

• maximum value for an object of type unsigned long int

          ULONG_MAX                         4294967295 // 232 − 1
        

• minimum value for an object of type long long int

          LLONG_MIN             -9223372036854775807 // −(263 − 1)
        

• maximum value for an object of type long long int

          LLONG_MAX             +9223372036854775807 // 263 − 1
        

• maximum value for an object of type unsigned long long int

          ULLONG_MAX            18446744073709551615 // 264 − 1
        

    _
  

value UCHAR_MAX shall equal 2CHAR BIT − 1.

Forward references: representations of types (6.2.6), conditional inclusion (6.10.1).

5.2.4.2.2 Characteristics of floating types <float.h>

    s          sign (±1)
    b          base or radix of exponent representation (an integer > 1)
    e          exponent (an integer between a minimum emin and a maximum emax )
    p          precision (the number of base-b digits in the significand)
    fk         nonnegative integers less than b (the significand digits)
  

                 p
    x = sbe            fk b−k ,
                 P
                                  emin ≤ e ≤ emax
                 k=1
  

-1

indeterminable

0

toward zero

1

to nearest

2

toward positive infinity

3

toward negative infinity

All other values for FLT_ROUNDS characterize implementation-defined rounding behavior.

-1

indeterminable;

0

evaluate all operations and constants just to the range and precision of the type;

1

evaluate operations and constants of type float and double to the range and precision of
the double type, evaluate long double operations and constants to the range and precision
of the long double type;

2

evaluate all operations and constants to the range and precision of the long double type.

All other negative values for FLT_EVAL_METHOD characterize implementation-defined behavior.

-1

indeterminable25)

0

absent (type does not support subnormal numbers)26)

1

present (type does support subnormal numbers)

• radix of exponent representation, b

          FLT_RADIX                           2
        

• number of base-FLT_RADIX digits in the floating-point significand, p

          FLT_MANT_DIG
          DBL_MANT_DIG
          LDBL_MANT_DIG
        

• number of decimal digits, n, such that any floating-point number with p radix b digits can be
  rounded to a floating-point number with n decimal digits and back again without change to
  the value,

          (
            p log10 b       if b is a power of 10
            d1 + p log10 be otherwise
        

          FLT_DECIMAL_DIG                      6
          DBL_DECIMAL_DIG                     10
          LDBL_DECIMAL_DIG                    10
        

• number of decimal digits, n, such that any floating-point number in the widest supported
  floating type with pmax radix b digits can be rounded to a floating-point number with n decimal
  digits and back again without change to the value,

          (
            pmax log10 b        if b is a power of 10
            d1 + pmax log10 be otherwise
        

          DECIMAL_DIG                         10
        

• number of decimal digits, q, such that any floating-point number with q decimal digits can be
  rounded into a floating-point number with p radix b digits and back again without change to
  the q decimal digits,

          (
            p log10 b         if b is a power of 10
            b(p − 1) log10 bc otherwise
        

          FLT_DIG                              6
          DBL_DIG                             10
          LDBL_DIG                            10
        

• minimum negative integer such that FLT_RADIX raised to one less than that power is a normal-
  ized floating-point number, emin

          FLT_MIN_EXP
          DBL_MIN_EXP
          LDBL_MIN_EXP
        

• minimum negative integer

                                  such that10 raised to that power is in the range of normalized
          floating-point numbers, log10 bemin −1
        

          FLT_MIN_10_EXP                             -37
          DBL_MIN_10_EXP                             -37
          LDBL_MIN_10_EXP                            -37
        

• maximum integer such that FLT_RADIX raised to one less than that power is a representable
  finite floating-point number, emax

          FLT_MAX_EXP
          DBL_MAX_EXP
          LDBL_MAX_EXP
        

• maximum integer such that 10 raised to that power is in the range of representable finite
  floating-point numbers, blog10 ((1 − b−p )bemax )c

          FLT_MAX_10_EXP                             +37
          DBL_MAX_10_EXP                             +37
          LDBL_MAX_10_EXP                            +37
        

• maximum representable finite floating-point number, (1 − b−p )bemax

          FLT_MAX                                 1E+37
          DBL_MAX                                 1E+37
          LDBL_MAX                                1E+37
        

• the difference between 1 and the least value greater than 1 that is representable in the given
  floating point type, b1−p

          FLT_EPSILON                               1E-5
          DBL_EPSILON                               1E-9
          LDBL_EPSILON                              1E-9
        

• minimum normalized positive floating-point number, bemin −1

          FLT_MIN                                 1E-37
          DBL_MIN                                 1E-37
          LDBL_MIN                                1E-37
        

• minimum positive floating-point number27)

          FLT_TRUE_MIN                            1E-37
          DBL_TRUE_MIN                            1E-37
          LDBL_TRUE_MIN                           1E-37
        

Recommended practice

               6
    x = s16e         fk 16−k ,
               P
                                 −31 ≤ e ≤ +32
               k=1
  

    FLT_RADIX                                   16
    FLT_MANT_DIG                                 6
    FLT_EPSILON                    9.53674316E-07F
    FLT_DECIMAL_DIG                              9
    FLT_DIG                                      6
    FLT_MIN_EXP                                -31
    FLT_MIN                        2.93873588E-39F
    FLT_MIN_10_EXP                             -38
    FLT_MAX_EXP                                +32
    FLT_MAX                        3.40282347E+38F
    FLT_MAX_10_EXP                             +38
  

               24
    xf = s2e         fk 2−k ,
               P
                                 −125 ≤ e ≤ +128
               k=1
  

               53
    xd = s2e         fk 2−k ,
               P
                                 −1021 ≤ e ≤ +1024
               k=1
  

    FLT_RADIX                          2
    DECIMAL_DIG                       17
    FLT_MANT_DIG                      24
    FLT_EPSILON          1.19209290E-07F // decimal constant
    FLT_EPSILON                 0X1P-23F // hex constant
    FLT_DECIMAL_DIG                    9
    FLT_DIG                            6
    FLT_MIN_EXP                     -125
    FLT_MIN              1.17549435E-38F // decimal constant
    FLT_MIN                    0X1P-126F // hex constant
    FLT_TRUE_MIN         1.40129846E-45F // decimal constant
    FLT_TRUE_MIN               0X1P-149F // hex constant
    FLT_HAS_SUBNORM                    1
    FLT_MIN_10_EXP                   -37
    FLT_MAX_EXP                     +128
    FLT_MAX              3.40282347E+38F // decimal constant
    FLT_MAX              0X1.fffffeP127F // hex constant
    FLT_MAX_10_EXP                   +38
    DBL_MANT_DIG                      53
    DBL_EPSILON   2.2204460492503131E-16 // decimal constant
    DBL_EPSILON                  0X1P-52 // hex constant
    DBL_DECIMAL_DIG                   17
    DBL_DIG                           15
    DBL_MIN_EXP                    -1021
    DBL_MIN      2.2250738585072014E-308 // decimal constant
    DBL_MIN                    0X1P-1022 // hex constant
    DBL_TRUE_MIN 4.9406564584124654E-324 // decimal constant
    DBL_TRUE_MIN               0X1P-1074 // hex constant
    DBL_HAS_SUBNORM                    1
    DBL_MIN_10_EXP                  -307
    DBL_MAX_EXP                    +1024
    DBL_MAX      1.7976931348623157E+308 // decimal constant
    DBL_MAX       0X1.fffffffffffffP1023 // hex constant
    DBL_MAX_10_EXP                  +308
  

If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For 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 (6.10.1), complex arithmetic <complex.h> (7.3), ex-
tended multibyte and wide character utilities <wchar.h> (7.29), floating-point environment
<fenv.h> (7.6), general utilities <stdlib.h> (7.22), input/output <stdio.h> (7.21), mathematics
<math.h> (7.12).

6. Language

6.1 Notation

    { expressionopt }
  

indicates an optional expression enclosed in braces.

6.2 Concepts

6.2.1 Scopes of identifiers

Forward references: declarations (6.7), function calls (6.5.2.2), function definitions (6.9.1), identifiers
(6.4.2), macro replacement (6.10.3), name spaces of identifiers (6.2.3), source file inclusion (6.10.2),
statements and blocks (6.8).

6.2.2 Linkages of identifiers

Forward references: declarations (6.7), expressions (6.5), external definitions (6.9), statements (6.8).

6.2.3 Name spaces of identifiers

• label names (disambiguated by the syntax of the label declaration and use);
• the tags of structures, unions, and enumerations (disambiguated by following any32) of the
  keywords struct, union, or enum);
• the members of structures or unions; each structure or union has a separate name space for its
  members (disambiguated by the type of the expression used to access the member via the . or
  -> operator);
• all other identifiers, called ordinary identifiers (declared in ordinary declarators or as enumera-
  tion constants).

Forward references: enumeration specifiers (6.7.2.2), labeled statements (6.8.1), structure and union
specifiers (6.7.2.1), structure and union members (6.5.2.3), tags (6.7.2.3), the goto statement (6.8.6.1).

6.2.4 Storage durations of objects

Forward references: array declarators (6.7.6.2), compound literals (6.5.2.5), declarators (6.7.6),
function calls (6.5.2.2), initialization (6.7.9), statements (6.8), effective type (6.5).

6.2.5 Types

6.10.8.3.) The real floating and complex types are collectively called the floating types.

• An array type describes a contiguously allocated nonempty set of objects with a particular
  member object type, called the element type. The element type shall be complete whenever the
  array type is specified. Array types are characterized by their element type and by the number
  of elements in the array. An array type is said to be derived from its element type, and if its
  element type is T, the array type is sometimes called “array of T”. The construction of an array
  type from an element type is called “array type derivation”.
• A structure type describes a sequentially allocated nonempty set of member objects (and, in
  certain circumstances, an incomplete array), each of which has an optionally specified name
  and possibly distinct type.
• A union type describes an overlapping nonempty set of member objects, each of which has an
  optionally specified name and possibly distinct type.
• A function type describes a function with specified return type. A function type is characterized
  by its return type and the number and types of its parameters. A function type is said to
  be derived from its return type, and if its return type is T, the function type is sometimes
  called “function returning T”. The construction of a function type from a return type is called
  “function type derivation”.
• A pointer type may be derived from a function type or an object type, called the referenced type. A
  pointer type describes an object whose value provides a reference to an entity of the referenced
  type. A pointer type derived from the referenced type T is sometimes called “pointer to T”.
  The construction of a pointer type from a referenced type is called “pointer type derivation”.
  A pointer type is a complete object type.
• An atomic type describes the type designated by the construct _Atomic (type-name). (Atomic
  types are a conditional feature that implementations need not support; see 6.10.8.3.)

These methods of constructing derived types can be applied recursively.

Forward references: compatible type and composite type (6.2.7), declarations (6.7).

6.2.6 Representations of types

6.2.6.1 General

Forward references: declarations (6.7), expressions (6.5), lvalues, arrays, and function designators
(6.3.2.1), order and consistency (7.17.3).

      _
    

6.2.6.2 Integer types

• the corresponding value with sign bit 0 is negated (sign and magnitude);
• the sign bit has the value −(2M ) (two’s complement);
• the sign bit has the value −(2M − 1) (ones’ complement).

Which of these applies is implementation-defined, as is whether the value with sign bit 1 and all
value bits zero (for the first two), or with sign bit and all value bits 1 (for ones’ complement), is a
trap representation or a normal value. In the case of sign and magnitude and ones’ complement, if
this representation is a normal value it is called a negative zero.

• the &, |, ^, ~ , << , and >> operators with operands that produce such a value;
• the + ,- , * , / , and % operators where one operand is a negative zero and the result is zero;
• compound assignment operators based on the above cases.

It is unspecified whether these cases actually generate a negative zero or a normal zero, and whether
a negative zero becomes a normal zero when stored in an object.

6.2.7 Compatible type and composite type

• If both types are array types, the following rules are applied:
  • If one type is an array of known constant size, the composite type is an array of that size.
  • Otherwise, if one type is a variable length array whose size is specified by an expression
    that is not evaluated, the behavior is undefined.
  • Otherwise, if one type is a variable length array whose size is specified, the composite
    type is a variable length array of that size.
  • Otherwise, if one type is a variable length array of unspecified size, the composite type is
    a variable length array of unspecified size.
  • Otherwise, both types are arrays of unknown size and the composite type is an array of
    unknown size.

  The element type of the composite type is the composite type of the two element types.

• If only one type is a function type with a parameter type list (a function prototype), the
  composite type is a function prototype with the parameter type list.
• If both types are function types with parameter type lists, the type of each parameter in the
  composite parameter type list is the composite type of the corresponding parameters.

These rules apply recursively to the types from which the two types are derived.

Forward references: array declarators (6.7.6.2).

    int f(int (*)(), double (*)[3]);
    int f(int (*)(char *), double (*)[]);
  

The resulting composite type for the function is:

    int f(int (*)(char *), double (*)[3]);
  

6.2.8 Alignment of objects

• all atomic, qualified or unqualified basic types;
• all atomic, qualified or unqualified enumerated types;
• all atomic, qualified or unqualified pointer types;
• all array types whose element type has a fundamental alignment requirement;
• all types specified in clause 7 as complete object types;
• all structure or union types all of whose elements have types with fundamental alignment
  requirements and none of whose elements have an alignment specifier specifying an alignment
  that is not a fundamental alignment.

• Two alignments are equal when their numeric values are equal.
• Two alignments are different when their numeric values are not equal.
• When an alignment is larger than another it represents a stricter alignment.

6.3 Conversions

Forward references: cast operators (6.5.4).

6.3.1 Arithmetic operands

6.3.1.1 Boolean, characters, and integers

• No two signed integer types shall have the same rank, even if they have the same representa-
  tion.
• The rank of a signed integer type shall be greater than the rank of any signed integer type with
  less precision.
• The rank of long long int shall be greater than the rank of long int, which shall be greater
  than the rank of int, which shall be greater than the rank of short int, which shall be greater
  than the rank of signed char.
• The rank of any unsigned integer type shall equal the rank of the corresponding signed integer
  type, if any.
• The rank of any standard integer type shall be greater than the rank of any extended integer
  type with the same width.
• The rank of char shall equal the rank of signed char and unsigned char.
• The rank of _Bool shall be less than the rank of all other standard integer types.
• The rank of any enumerated type shall equal the rank of the compatible integer type (see
  6.7.2.2).
• The rank of any extended signed integer type relative to another extended signed integer
  type with the same precision is implementation-defined, but still subject to the other rules for
  determining the integer conversion rank.
• For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than
  T3 , then T1 has greater rank than T3.

• An object or expression with an integer type (other than int or unsigned int) whose integer
  conversion rank is less than or equal to the rank of int and unsigned int.
• A bit-field of type _Bool , int, signed int, or unsigned int.

If an int can represent all values of the original type (as restricted by the width, for a bit-field), the
value is converted to an int; otherwise, it is converted to an unsigned int. These are called the
integer promotions.58) All other types are unchanged by the integer promotions.

Forward references: enumeration specifiers (6.7.2.2), structure and union specifiers (6.7.2.1).

6.3.1.2 Boolean type

6.3.1.3 Signed and unsigned integers

6.3.1.4 Real floating and integer

If the value being converted is outside the range of values that can be represented, the behavior is
undefined. Results of some implicit conversions may be represented in greater range and precision
than that required by the new type (see 6.3.1.8 and 6.8.6.4).

6.3.1.5 Real floating types

6.3.1.6 Complex types

6.3.1.7 Real and complex

6.3.1.8 Usual arithmetic conversions

    First, if the corresponding real type of either operand is long double, the other operand
    is converted, without change of type domain, to a type whose corresponding real type is
    long double.
  

    Otherwise, if the corresponding real type of either operand is double, the other operand is
    converted, without change of type domain, to a type whose corresponding real type is double.
  

    Otherwise, if the corresponding real type of either operand is float, the other operand is
    converted, without change of type domain, to a type whose corresponding real type is float.63)
  

    Otherwise, the integer promotions are performed on both operands. Then the following rules
    are applied to the promoted operands:
  

    If both operands have the same type, then no further conversion is needed.
    Otherwise, if both operands have signed integer types or both have unsigned integer
    types, the operand with the type of lesser integer conversion rank is converted to the type
    of the operand with greater rank.
    Otherwise, if the operand that has unsigned integer type has rank greater or equal to
    the rank of the type of the other operand, then the operand with signed integer type is
    converted to the type of the operand with unsigned integer type.
    Otherwise, if the type of the operand with signed integer type can represent all of the
    values of the type of the operand with unsigned integer type, then the operand with
    unsigned integer type is converted to the type of the operand with signed integer type.
  

    Otherwise, both operands are converted to the unsigned integer type corresponding to
    the type of the operand with signed integer type.
  

6.3.2 Other operands

6.3.2.1 Lvalues, arrays, and function designators

Forward references: address and indirection operators (6.5.3.2), assignment operators (6.5.16),
common definitions <stddef.h> (7.19), initialization (6.7.9), postfix increment and decrement
operators (6.5.2.4), prefix increment and decrement operators (6.5.3.1), the sizeof and _Alignof
operators (6.5.3.4), structure and union members (6.5.2.3).

6.3.2.2 void

6.3.2.3 Pointers

Forward references: cast operators (6.5.4), equality operators (6.5.9), integer types capable of
holding object pointers (7.20.1.4), simple assignment (6.5.16.1).

6.4 Lexical elements

Syntax

    keyword
    identifier
    constant
    string-literal
    punctuator
  

preprocessing-token:

     header-name
     identifier
     pp-number
     character-constant
     string-literal
     punctuator
    each non-white-space character that cannot be one of the above
  

Constraints

Semantics

Forward references: character constants (6.4.4.4), comments (6.4.9), expressions (6.5), floating
constants (6.4.4.2), header names (6.4.7), macro replacement (6.10.3), postfix increment and decrement
operators (6.5.2.4), prefix increment and decrement operators (6.5.3.1), preprocessing directives (6.10),
preprocessing numbers (6.4.8), string literals (6.4.5).

6.4.1 Keywords

Syntax

    auto                       extern                    short                      while
    break                      float                     signed                     _Alignas
    case                       for                       sizeof                     _Alignof
    char                       goto                      static                     _Atomic
    const                      if                        struct                     _Bool
    continue                   inline                    switch                     _Complex
    default                    int                       typedef                    _Generic
    do                         long                      union                      _Imaginary
    double                     register                  unsigned                   _Noreturn
    else                       restrict                  void                       _Static_assert
    enum                       return                    volatile                   _Thread_local
  

Semantics

6.4.2 Identifiers

6.4.2.1 General

Syntax

    identifier-nondigit
    identifier identifier-nondigit
    identifier digit
  

identifier-nondigit:

    nondigit
    universal-character-name
    other implementation-defined characters
  

nondigit: one of

    _ a b c d e f g h i j k l m
      n o p q r s t u v w x y z
      A B C D E F G H I J K L M
      N O P Q R S T U V W X Y Z
  

digit: one of

    0 1 2 3 4 5 6 7 8 9
  

Semantics

Implementation limits

Forward references: universal character names (6.4.3), macro replacement (6.10.3).

6.4.2.2 Predefined identifiers

Semantics

    static const char __func__[] = "function-name";
  

appeared, where function-name is the name of the lexically-enclosing function.73)

    #include <stdio.h>
    void myfunc(void)
    {
          printf("%s\n", __func__);
          /* ... */
    }
  

Each time the function is called, it will print to the standard output stream:

    myfunc
  

Forward references: function definitions (6.9.1).

6.4.3 Universal character names

Syntax

    \u hex-quad
    \U hex-quad hex-quad
  

hex-quad:

    hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit
  

Constraints

Description

Semantics

6.4.4 Constants

Syntax

    integer-constant
    floating-constant
    enumeration-constant
    character-constant
  

Constraints

Semantics

6.4.4.1 Integer constants

Syntax

    decimal-constant integer-suffixopt
    octal-constant integer-suffixopt
    hexadecimal-constant integer-suffixopt
  

decimal-constant:

    nonzero-digit
    decimal-constant digit
  

octal-constant:

    0
    octal-constant octal-digit
  

hexadecimal-constant:

    hexadecimal-prefix hexadecimal-digit
    hexadecimal-constant hexadecimal-digit
  

hexadecimal-prefix: one of

    0X 0X
  

nonzero-digit: one of

    1 2 3 4 5 6 7 8 9
  

octal-digit: one of

    0 1 2 3 4 5 6 7
  

hexadecimal-digit: one of

    0 1 2 3 4 5 6 7 8 9
    a b c d e f
    A B C D E F
  

integer-suffix:

    unsigned-suffix long-suffixopt
    unsigned-suffix long-long-suffix
    long-suffix unsigned-suffixopt
    long-long-suffix unsigned-suffixopt
  

unsigned-suffix: one of

    u U
  

long-suffix: one of

    l L
  

long-long-suffix: one of

    ll LL
  

Description

Semantics

                                                       Octal or Hexadecimal
    Suffix                 Decimal Constant            Constant
    none                   int                         int
                           long int                    unsigned int
                           long long int               long int
                                                       unsigned long int
                                                       long long int
                                                       unsigned long long int
     u or U                unsigned int                unsigned int
                           unsigned long int           unsigned long int
                           unsigned long long int      unsigned long long int
     l or L                long int                    long int
                           long long int               unsigned long int
                                                       long long int
                                                       unsigned long long int
    Both u or U            unsigned long int           unsigned long int
    and l or L             unsigned long long int      unsigned long long int
    ll or LL               long long int               long long int
                                                       unsigned long long int
    Both u or U            unsigned long long int      unsigned long long int
    and ll or LL
  

6.4.4.2 Floating constants

Syntax

    decimal-floating-constant
    hexadecimal-floating-constant
  

decimal-floating-constant:

    fractional-constant exponent-partopt floating-suffixopt
    digit-sequence exponent-part floating-suffixopt
  

hexadecimal-floating-constant:

    hexadecimal-prefix hexadecimal-fractional-constant
                       binary-exponent-part floating-suffixopt
    hexadecimal-prefix hexadecimal-digit-sequence
                       binary-exponent-part floating-suffixopt
  

fractional-constant:

    digit-sequenceopt . digit-sequence
    digit-sequence .
  

exponent-part:

    e signopt digit-sequence
    E signopt digit-sequence
  

sign: one of

    + -
  

digit-sequence:

    digit
    digit-sequence digit
  

hexadecimal-fractional-constant:

    hexadecimal-digit-sequenceopt .
                       hexadecimal-digit-sequence
    hexadecimal-digit-sequence .
  

binary-exponent-part:

    p signopt digit-sequence
    P signopt digit-sequence
  

hexadecimal-digit-sequence:

    hexadecimal-digit
    hexadecimal-digit-sequence hexadecimal-digit
  

floating-suffix: one of

    f l F L
  

Description

Semantics

Recommended practice

6.4.4.3 Enumeration constants

Syntax

    identifier
  

Semantics

Forward references: enumeration specifiers (6.7.2.2).

6.4.4.4 Character constants

Syntax

    ’ c-char-sequence ’
      L’ c-char-sequence ’
      u’ c-char-sequence ’
      U’ c-char-sequence ’
  

c-char-sequence:

    c-char
    c-char-sequence c-char
  

c-char:

    any member of the source character set except
                        the single-quote ’, backslash \ , or new-line character
      escape-sequence
  

escape-sequence:

    simple-escape-sequence
    octal-escape-sequence
    hexadecimal-escape-sequence
    universal-character-name
  

simple-escape-sequence: one of

    \’ \" \? \\
    \a \b \f \n \r \t \v
  

octal-escape-sequence:

    \ octal-digit
    \ octal-digit octal-digit
    \ octal-digit octal-digit octal-digit
  

hexadecimal-escape-sequence:

    \x hexadecimal-digit
     hexadecimal-escape-sequence hexadecimal-digit
  

Description

    single quote ’                   \’
    double quote "                   \"
    question mark ?                  \?
    backslash \                      \\
    octal character                  \ octal digits
    hexadecimal character            \x hexadecimal digits
  

Constraints

    Prefix     Corresponding Type
    none       unsigned char
    L          the unsigned type corresponding to wchar_t
    u          char16_t
    U          char32_t
  

Semantics

Forward references: common definitions <stddef.h> (7.19), the mbtowc function (7.22.7.2), Uni-
code utilities <uchar.h> (7.28).

6.4.5 String literals

Syntax

    encoding-prefixopt " s-char-sequenceopt "
  

encoding-prefix:

    u8
    u
    U
    L
  

s-char-sequence:

    s-char
    s-char-sequence s-char
  

s-char:

    any member of the source character set except
                     the double-quote ", backslash \, or new-line character
     escape-sequence
  

Constraints

Description

Semantics

    "\x12" "3"
  

produces a single character string literal containing the two characters whose values are ’\x12’ and ’3’ , because escape
sequences are converted into single members of the execution character set just prior to adjacent string literal concatenation.

    "a" "b" L"c"
    "a" L"b" "c"
    L"a" "b" L"c"
    L"a" L"b" L"c"
  

is equivalent to the string literal

    L"abc"
  

Likewise, each of the sequences

    "a" "b" u"c"
    "a" u"b" "c"
    u"a" "b" u"c"
    u"a" u"b" u"c"
  

is equivalent to

    u"abc"
  

Forward references: common definitions <stddef.h> (7.19), the mbstowcs function (7.22.8.1),
Unicode utilities <uchar.h> (7.28).

6.4.6 Punctuators

Syntax

    [ ] ( ) { } . ->
    ++ -- & * + - ~ !
    / % << >> < > <= >=                       ==     !=    ^    |    &&    ||
    ? : ; ...
    = *= /= %= += -= <<=                      >>=     &=       ^=   |=
    , # ##
    <: :> <% %> %: %:%:
  

Semantics

    <:     :>     <%     %>    %:   %:%:
  

behave, respectively, the same as the six tokens

    [      ]     {      }      #    ##
                         81)
  

except for their spelling.

Forward references: expressions (6.5), declarations (6.7), preprocessing directives (6.10), statements
(6.8).

6.4.7 Header names

Syntax

    < h-char-sequence >
    " q-char-sequence "
  

h-char-sequence:

    h-char
    h-char-sequence h-char
  

h-char:

    any member of the source character set except
                    the new-line character and >
  

q-char-sequence:

    q-char
    q-char-sequence q-char
  

q-char:

    any member of the source character set except
                    the new-line character and "
  

Semantics

    0x3<1/a.h>1e2
    #include <1/a.h>
    #define const.member@$
  

forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited by a { on the left
and a } on the right).

    {0x3}{<}{1}{/}{a}{.}{h}{>}{1e2}
    {#}{include} {<1/a.h>}
    {#}{define} {const}{.}{member}{@}{$}
  

Forward references: source file inclusion (6.10.2).

6.4.8 Preprocessing numbers

Syntax

    digit
    . digit
    pp-number digit
    pp-number identifier-nondigit
    pp-number e sign
    pp-number E sign
    pp-number p sign
    pp-number P sign
    pp-number .
  

Description

Semantics

6.4.9 Comments

    "a//b"                                  // four-character string literal
    #include "//e"                          // undefined behavior
    // */                                   // comment, not syntax error
    f = g/**//h;                            // equivalent to f = g / h;
    //\
    i();                                    // part of a two-line comment
    /\
    / j();                                  // part of a two-line comment
    #define glue(x,y) x##y
    glue(/,/) k();                          // syntax error, not comment
    /*//*/ l();                             // equivalent to l();
    m = n//**/o
      + p;                                  // equivalent to m = n + p;
  

      * . . . */ comments do not nest.
    

6.5 Expressions

• a type compatible with the effective type of the object,
• a qualified version of a type compatible with the effective type of the object,
• a type that is the signed or unsigned type corresponding to the effective type of the object,
• a type that is the signed or unsigned type corresponding to a qualified version of the effective
  type of the object,
• an aggregate or union type that includes one of the aforementioned types among its members
  (including, recursively, a member of a subaggregate or contained union), or
• a character type.

Forward references: the FP_CONTRACT pragma (7.12.2), copying functions (7.24.2).

      i = ++i + 1;
      a[i++] = i;
    

      i = i + 1;
      a[i] = i;
    

6.5.1 Primary expressions

Syntax

    identifier
    constant
    string-literal
    ( expression )
    generic-selection
  

Semantics

Forward references: declarations (6.7).

6.5.1.1 Generic selection

Syntax

    _Generic ( assignment-expression , generic-assoc-list )
  

generic-assoc-list:

    generic-association
    generic-assoc-list , generic-association
  

generic-association:

    type-name : assignment-expression
    default : assignment-expression
  

Constraints

Semantics

    #define cbrt(X) _Generic((X),                              \
                            long double: cbrtl,                \
                            default: cbrt,                     \
                            float: cbrtf                       \
                            )(X)
  

6.5.2 Postfix operators

Syntax

    primary-expression
    postfix-expression [ expression ]
    postfix-expression ( argument-expression-listopt )
    postfix-expression . identifier
    postfix-expression -> identifier
    postfix-expression ++
    postfix-expression -
    ( type-name ) { initializer-list }
    ( type-name ) { initializer-list , }
  

argument-expression-list:

    assignment-expression
    argument-expression-list , assignment-expression
  

6.5.2.1 Array subscripting

Constraints

Semantics

    int x[3][5];
  

Here x
is a 3 × 5 array of
int s; more precisely, x is an array of three element objects, each of which is an array of five int s. In the expression x[i],
which is equivalent to (*((x)+(i))) , x is first converted to a pointer to the initial array of five int s. Then i is adjusted
according to the type of x, which conceptually entails multiplying i by the size of the object to which the pointer points,
namely an array of five int objects. The results are added and indirection is applied to yield an array of five int s. When
used in the expression x[i][j], that array is in turn converted to a pointer to the first of the int s, so x[i][j] yields an int.

Forward references: additive operators (6.5.6), address and indirection operators (6.5.3.2), array
declarators (6.7.6.2).

6.5.2.2 Function calls

Constraints

Semantics

• one promoted type is a signed integer type, the other promoted type is the corresponding
  unsigned integer type, and the value is representable in both types;
• both types are pointers to qualified or unqualified versions of a character type or void.

    (*pf[f1()]) (f2(), f3() + f4())
  

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) (6.7.6.3), function definitions
(6.9.1), the return statement (6.8.6.4), simple assignment (6.5.16.1).

6.5.2.3 Structure and union members

Constraints

Semantics

    struct s { int i; const int ci; };
    struct s s;
    const struct s cs;
    volatile struct s vs;
  

the various members have the types:
s.i int
s.ci const int
cs.i const int
cs.ci const int
vs.i volatile int
vs.ci volatile const int

    union {
          struct {
                int    alltypes;
          } n;
          struct {
                int    type;
                int    intnode;
          } ni;
          struct {
                int    type;
                double doublenode;
          } nf;
    } u;
    u.nf.type = 1;
    u.nf.doublenode = 3.14;
    /* ... */
    if (u.n.alltypes == 1)
          if (sin(u.nf.doublenode) == 0.0)
                /* ... */
  

The following is not a valid fragment (because the union type is not visible within function f):

    struct t1 { int m; };
    struct t2 { int m; };
    int f(struct t1 *p1, struct t2 *p2)
    {
          if (p1->m < 0)
                p2->m = -p2->m;
          return p1->m;
    }
    int g()
    {
          union {
                struct t1 s1;
                struct t2 s2;
           } u;
           /* ... */
           return f(&u.s1, &u.s2);
    }
  

Forward references: address and indirection operators (6.5.3.2), structure and union specifiers
(6.7.2.1).

6.5.2.4 Postfix increment and decrement operators

Constraints

Semantics

Forward references: additive operators (6.5.6), compound assignment (6.5.16.2).

      T *addr = &E;
      T old = *addr;
      T new;
      do {
            new = old + 1;
      } while (!atomic_compare_exchange_strong(addr, &old, new));
    

6.5.2.5 Compound literals

Constraints

Semantics

    int *p = (int []){2, 4};
  

initializes p to point to the first element of an array of two ints, the first having the value two and the second, four. The
expressions in this compound literal are required to be constant. The unnamed object has static storage duration.

    void f(void)
    {
          int *p;
          /*...*/
          p = (int [2]){*p};
          /*...*/
    }
  

p is assigned the address of the first element of an array of two ints, the first having the value previously pointed to by p and
the second, zero. The expressions in this compound literal need not be constant. The unnamed object has automatic storage
duration.

    drawline((struct point){.x=1, .y=1},
          (struct point){.x=3, .y=4});
  

Or, if drawline instead expected pointers to struct point:

    drawline(&(struct point){.x=1, .y=1},
          &(struct point){.x=3, .y=4});
  

    (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}
  

    "/tmp/fileXXXXXX"
    (char []){"/tmp/fileXXXXXX"}
    (const char []){"/tmp/fileXXXXXX"}
  

The first always has static storage duration and has type array of char, but need not be modifiable; the last two have
automatic storage duration when they occur within the body of a function, and the first of these two is modifiable.

    (const char []){"abc"} == "abc"
  

might yield 1 if the literals’ storage is shared.

    struct int_list { int car; struct int_list *cdr; };
    struct int_list endless_zeros = {0, &endless_zeros};
    eval(endless_zeros);
  

    struct s { int i; };
  

    int f (void)
    {
          struct s *p = 0, *q;
          int j = 0;
  

    again:
          q = p, p = &((struct s){ j++ });
          if (j < 2) goto again;
  

           return p == q && q->i == 1;
    }
  

The function f() always returns the value 1.

Forward references: type names (6.7.7), initialization (6.7.9).

6.5.3 Unary operators

Syntax

    postfix-expression
    ++ unary-expression
    - unary-expression
    unary-operator cast-expression
    sizeof unary-expression
    sizeof ( type-name )
    _Alignof ( type-name )
  

unary-operator: one of

    &    *   +    - ˜ !
  

6.5.3.1 Prefix increment and decrement operators

Constraints

Semantics

Forward references: additive operators (6.5.6), compound assignment (6.5.16.2).

6.5.3.2 Address and indirection operators

Constraints

Semantics

Forward references: storage-class specifiers (6.7.1), structure and union specifiers (6.7.2.1).

      *
    

6.5.3.3 Unary arithmetic operators

Constraints

Semantics

6.5.3.4 The sizeof and _Alignof operators

Constraints

Semantics

    extern void *alloc(size_t);
    double *dp = alloc(sizeof *dp);
  

The implementation of the alloc function should ensure that its return value is aligned suitably for conversion to a pointer
to double.

    sizeof array / sizeof array[0]
  

    #include <stddef.h>
  

    size_t fsize3(int n)
    {
          char b[n+3];                  // variable length array
          return sizeof b;              // execution time sizeof
    }
  

    int main()
    {
          size_t size;
          size = fsize3(10); // fsize3 returns 13
          return 0;
    }
  

Forward references: common definitions <stddef.h> (7.19), declarations (6.7), structure and union
specifiers (6.7.2.1), type names (6.7.7), array declarators (6.7.6.2).

6.5.4 Cast operators

Syntax

    unary-expression
    ( type-name ) cast-expression
  

Constraints

Semantics

Forward references: equality operators (6.5.9), function declarators (including prototypes) (6.7.6.3),
simple assignment (6.5.16.1), type names (6.7.7).

6.5.5 Multiplicative operators

Syntax

    cast-expression
    multiplicative-expression * cast-expression
    multiplicative-expression / cast-expression
    multiplicative-expression % cast-expression
  

Constraints

Semantics

6.5.6 Additive operators

Syntax

    multiplicative-expression
    additive-expression + multiplicative-expression
    additive-expression - multiplicative-expression
  

Constraints

• both operands have arithmetic type;
• both operands are pointers to qualified or unqualified versions of compatible complete object
  types; or
• the left operand is a pointer to a complete object type and the right operand has integer type.

(Decrementing is equivalent to subtracting 1.)

Semantics

    {
            int n = 4, m = 3;
            int a[n][m];
            int (*p)[m] = a; // p == &a[0]
            p += 1;           // p == &a[1]
            (*p)[2] = 99;     // a[1][2] == 99
            n = p - a;        // n == 1
    }
  

Forward references: array declarators (6.7.6.2), common definitions <stddef.h> (7.19).

6.5.7 Bitwise shift operators

Syntax

    additive-expression
    shift-expression « additive-expression
    shift-expression » additive-expression
  

Constraints

Semantics

6.5.8 Relational operators

Syntax

    shift-expression
    relational-expression < shift-expression
    relational-expression > shift-expression
    relational-expression <= shift-expression
    relational-expression >= shift-expression
  

Constraints

• both operands have real type; or
• both operands are pointers to qualified or unqualified versions of compatible object types.

Semantics

6.5.9 Equality operators

Syntax

    relational-expression
    equality-expression == relational-expression
    equality-expression != relational-expression
  

Constraints

• both operands have arithmetic type;
• both operands are pointers to qualified or unqualified versions of compatible types;
• one operand is a pointer to an object type and the other is a pointer to a qualified or unqualified
  version of void; or
• one operand is a pointer and the other is a null pointer constant.

Semantics

6.5.10 Bitwise AND operator

Syntax

    equality-expression
    AND-expression & equality-expression
  

Constraints

Semantics

6.5.11 Bitwise exclusive OR operator

Syntax

    AND-expression
    exclusive-OR-expression ^ AND-expression
  

Constraints

Semantics

6.5.12 Bitwise inclusive OR operator

Syntax

    exclusive-OR-expression
    inclusive-OR-expression | exclusive-OR-expression
  

Constraints

Semantics

6.5.13 Logical AND operator

Syntax

    inclusive-OR-expression
    logical-AND-expression && inclusive-OR-expression
  

Constraints

Semantics

6.5.14 Logical OR operator

Syntax

    logical-AND-expression
    logical-OR-expression || logical-AND-expression
  

Constraints

Semantics

6.5.15 Conditional operator

Syntax

    logical-OR-expression
    logical-OR-expression ? expression : conditional-expression
  

Constraints

• both operands have arithmetic type;
• both operands have the same structure or union type;
• both operands have void type;
• both operands are pointers to qualified or unqualified versions of compatible types;
• one operand is a pointer and the other is a null pointer constant; or
• one operand is a pointer to an object type and the other is a pointer to a qualified or unqualified
  version of void.

Semantics

    const void *c_vp;
    void *vp;
    const int *c_ip;
    volatile int *v_ip;
    int *ip;
    const char *c_cp;
  

the third column in the following table is the common type that is the result of a conditional expression in which the first two
columns are the second and third operands (in either order):
c_vp c_ip const void *
v_ip 0 volatile int *
c_ip v_ip const volatile int *
vp c_cp const void *
ip c_ip const int *
vp ip void *

6.5.16 Assignment operators

Syntax

    conditional-expression
    unary-expression assignment-operator assignment-expression
  

assignment-operator: one of

    =    *=    /=     %=    +=    -=     <<=     >>=     &=     ^=    |=
  

Constraints

Semantics

6.5.16.1 Simple assignment

Constraints

• the left operand has atomic, qualified, or unqualified arithmetic type, and the right has
  arithmetic type;
• the left operand has an atomic, qualified, or unqualified version of a structure or union type
  compatible with the type of the right;
• the left operand has atomic, qualified, or unqualified pointer type, and (considering the type
  the left operand would have after lvalue conversion) both operands are pointers to qualified
  or unqualified versions of compatible types, and the type pointed to by the left has all the
  qualifiers of the type pointed to by the right;
• the left operand has atomic, qualified, or unqualified pointer type, and (considering the type
  the left operand would have after lvalue conversion) one operand is a pointer to an object type,
  and the other is a pointer to a qualified or unqualified version of void, and the type pointed to
  by the left has all the qualifiers of the type pointed to by the right;
• the left operand is an atomic, qualified, or unqualified pointer, and the right is a null pointer
  constant; or
• the left operand has type atomic, qualified, or unqualified _Bool , and the right is a pointer.

Semantics

    int f(void);
    char c;
    /* ... */
    if ((c = f()) == -1)
          /* ... */
  

the int value returned by the function may be truncated when stored in the char, and then converted back to int width
prior to the comparison. In an implementation in which “plain” char has the same range of values as unsigned char (and
char is narrower than int), the result of the conversion cannot be negative, so the operands of the comparison can never
compare equal. Therefore, for full portability, the variable c should be declared as int.

    char c;
    int i;
    long l;
  

    l = (c = i);
  

the value of i is converted to the type of the assignment expression c = i, that is, char type. The value of the expression
enclosed in parentheses is then converted to the type of the outer assignment expression, that is, long int type.

    const char **cpp;
    char *p;
    const char c = ’A’;
  

    cpp = &p;              // constraint violation
    *cpp = &c;             // valid
    *p = 0;                // valid
  

The first assignment is unsafe because it would allow the following valid code to attempt to change the value of the const
object c.

6.5.16.2 Compound assignment

Constraints

Semantics

      T1 *addr = &E1;
      T2 val = (E2);
      T1 old = *addr;
      T1 new;
      do {
            new = old op val;
      } while (!atomic_compare_exchange_strong(addr, &old, new));
    

      #include <fenv.h>
      #pragma STDC FENV_ACCESS ON
      /* ... */
            fenv_t fenv;
            T1 *addr = &E1;
            T2 val = E2;
            T1 old = *addr;
            T1 new;
            feholdexcept(&fenv);
    

6.5.17 Comma operator

Syntax

    assignment-expression
    expression , assignment-expression
  

Semantics

    f(a, (t=3, t+2), c)
  

the function has three arguments, the second of which has the value 5.

Forward references: initialization (6.7.9).

    for (;;) {
          new = old op val;
          if (atomic_compare_exchange_strong(addr, &old, new))
                      break;
          feclearexcept(FE_ALL_EXCEPT);
    }
    feupdateenv(&fenv);
  

If FLT_EVAL_METHOD is not 0, then T2 must be a type with the range and precision to which E2 is evaluated in order to satisfy
the equivalence.

6.6 Constant expressions

Syntax

    conditional-expression
  

Description

Constraints

Semantics

• an arithmetic constant expression,
• a null pointer constant,
• an address constant, or
• an address constant for a complete object type plus or minus an integer constant expression.

Forward references: array declarators (6.7.6.2), initialization (6.7.9).

      static int i = 2 || 1 / 0;
    

6.7 Declarations

Syntax

    declaration-specifiers init-declarator-listopt ;
    static_assert-declaration
  

declaration-specifiers:

    storage-class-specifier declaration-specifiersopt
    type-specifier declaration-specifiersopt
    type-qualifier declaration-specifiersopt
    function-specifier declaration-specifiersopt
    alignment-specifier declaration-specifiersopt
  

init-declarator-list:

    init-declarator
    init-declarator-list , init-declarator
  

init-declarator:

    declarator
    declarator = initializer
  

Constraints

• a typedef name may be redefined to denote the same type as it currently does, provided that
  type is not a variably modified type;
• tags may be redeclared as specified in 6.7.2.3.

Semantics

• for an object, causes storage to be reserved for that object;
• for a function, includes the function body;121)
• for an enumeration constant, is the (only) declaration of the identifier;
• for a typedef name, is the first (or only) declaration of the identifier.

Forward references: declarators (6.7.6), enumeration specifiers (6.7.2.2), initialization (6.7.9), type
names (6.7.7), type qualifiers (6.7.3).

6.7.1 Storage-class specifiers

Syntax

    typedef
    extern
    static
    _Thread_local
    auto
    register
  

Constraints

Semantics

Forward references: type definitions (6.7.8).

6.7.2 Type specifiers

Syntax

    void
    char
    short
    int
    long
    float
    double
    signed
    unsigned
    _Bool
    _Complex
    atomic-type-specifier
    struct-or-union-specifier
    enum-specifier
    typedef-name
  

Constraints

• void
• char
• signed char
• unsigned char
• short, signed short, short int, or signed short int
• unsigned short, or unsigned short int
• int, signed, or signed int
• unsigned, or unsigned int
• long, signed long, long int, or signed long int
• unsigned long, or unsigned long int
• long long, signed long long, long long int, or signed long long int
• unsigned long long, or unsigned long long int
• float
• double
• long double
• _Bool
• float _Complex
• double _Complex
• long double _Complex
• atomic type specifier
• struct or union specifier
• enum specifier
• typedef name

Semantics

Forward references: atomic type specifiers (6.7.2.4), enumeration specifiers (6.7.2.2), structure and
union specifiers (6.7.2.1), tags (6.7.2.3), type definitions (6.7.8).

6.7.2.1 Structure and union specifiers

Syntax

    struct-or-union identifieropt { struct-declaration-list }
    struct-or-union identifier
  

struct-or-union:

    struct
    union
  

struct-declaration-list:

    struct-declaration
    struct-declaration-list struct-declaration
  

struct-declaration:

    specifier-qualifier-list struct-declarator-listopt ;
    static_assert-declaration
  

specifier-qualifier-list:

    type-specifier specifier-qualifier-listopt
    type-qualifier specifier-qualifier-listopt
    alignment-specifier specifier-qualifier-listopt
  

struct-declarator-list:

    struct-declarator
    struct-declarator-list , struct-declarator
  

struct-declarator:

    declarator
    declaratoropt : constant-expression
  

Constraints

Semantics

    struct v {
          union {     // anonymous union
                struct { int i, j; };   // anonymous structure
                struct { long k, l; } w;
          };
          int m;
    } v1;
  

    v1.i = 2;   // valid
    v1.k = 3;   // invalid:          inner structure is not anonymous
    v1.w.k = 5; // valid
  

    struct s { int n; double d[]; };
  

the structure struct s has a flexible array member d. A typical way to use this is:

    int m = /* some value */;
    struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));
  

and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if p had been
declared as:

    struct { int n; double d[m]; } *p;
  

(there are circumstances in which this equivalence is broken; in particular, the offsets of member d might not be the same).

    struct s t1 = { 0 };                    // valid
    struct s t2 = { 1, { 4.2 }};            // invalid
    t1.n = 4;                               // valid
    t1.d[0] = 4.2;                          // might be undefined behavior
  

The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not contain member d.
The assignment to t1.d[0] is probably undefined behavior, but it is possible that

    sizeof (struct s) >= offsetof(struct s, d) + sizeof (double)
  

in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming code.

    struct ss { int n; };
  

the expressions:

    sizeof (struct s) >= sizeof (struct ss)
    sizeof (struct s) >= offsetof(struct s, d)
  

are always equal to 1.

    struct s *s1;
    struct s *s2;
    s1 = malloc(sizeof (struct s) + 64);
    s2 = malloc(sizeof (struct s) + 46);
  

and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most purposes, as if the
identifiers had been declared as:

    struct { int n; double d[8]; } *s1;
    struct { int n; double d[5]; } *s2;
  

    s1 = malloc(sizeof (struct s) + 10);
    s2 = malloc(sizeof (struct s) + 6);
  

they then behave as if the declarations were:

    struct { int n; double d[1]; } *s1, *s2;
  

and:

    double *dp;
    dp = &(s1->d[0]); // valid
    *dp = 42;         // valid
    dp = &(s2->d[0]); // valid
    *dp = 42;         // undefined behavior
  

    *s1 = *s2;
  

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.

    struct s {
          struct { int i; };
          int a[];
    };
  

Forward references: declarators (6.7.6), tags (6.7.2.3).

6.7.2.2 Enumeration specifiers

Syntax

    enum identifieropt { enumerator-list }
    enum identifieropt { enumerator-list , }
    enum identifier
  

enumerator-list:

    enumerator
    enumerator-list , enumerator
  

enumerator:

    enumeration-constant
    enumeration-constant = constant-expression
  

Constraints

Semantics

    enum hue { chartreuse, burgundy, claret=20, winedark };
    enum hue col, *cp;
    col = claret;
    cp = &col;
    if (*cp != burgundy)
          /* ... */
  

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 (6.7.2.3).

6.7.2.3 Tags

Constraints

    enum identifier
  

without an enumerator list shall only appear after the type it specifies is complete.

Semantics

    struct-or-union identifieropt { struct-declaration-list }
  

or

    enum identifieropt { enumerator-list }
  

or

    enum identifieropt { enumerator-list , }
  

declares a structure, union, or enumerated type. The list defines the structure content, union content,
or enumeration content. If an identifier is provided,132) the type specifier also declares the identifier to
be the tag of that type.

    struct-or-union identifier ;
  

specifies a structure or union type and declares the identifier as a tag of that type.133)

    struct-or-union identifier
  

occurs other than as part of one of the above forms, and no other declaration of the identifier as a
tag is visible, then it declares an incomplete structure or union type, and declares the identifier as
the tag of that type.133)

    struct-or-union identifier
  

or

    enum identifier
  

occurs other than as part of one of the above forms, and a declaration of the identifier as a tag is
visible, then it specifies the same type as that other declaration, and does not redeclare the tag.

    struct tnode {
          int count;
          struct tnode *left, *right;
    };
  

specifies a structure that contains an integer and two pointers to objects of the same type. Once this declaration has been
given, the declaration

    struct tnode s, *sp;
  

declares s to be an object of the given type and sp to be a pointer to an object of the given type. With these declarations, the
expression sp->left refers to the left struct tnode pointer of the object to which sp points; the expression s.right->count
designates the count member of the right struct tnode pointed to from s.

    typedef struct tnode TNODE;
    struct tnode {
          int count;
          TNODE *left, *right;
    };
    TNODE s, *sp;
  

    struct s1 { struct s2 *s2p; /* ... */ }; // D1
    struct s2 { struct s1 *s1p; /* ... */ }; // D2
  

specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already declared as a tag in an
enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in D2. To eliminate this context sensitivity, the
declaration

    struct s2;
  

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 (6.7.6), type definitions (6.7.8).

6.7.2.4 Atomic type specifiers

Syntax

    _Atomic ( type-name )
  

Constraints

Semantics

6.7.3 Type qualifiers

Syntax

    const
    restrict
    volatile
    _Atomic
  

Constraints

Semantics

    extern const volatile int real_time_clock;
  

may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.

    const struct s { int mem; } cs = { 1 };
    struct s ncs; // the object ncs is modifiable
    typedef int A[2][3];
    const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
    int *pi;
    const int *pci;
  

    ncs = cs;      // valid
    cs = ncs;      // violates modifiable lvalue constraint for =
    pi = &ncs.mem; // valid
    pi = &cs.mem; // violates type constraints for =
    pci = &cs.mem; // valid
    pi = a[0];     // invalid: a[0] has type “const int *”
  

    _Atomic volatile int *p;
  

specifies that p has the type “pointer to volatile atomic int”, a pointer to a volatile-qualified atomic type.

6.7.3.1 Formal definition of restrict

    int * restrict a;
    int * restrict b;
    extern int c[];
  

assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the program, then it is never
accessed using either of the other two.

    void f(int n, int * restrict p, int * restrict q)
    {
          while (n-- > 0)
                *p++ = *q++;
    }
  

assert that, during each execution of the function, if an object is accessed through one of the pointer parameters, then it is not
also accessed through the other.

    void g(void)
    {
          extern int d[100];
          f(50, d + 50, d); // valid
          f(50, d + 1, d); // undefined behavior
    }
  

    void h(int n, int * restrict p, int * restrict q, int * restrict r)
    {
          int i;
          for (i = 0; i < n; i++)
                p[i] = q[i] + r[i];
    }
  

illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b are disjoint arrays,
a call of the form h(100, a, b, b) has defined behavior, because array b is not modified within function h.

    {
             int * restrict p1;
             int * restrict q1;
             p1 = q1; // undefined behavior
             {
                   int * restrict p2 = p1; // valid
                   int * restrict q2 = q1; // valid
                   p1 = q2;                // undefined behavior
                   p2 = q2;                // undefined behavior
             }
    }
  

    typedef struct { int n; float * restrict v; } vector;
    vector new_vector(int n)
    {
          vector t;
          t.n = n;
          t.v = malloc(n * sizeof (float));
          return t;
    }
  

6.7.4 Function specifiers

Syntax

    inline
    _Noreturn
  

Constraints

Semantics

Recommended practice

    inline double fahr(double t)
    {
          return (9.0 * t) / 5.0 + 32.0;
    }
  

    inline double cels(double t)
    {
          return (5.0 * (t - 32.0)) / 9.0;
    }
  

    extern double fahr(double);                // creates an external definition
  

    double convert(int is_fahr, double temp)
    {
          /* A translator may perform inline substitutions */
          return is_fahr ? cels(temp): fahr(temp);
    }
  

    _Noreturn void f () {
          abort(); // ok
    }
  

    _Noreturn void g (int i) { // causes undefined behavior if i <= 0
          if (i > 0) abort();
    }
  

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.

Forward references: function definitions (6.9.1).

6.7.5 Alignment specifier

Syntax

    _Alignas ( type-name )
    _Alignas ( constant-expression )
  

Constraints

Semantics

6.7.6 Declarators

Syntax

    pointeropt direct-declarator
  

direct-declarator:

    identifier
    ( declarator )
    direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
    direct-declarator [ static type-qualifier-listopt assignment-expression ]
    direct-declarator [ type-qualifier-list static assignment-expression ]
    direct-declarator [ type-qualifier-listopt * ]
    direct-declarator ( parameter-type-list )
    direct-declarator ( identifier-listopt )
  

pointer:

    * type-qualifier-listopt
    * type-qualifier-listopt pointer
  

type-qualifier-list:

    type-qualifier
    type-qualifier-list type-qualifier
  

parameter-type-list:

    parameter-list
    parameter-list , ...
  

parameter-list:

    parameter-declaration
    parameter-list , parameter-declaration
  

parameter-declaration:

    declaration-specifiers declarator
    declaration-specifiers abstract-declaratoropt
  

identifier-list:

    identifier
    identifier-list , identifier
  

Semantics

    T D1
  

where T contains the declaration specifiers that specify a type T (such as int) and D1 is a declarator
that contains an identifier ident. The type specified for the identifier ident in the various forms of
declarator is described inductively using this notation.

    identifier
  

then the type specified for ident is T.

    (D )
  

then ident has the type specified by the declaration “T D”. Thus, a declarator in parentheses is
identical to the unparenthesized declarator, but the binding of complicated declarators may be
altered by parentheses.

Implementation limits

Forward references: array declarators (6.7.6.2), type definitions (6.7.8).

6.7.6.1 Pointer declarators

Semantics

    * type-qualifier-listopt D
  

and the type specified for ident in the declaration “T D” is “derived-declarator-type-list T”, then the
type specified for ident is “derived-declarator-type-list type-qualifier-list pointer to T”. For each type
qualifier in the list, ident is a so-qualified pointer.

    const int *ptr_to_constant;
    int *const constant_ptr;
  

The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer, but ptr_to_constant
itself may be changed to point to another object. Similarly, the contents of the int pointed to by constant_ptr may be
modified, but constant_ptr itself shall always point to the same location.

    typedef int *int_ptr;
    const int_ptr constant_ptr;
  

declares constant_ptr as an object that has type “const-qualified pointer to int”.

6.7.6.2 Array declarators

Constraints

Semantics

    D [    type-qualifier-listopt assignment-expressionopt ]
    D [    type-qualifier-listopt assignment-expression ]
    D [    type-qualifier-list static assignment-expression                    ]
    D [    type-qualifier-listopt ]
  

and the type specified for ident in the declaration “T D” is “derived-declarator-type-list T”, then the
type specified for ident is “derived-declarator-type-list array of T”.144) (See 6.7.6.3 for the meaning of
the optional type qualifiers and the keyword static.)

    float fa[11], *afp[17];
  

declares an array of float numbers and an array of pointers to float numbers.

    extern int *x;
    extern int y[];
  

The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size (an incomplete type),
the storage for which is defined elsewhere.

    extern int n;
    extern int m;
  

    void fcompat(void)
    {
          int a[n][6][m];
          int (*p)[4][n+1];
          int c[n][n][6][m];
          int (*r)[n][n][n+1];
          p = a;      // invalid: not compatible because 4 != 6
          r = c;      // compatible, but defined behavior only if
                      // n == 6 and m == n+1
    }
  

    extern int n;
    int A[n];                                          // invalid: file scope VLA
    extern int (*p2)[n];                               // invalid: file scope VM
    int B[100];                                        // valid: file scope but not VM
  

    void fvla(int m, int C[m][m]);                     // valid:       VLA with prototype scope
  

    void fvla(int m, int C[m][m])                      // valid:       adjusted to auto pointer to VLA
    {
          typedef int VLA[m][m];                       // valid:       block scope typedef VLA
  

    struct tag {
          int (*y)[n];                          // invalid:        y not ordinary identifier
          int z[n];                             // invalid:        z not ordinary identifier
    };
    int D[m];                                   // valid: auto VLA
    static int E[m];                            // invalid: static block scope VLA
    extern int F[m];                            // invalid: F has linkage and is VLA
    int (*s)[m];                                // valid: auto pointer to VLA
    extern int (*r)[m];                         // invalid: r has linkage and points to VLA
    static int (*q)[m] = &B;                    // valid: q is a static block pointer to VLA
    }
  

Forward references: function declarators (6.7.6.3), function definitions (6.9.1), initialization (6.7.9).

6.7.6.3 Function declarators (including prototypes)

Constraints

Semantics

    D ( parameter-type-list )
  

or

    D ( identifier-listopt )
  

and the type specified for ident in the declaration “T D” is “derived-declarator-type-list T”, then the
type specified for ident is “derived-declarator-type-list function returning the unqualified version of T”.

    int f(void), *fip(), (*pfi)();
  

declares a function f with no parameters returning an int, a function fip with no parameter specification returning a pointer
to an int, and a pointer pfi to a function with no parameter specification returning an int. It is especially useful to compare
the last two. The binding of *fip() is *(fip()) , so that the declaration suggests, and the same construction in an expression
requires, the calling of a function fip, and then using indirection through the pointer result to yield an int. In the declarator
(*pfi)() , the extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
designator, which is then used to call the function; it returns an int.

    int (*apfi[3])(int *x, int *y);
  

declares an array apfi of three pointers to functions returning int. Each of these functions has two parameters that are
pointers to int. The identifiers x and y are declared for descriptive purposes only and go out of scope at the end of the
declaration of apfi.

    int (*fpfi(int (*)(long), int))(int, ...);
  

declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two parameters: a
pointer to a function returning an int (with one parameter of type long int), and an int. The pointer returned by fpfi
points to a function that has one int parameter and accepts zero or more additional arguments of any type.

    void addscalar(int n, int m,
          double a[n][n*m+300], double x);
  

    int main()
    {
          double b[4][308];
          addscalar(4, 2, b, 2.17);
          return 0;
    }
  

    void addscalar(int n, int m,
          double a[n][n*m+300], double x)
    {
          for (int i = 0; i < n; i++)
                for (int j = 0, k = n*m+300; j < k; j++)
                      // a is a pointer to a VLA with n*m+300 elements
                      a[i][j] += x;
    }
  

    double maximum(int n, int m, double a[n][m]);
    double maximum(int n, int m, double a[*][*]);
    double maximum(int n, int m, double a[ ][*]);
    double maximum(int n, int m, double a[ ][m]);
  

as are:

    void f(double (* restrict a)[5]);
    void f(double a[restrict][5]);
    void f(double a[restrict 3][5]);
    void f(double a[restrict static 3][5]);
  

(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 (6.9.1), type names (6.7.7).

6.7.7 Type names

Syntax

    specifier-qualifier-list abstract-declaratoropt
  

abstract-declarator:

    pointer
    pointeropt direct-abstract-declarator
  

direct-abstract-declarator:

    ( abstract-declarator )
    direct-abstract-declaratoropt [ type-qualifier-listopt
                          assignment-expressionopt ]
    direct-abstract-declaratoropt [ static type-qualifier-listopt
                          assignment-expression ]
    direct-abstract-declaratoropt [ type-qualifier-list static
                          assignment-expression ]
    direct-abstract-declaratoropt [ * ]
    direct-abstract-declaratoropt ( parameter-type-listopt )
  

Semantics

    (a)           int
    (b)           int *
    (c)           int *[3]
    (d)           int (*)[3]
    (e)           int (*)[*]
    (f)           int *()
    (g)           int (*)(void)
    (h)           int (*const [])(unsigned int, ...)
  

name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an array of three int s,
(e) pointer to a variable length array of an unspecified number of int s, (f) function with no parameter specification returning
a pointer to int, (g) pointer to function with no parameters returning an int, and (h) array of an unspecified number of
constant pointers to functions, each with one parameter that has type unsigned int and an unspecified number of other
parameters, returning an int.

6.7.8 Type definitions

Syntax

    identifier
  

Constraints

Semantics

    typedef T type_ident;
    type_ident D;
  

type_ident is defined as a typedef name with the type specified by the declaration specifiers in T
(known as T), and the identifier in D has the type “derived-declarator-type-list T” where the derived-
declarator-type-list is specified by the declarators of D. A typedef name shares the same name space
as other identifiers declared in ordinary declarators.

    typedef int MILES, KLICKSP();
    typedef struct { double hi, lo; } range;
  

the constructions

    MILES distance;
    extern KLICKSP *metricp;
    range x;
    range z, *zp;
  

are all valid declarations. The type of distance is int, that of metricp is “pointer to function with no parameter specification
returning int”, and that of x and z is the specified structure; zp is a pointer to such a structure. The object distance has a
type compatible with any other int object.

    typedef struct s1 { int x; } t1, *tp1;
    typedef struct s2 { int x; } t2, *tp2;
  

type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct s1, but not compatible
with the types struct s2, t2, the type pointed to by tp2, or int.

    typedef signed int t;
    typedef int plain;
    struct tag {
          unsigned t:4;
          const t:5;
          plain r:5;
    };
  

declare a typedef name t with type signed int, a typedef name plain with type int, and a structure with three bit-field
members, one named t that contains values in the range [0, 15], an unnamed const-qualified bit-field which (if it could
be accessed) would contain values in either the range [−15, +15] or [−16, +15], and one named r that contains values in
one of the ranges [0, 31], [−15, +15], or [−16, +15]. (The choice of range is implementation-defined.) The first two bit-field
declarations differ in that unsigned is a type specifier (which forces t to be the name of a structure member), while const is
a type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed in an inner scope
by

    t f(t (t));
    long t;
  

then a function f is declared with type “function returning signed int with one unnamed parameter with type pointer
to function returning signed int with one unnamed parameter with type signed int”, and an identifier t with type
long int.

    typedef void fv(int), (*pfv)(int);
  

    void (*signal(int, void (*)(int)))(int);
    fv *signal(int, fv *);
    pfv signal(int, pfv);
  

    void copyt(int n)
    {
          typedef int B[n];   // B is n ints, n evaluated now
          n += 1;
          B a;                // a is n ints, n without += 1
          int b[n];           // a and b are different sizes
          for (int i = 1; i < n; i++)
                a[i-1] = b[i];
    }
  

6.7.9 Initialization

Syntax

    assignment-expression
    { initializer-list }
    { initializer-list , }
  

initializer-list:

    designationopt initializer
    initializer-list , designationopt initializer
  

designation:

    designator-list =
  

designator-list:

    designator
    designator-list designator
  

designator:

    [ constant-expression ]
    . identifier
  

Constraints

    [ constant-expression ]
  

then the current object (defined below) shall have array type and the expression shall be an integer
constant expression. If the array is of unknown size, any nonnegative value is valid.

    . identifier
  

then the current object (defined below) shall have structure or union type and the identifier shall be
the name of a member of that type.

Semantics

• if it has pointer type, it is initialized to a null pointer;
• if it has arithmetic type, it is initialized to (positive or unsigned) zero;
• if it is an aggregate, every member is initialized (recursively) according to these rules, and any
  padding is initialized to zero bits;
• if it is a union, the first named member is initialized (recursively) according to these rules, and
  any padding is initialized to zero bits;

    int i = 3.5;
    double complex c = 5 + 3 * I;
  

define and initialize i with the value 3 and c with the value 5.0 + i3.0.

    int x[] = { 1, 3, 5 };
  

defines and initializes x as a one-dimensional array object that has three elements, as no size was specified and there are three
initializers.

    int y[4][3] = {
          { 1, 3, 5 },
          { 2, 4, 6 },
             { 3, 5, 7 },
    };
  

is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object y[0]), namely
y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and y[2]. The initializer ends early, so y[3] is
initialized with zeros. Precisely the same effect could have been achieved by

    int y[4][3] = {
          1, 3, 5, 2, 4, 6, 3, 5, 7
    };
  

The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the next three are
taken successively for y[1] and y[2].

    int z[4][3] = {
          { 1 }, { 2 }, { 3 }, { 4 }
    };
  

initializes the first column of z as specified and initializes the rest with zeros.

    struct { int a[3], b; } w[] = { { 1 }, 2 };
  

is a definition with an inconsistently bracketed initialization. It defines an array with two element structures: w[0].a[0] is 1
and w[1].a[0] is 2; all the other elements are zero.

    short q[4][3][2] = {
          { 1 },
          { 2, 3 },
          { 4, 5, 6 }
    };
  

contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array object: q[0][0][0] is
1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all
the rest are zero. The initializer for q[0][0] does not begin with a left brace, so up to six items from the current list may be
used. There is only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers for
q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their respective two-dimensional
subaggregates. If there had been more than six items in any of the lists, a diagnostic message would have been issued. The
same initialization result could have been achieved by:

    short q[4][3][2] = {
          1, 0, 0, 0, 0, 0,
          2, 3, 0, 0, 0, 0,
          4, 5, 6
    };
  

or by:

    short q[4][3][2] = {
          {
                { 1 },
          },
          {
                { 2, 3 },
          },
          {
                { 4, 5 },
                { 6 },
          }
    };
  

in a fully bracketed form.

    typedef int A[];         // OK - declared with block scope
  

the declaration

    A a = { 1, 2 }, b = { 3, 4, 5 };
  

is identical to

    int a[] = { 1, 2 }, b[] = { 3, 4, 5 };
  

due to the rules for incomplete types.

    char s[] = "abc", t[3] = "abc";
  

defines “plain” char array objects s and t whose elements are initialized with character string literals. This declaration is
identical to

    char s[] = { ’a’, ’b’, ’c’, ’\0’ },
         t[] = { ’a’, ’b’, ’c’ };
  

The contents of the arrays are modifiable. On the other hand, the declaration

    char *p = "abc";
  

defines p with type “pointer to char” and initializes it to point to an object with type “array of char” with length 4 whose
elements are initialized with a character string literal. If an attempt is made to use p to modify the contents of the array, the
behavior is undefined.

    enum { member_one, member_two };
    const char *nm[] = {
          [member_two] = "member two",
          [member_one] = "member one",
    };
  

    div_t answer = {.quot = 2, .rem = -1 };
  

    struct { int a[3], b; } w[] =
          { [0].a = {1}, [1].a[0] = 2 };
  

    struct T {
          int k;
          int l;
    };
  

    struct S {
          int i;
          struct T t;
    };
    struct T x = {.l = 43, .k = 42, };
  

    void f(void)
    {
          struct S l = { 1, .t = x, .t.l = 41, };
    }
  

The value of l.t.k is 42, because implicit initialization does not override explicit initialization.

    int a[MAX] = {
          1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
    };
  

    union { /* ... */ } u = {.any_member = 42 };
  

Forward references: common definitions <stddef.h> (7.19).

6.7.10 Static assertions

Syntax

    _Static_assert ( constant-expression , string-literal ) ;
  

Constraints

Semantics

Forward references: diagnostics (7.2).

6.8 Statements and blocks

Syntax

    labeled-statement
    compound-statement
    expression-statement
    selection-statement
    iteration-statement
    jump-statement
  

Semantics

• a full declarator for a variably modified type;
• an initializer that is not part of a compound literal;
• the expression in an expression statement;
• the controlling expression of a selection statement (if or switch);
• the controlling expression of a while or do statement;
• each of the (optional) expressions of a for statement;
• the (optional) expression in a return statement.

While a constant expression satisfies the definition of a full expression, evaluating it does not depend on nor produce any
side effects, so the sequencing implications of being a full expression are not relevant to a constant expression.

Forward references: expression and null statements (6.8.3), selection statements (6.8.4), iteration
statements (6.8.5), the return statement (6.8.6.4).

6.8.1 Labeled statements

Syntax

    identifier : statement
    case constant-expression : statement
    default : statement
  

Constraints

Semantics

Forward references: the goto statement (6.8.6.1), the switch statement (6.8.4.2).

6.8.2 Compound statement

Syntax

    { block-item-listopt }
  

block-item-list:

    block-item
    block-item-list block-item
  

block-item:

    declaration
    statement
  

Semantics

6.8.3 Expression and null statements

Syntax

    expressionopt ;
  

Semantics

    int p(int);
    /* ... */
    (void)p(0);
  

    char *s;
    /* ... */
    while (*s++ != ’\0’)
          ;
  

a null statement is used to supply an empty loop body to the iteration statement.

    while (loop1) {
          /* ... */
          while (loop2) {
                /* ... */
                if (want_out)
                      goto end_loop1;
                /* ... */
          }
          /* ... */
    end_loop1:;
    }
  

Forward references: iteration statements (6.8.5).

6.8.4 Selection statements

Syntax

    if ( expression ) statement
    if ( expression ) statement else statement
    switch ( expression ) statement
  

Semantics

6.8.4.1 The if statement

Constraints

Semantics

6.8.4.2 The switch statement

Constraints

Semantics

Implementation limits

    switch (expr)
    {
          int i = 4;
          f(i);
    case 0:
          i = 17;
          /* falls through into default code */
    default:
          printf("%d\n", i);
    }
  

the object whose identifier is i exists with automatic storage duration (within the block) but is never initialized, and thus if
the controlling expression has a nonzero value, the call to the printf function will access an indeterminate value. Similarly,
the call to the function f cannot be reached.

6.8.5 Iteration statements

Syntax

    while ( expression ) statement
    do statement while ( expression ) ;
    for ( expressionopt ; expressionopt ; expressionopt ) statement
    for ( declaration expressionopt ; expressionopt ) statement
  

Constraints

Semantics

• input/output operations
• accessing a volatile object
• synchronization or atomic operations.

6.8.5.1 The while statement

6.8.5.2 The do statement

6.8.5.3 The for statement

    for (clause-1; expression-2; expression-3) statement
  

behaves as follows: The expression expression-2 is the controlling expression that is evaluated before
each execution of the loop body. The expression expression-3 is evaluated as a void expression after
each execution of the loop body. If clause-1 is a declaration, the scope of any identifiers it declares
is the remainder of the declaration and the entire loop, including the other two expressions; it is
reached in the order of execution before the first evaluation of the controlling expression. If clause-1
is an expression, it is evaluated as a void expression before the first evaluation of the controlling
expression.160)

6.8.6 Jump statements

Syntax

    goto identifier ;
    continue ;
    break ;
    return expressionopt ;
  

Semantics

6.8.6.1 The goto statement

Constraints

Semantics

1. The general initialization code accesses objects only visible to the current function.
2. The general initialization code is too large to warrant duplication.
3. The code to determine the next operation is at the head of the loop. (To allow it to be reached by continue statements,
   for example.)

           /* ... */
           goto first_time;
           for (;;) {
                 // determine next operation
                 /* ... */
                 if (need to reinitialize) {
                       // reinitialize-only code
                       /* ... */
                 first_time:
                       // general initialization code
                          /* ... */
                          continue;
                 }
                 // handle other operations
                 /* ... */
           }
         

    goto lab3;                      // invalid:      going INTO scope of VLA.
    {
          double a[n];
          a[j] = 4.4;
    lab3:
          a[j] = 3.3;
          goto lab4;                // valid:      going WITHIN scope of VLA.
          a[j] = 5.5;
    lab4:
          a[j] = 6.6;
    }
    goto lab4;                      // invalid:      going INTO scope of VLA.
  

6.8.6.2 The continue statement

Constraints

Semantics

    while (/* ...        */) {             do {                             for (/* ... */) {
       /* ... */                              /* ... */                        /* ... */
       continue;                              continue;                        continue;
       /* ... */                              /* ... */                        /* ... */
    contin:;                               contin:;                         contin:;
    }                                      } while (/* ...        */);      }
  

unless the continue statement shown is in an enclosed iteration statement (in which case it is
interpreted within that statement), it is equivalent to goto contin;.161)

6.8.6.3 The break statement

Constraints

Semantics

6.8.6.4 The return statement

Constraints

Semantics

    struct s { double i; } f(void);
    union {
          struct {
                int f1;
                struct s f2;
          } u1;
          struct {
                struct s f3;
                int f4;
          } u2;
    } g;
  

    struct s f(void)
    {
          return g.u1.f2;
    }
  

    /* ... */
    g.u2.f3 = f();
  

there is no undefined behavior, although there would be if the assignment were done directly (without using a function call
to fetch the value).

6.9 External definitions

Syntax

    external-declaration
    translation-unit external-declaration
  

external-declaration:

    function-definition
    declaration
  

Constraints

Semantics

6.9.1 Function definitions

Syntax

    declaration-specifiers declarator declaration-listopt compound-statement
  

declaration-list:

    declaration
    declaration-list declaration
  

Constraints

Semantics

    extern int max(int a, int b)
    {
          return a > b ? a: b;
    }
  

extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the function declarator; and

    { return a       >    b ? a: b; }
  

is the function body. The following similar definition uses the identifier-list form for the parameter declarations:

    extern int max(a, b)
    int a, b;
    {
          return a > b ? a: b;
    }
  

Here int a, b; is the declaration list for the parameters. The difference between these two definitions is that the first form acts
as a prototype declaration that forces conversion of the arguments of subsequent calls to the function, whereas the second
form does not.

    int f(void);
    /* ... */
    g(f);
  

Then the definition of g might read

    void g(int (*funcp)(void))
    {
          /* ... */
          (*funcp)(); /* or funcp(); ...*/
    }
  

or, equivalently,

    void g(int func(void))
    {
          /* ... */
          func(); /* or (*func)(); ...*/
    }
  

      typedef int F(void);                          // type F is “function with no parameters
                                                    // returning int”
      F f, g;                                       // f and g both have type compatible with F
      F f { /* ... */ }                             // WRONG: syntax/constraint error
      F g() { /* ... */ }                           // WRONG: declares that g returns a function
      int f(void) { /* ... */ }                     // RIGHT: f has type compatible with F
      int g() { /* ... */ }                         // RIGHT: g has type compatible with F
      F *e(void) { /* ... */ }                      // e returns a pointer to a function
      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
    

6.9.2 External object definitions

Semantics

    int i1 = 1;                   // definition, external linkage
    static int i2 = 2;            // definition, internal linkage
    extern int i3 = 3;            // definition, external linkage
    int i4;                       // tentative definition, external linkage
    static int i5;                // tentative definition, internal linkage
  

    int i1;                       // valid tentative definition, refers to previous
    int i2;                       // 6.2.2 renders undefined, linkage disagreement
    int i3;                       // valid tentative definition, refers to previous
    int i4;                       // valid tentative definition, refers to previous
    int i5;                       // 6.2.2 renders undefined, linkage disagreement
  

    extern int i1;                // refers to previous, whose linkage is external
    extern int i2;              // refers to previous, whose linkage is internal
    extern int i3;              // refers to previous, whose linkage is external
    extern int i4;              // refers to previous, whose linkage is external
    extern int i5;              // refers to previous, whose linkage is internal
  

    int i[];
  

the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to zero on program
startup.

6.10 Preprocessing directives

Syntax

    groupopt
  

group:

    group-part
    group group-part
  

group-part:

    if-section
    control-line
    text-line
    # non-directive
  

if-section:

    if-group elif-groupsopt else-groupopt endif-line
  

if-group:

    # if constant-expression new-line groupopt
    # ifdef identifier new-line groupopt
    # ifndef identifier new-line groupopt
  

elif-groups:

    elif-group
    elif-groups elif-group
  

elif-group:

    # elif constant-expression new-line groupopt
  

else-group:

    # else new-line groupopt
  

endif-line:

    # endif new-line
  

control-line:

    # include pp-tokens new-line
    # define identifier replacement-list new-line
    # define identifier lparen identifier-listopt )
                                                       replacement-list new-line
    # define identifier lparen ... ) replacement-list new-line
    # define identifier lparen identifier-list , ... )
                                                       replacement-list new-line
    # undef identifier new-line
    # line pp-tokens new-line
    # error pp-tokensopt new-line
    # pragma pp-tokensopt new-line
    # new-line
  

text-line:

    pp-tokensopt new-line
  

non-directive:

    pp-tokens new-line
  

lparen:

    a ( character not immediately preceded by white-space
  

replacement-list:

    pp-tokensopt
  

pp-tokens:

    preprocessing-token
    pp-tokens preprocessing-token
  

new-line:

    the new-line character
  

Description

Constraints

Semantics

    #define EMPTY
    EMPTY # include <file.h>
  

the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not begin with a # at
the start of translation phase 4, even though it will do so after the macro EMPTY has been replaced.

6.10.1 Conditional inclusion

Constraints

    defined identifier
  

or

    defined ( identifier )
  

which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is predefined
or if it has been the subject of a #define preprocessing directive without an intervening #undef
directive with the same subject identifier), 0 if it is not.

Semantics

    # if   constant-expression new-line groupopt
    # elif constant-expression new-line groupopt
  

check whether the controlling constant expression evaluates to nonzero.

    # ifdef identifier new-line groupopt
    # ifndef identifier new-line groupopt
  

check whether the identifier is or is not currently defined as a macro name. Their conditions are
equivalent to #if defined identifier and #if !defined identifier respectively.

Forward references: macro replacement (6.10.3), source file inclusion (6.10.2), largest integer types
(7.20.1.5).

6.10.2 Source file inclusion

Constraints

Semantics

    # include < h-char-sequence > new-line
  

searches a sequence of implementation-defined places for a header identified uniquely by the
specified sequence between the < and > delimiters, and causes the replacement of that directive
by the entire contents of the header. How the places are specified or the header identified is
implementation-defined.

    # include " q-char-sequence " new-line
  

causes the replacement of that directive by the entire contents of the source file identified by the
specified sequence between the " delimiters. The named source file is searched for in an implementa-
tion-defined manner. If this search is not supported, or if the search fails, the directive is reprocessed
as if it read

    # include < h-char-sequence > new-line
  

with the identical contained sequence (including > characters, if any) from the original directive.

    # include pp-tokens new-line
  

(that does not match one of the two previous forms) is permitted. The preprocessing tokens after
include in the directive are processed just as in normal text. (Each identifier currently defined as a
macro name is replaced by its replacement list of preprocessing tokens.) The directive resulting after
all replacements shall match one of the two previous forms.172) The method by which a sequence
of preprocessing tokens between a < and a > preprocessing token pair or a pair of " characters is
combined into a single header name preprocessing token is implementation-defined.

    #include <stdio.h>
    #include "myprog.h"
  

    #if VERSION == 1
          #define INCFILE             "vers1.h"
    #elif VERSION == 2
          #define INCFILE             "vers2.h"         // and so on
    #else
          #define INCFILE             "versN.h"
    #endif
    #include INCFILE
  

Forward references: macro replacement (6.10.3).

6.10.3 Macro replacement

Constraints

Semantics

    # define identifier replacement-list new-line
  

defines an object-like macro that causes each subsequent instance of the macro name173) to be replaced
by the replacement list of preprocessing tokens that constitute the remainder of the directive. The
replacement list is then rescanned for more macro names as specified below.

    # define identifier lparen identifier-listopt ) replacement-list new-line
    # define identifier lparen ... ) replacement-list new-line
    # define identifier lparen identifier-list , ... ) replacement-list new-line
  

defines a function-like macro with parameters, whose use is similar syntactically to a function call. The
parameters are specified by the optional list of identifiers, whose scope extends from their declaration
in the identifier list until the new-line character that terminates the #define preprocessing directive.
Each subsequent instance of the function-like macro name followed by a ( as the next preprocessing
token introduces the sequence of preprocessing tokens that is replaced by the replacement list
in the definition (an invocation of the macro). The replaced sequence of preprocessing tokens is
terminated by the matching ) preprocessing token, skipping intervening matched pairs of left and
right parenthesis preprocessing tokens. Within the sequence of preprocessing tokens making up an
invocation of a function-like macro, new-line is considered a normal white-space character.

6.10.3.1 Argument substitution

6.10.3.2 The # operator

Constraints

Semantics

6.10.3.3 The ## operator

Constraints

Semantics

(not from an argument) is deleted and the preceding preprocessing token is concatenated with the
following preprocessing token. Placemarker preprocessing tokens are handled specially: concatena-
tion of two placemarkers results in a single placemarker preprocessing token, and concatenation
of a placemarker with a non-placemarker preprocessing token results in the non-placemarker pre-
processing token. If the result is not a valid preprocessing token, the behavior is undefined. The
resulting token is available for further macro replacement. The order of evaluation of ## operators is
unspecified.

    #define hash_hash # ## #
    #define mkstr(a) # a
    #define in_between(a) mkstr(a)
    #define join(c, d) in_between(c hash_hash d)
  

    char p[] = join(x, y); // equivalent to
                           // char p[] = "x ## y";
  

The expansion produces, at various stages:

    join(x, y)
  

    in_between(x hash_hash y)
  

    in_between(x ## y)
  

    mkstr(x ## y)
  

    "x ## y"
  

In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but this new token is
not the ## operator.

6.10.3.4 Rescanning and further replacement

    #define f(a) a*g
    #define g(a) f(a)
  

the invocation

    f(2)(9)
  

may expand to either

    2*f(9)
  

or

    2*9*g
  

Strictly conforming programs are not permitted to depend on such unspecified behavior.

6.10.3.5 Scope of macro definitions

    # undef identifier new-line
  

causes the specified identifier no longer to be defined as a macro name. It is ignored if the specified
identifier is not currently defined as a macro name.

    #define TABSIZE 100
  

    int table[TABSIZE];
  

    #define max(a, b) ((a)         >   (b) ? (a): (b))
  

The parentheses ensure that the arguments and the resulting expression are bound properly.

    #define x      3
    #define f(a)   f(x * (a))
    #undef x
    #define x      2
    #define g      f
    #define z      z[0]
    #define h      g(\~{ }
    #define m(a)   a(w)
    #define w      0,1
    #define t(a)   a
    #define p()    int
    #define q(x)   x
    #define r(x,y) x ## y
    #define str(x) # x
  

    f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);
    g(x+(3,4)-w) | h 5) & m
          (f)^m(m);
    p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
    char c[2][6] = { str(hello), str() };
  

results in

    f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
    f(2 * (2+(3,4)-0,1)) | f(2 * (\~{ } 5)) & f(2 * (0,1))^m(0,1);
    int i[] = { 1, 23, 4, 5, };
    char c[2][6] = { "hello", "" };
  

    #define str(s)      # s
    #define xstr(s)     str(s)
    #define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
                            x ## s, x ## t)
    #define INCFILE(n) vers ## n
    #define glue(a, b) a ## b
    #define xglue(a, b) glue(a, b)
    #define HIGHLOW     "hello"
    #define LOW         LOW ", world"
  

    debug(1, 2);
    fputs(str(strncmp("abc\0d", "abc", ’\4’) // this goes away
          == 0) str(: @\n), s);
    #include xstr(INCFILE(2).h)
    glue(HIGH, LOW);
    xglue(HIGH, LOW)
  

results in

    printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
    fputs(
      "strncmp(\"abc\\0d\", \"abc\", ’\\4’) == 0" ": @\n",
      s);
    #include "vers2.h"    (after macro replacement, before file access)
    "hello";
    "hello" ", world"
  

or, after concatenation of the character string literals,

    printf("x1= %d, x2= %s", x1, x2);
    fputs(
      "strncmp(\"abc\\0d\", \"abc\", ’\\4’) == 0: @\n",
      s);
    #include "vers2.h"    (after macro replacement, before file access)
    "hello";
    "hello, world"
  

Space around the # and ## tokens in the macro definition is optional.

    #define t(x,y,z) x ## y ## z
    int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
               t(10,,), t(,11,), t(,,12), t(,,) };
  

results in

    int j[] = { 123, 45, 67, 89,
                10, 11, 12, };
  

    #define OBJ_LIKE      (1-1)
    #define OBJ_LIKE      /* white space */ (1-1) /* other */
    #define FUNC_LIKE(a)   (a)
    #define FUNC_LIKE(a)(   /* note the white space */ \
                            a /* other stuff on this line
                               */)
  

But the following redefinitions are invalid:

    #define OBJ_LIKE    (0)     // different token sequence
    #define OBJ_LIKE    (1 - 1) // different white space
    #define FUNC_LIKE(b) (a)    // different parameter usage
    #define FUNC_LIKE(b) (b)    // different parameter spelling
  

    #define debug(...)      fprintf(stderr, __VA_ARGS__)
    #define showlist(...)   puts(#__VA_ARGS__)
    #define report(test, ...) ((test)?puts(#test):\
                printf(__VA_ARGS__))
    debug("Flag");
    debug("X = %d\n", x);
    showlist(The first, second, and third items.);
    report(x>y, "x is %d but y is %d", x, y);
  

results in

    fprintf(stderr, "Flag");
    fprintf(stderr, "X = %d\n", x);
    puts("The first, second, and third items.");
    ((x>y)?puts("x>y"):
                printf("x is %d but y is %d", x, y));
  

6.10.4 Line control

Constraints

Semantics

    # line digit-sequence new-line
  

causes the implementation to behave as if the following sequence of source lines begins with a source
line that has a line number as specified by the digit sequence (interpreted as a decimal integer). The
digit sequence shall not specify zero, nor a number greater than 2147483647.

    # line digit-sequence " s-char-sequenceopt " new-line
  

sets the presumed line number similarly and changes the presumed name of the source file to be the
contents of the character string literal.

    # line pp-tokens new-line
  

(that does not match one of the two previous forms) is permitted. The preprocessing tokens after
line on the directive are processed just as in normal text (each identifier currently defined as a
macro name is replaced by its replacement list of preprocessing tokens). The directive resulting after
all replacements shall match one of the two previous forms and is then processed as appropriate.176)

6.10.5 Error directive

Semantics

    # error pp-tokensopt new-line
  

causes the implementation to produce a diagnostic message that includes the specified sequence of
preprocessing tokens.

6.10.6 Pragma directive

Semantics

    # pragma pp-tokensopt new-line
  

where the preprocessing token STDC does not immediately follow pragma in the directive (prior to
any macro replacement)177) causes the implementation to behave in an implementation-defined man-
ner. The behavior might cause translation to fail or cause the translator or the resulting program to
behave in a non-conforming manner. Any such pragma that is not recognized by the implementation
is ignored.

    # pragma STDC FP_CONTRACT on-off-switch
    # pragma STDC FENV_ACCESS on-off-switch
    # pragma STDC CX_LIMITED_RANGE on-off-switch
  

on-off-switch: one of

    ON        OFF        DEFAULT
  

Forward references: the FP_CONTRACT pragma (7.12.2), the FENV_ACCESS pragma (7.6.1), the
CX_LIMITED_RANGE pragma (7.3.4).

6.10.7 Null directive

Semantics

    # new-line
  

has no effect.

6.10.8 Predefined macro names

__LINE__

) remain constant throughout the translation unit.

Forward references: standard headers (7.1.2).

6.10.8.1 Mandatory macros

__DATE__

The date of translation of the preprocessing translation unit: a character string literal of
the form "Mmm dd yyyy", where the names of the months are the same as those generated
by the asctime function, and the first character of dd is a space character if the value is
less than 10. If the date of translation is not available, an implementation-defined valid
date shall be supplied.

__FILE__

The presumed name of the current source file (a character string literal).180)

__LINE__

The presumed line number (within the current source file) of the current source line (an
integer constant).180)

__STDC__

The integer constant 1 , intended to indicate a conforming implementation.

__STDC_HOSTED__

The integer constant 1 if the implementation is a hosted implementation or the
integer constant 0 if it is not.

__STDC_VERSION__

The integer constant 201710L.181)

__TIME__

The time of translation of the preprocessing translation unit: a character 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.

Forward references: the asctime function (7.27.3.1).

6.10.8.2 Environment macros

__STDC_ISO_10646__

An integer constant of the form yyyymmL (for example, 199712L ). If this
symbol is defined, then every character in the Unicode required set, when stored in an
object of type wchar_t, has the same value as the short identifier of that character. The
Unicode required set consists of all the characters that are defined by ISO/IEC 10646, along
with all amendments and technical corrigenda, as of the specified year and month. If
some other encoding is used, the macro shall not be defined and the actual encoding
used is implementation-defined.

__STDC_MB_MIGHT_NEQ_WC__

The integer constant 1 , intended to indicate that, in the encoding for
wchar_t, a member of the basic character set need not have a code value equal to its
value when used as the lone character in an integer character constant.

__STDC_UTF_16__

The integer constant 1 , intended to indicate that values of type char16_t are
UTF–16 encoded. If some other encoding is used, the macro shall not be defined and the
actual encoding used is implementation-defined.

__STDC_UTF_32__

The integer constant 1 , intended to indicate that values of type 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.

Forward references: common definitions (7.19), unicode utilities (7.28).

6.10.8.3 Conditional feature macros

__STDC_ANALYZABLE__

The integer constant 1 , intended to indicate conformance to the specifica-
tions in annex L (Analyzability).

__STDC_IEC_559__

The integer constant 1 , intended to indicate conformance to the specifications
in annex F (IEC 60559 floating-point arithmetic).

__STDC_IEC_559_COMPLEX__

The integer constant 1 , intended to indicate adherence to the specifi-
cations in annex G (IEC 60559 compatible complex arithmetic).

__STDC_LIB_EXT1__

The integer constant 201710L, intended to indicate support for the extensions
defined in annex K (Bounds-checking interfaces).182)

__STDC_NO_ATOMICS__

The integer constant 1, intended to indicate that the implementation does
not support atomic types (including the _Atomic type qualifier) and the <stdatomic.h>
header.

__STDC_NO_COMPLEX__

The integer constant 1, intended to indicate that the implementation does
not support complex types or the <complex.h> header.

__STDC_NO_THREADS__

The integer constant 1, intended to indicate that the implementation does
not support the <threads.h> header.

__STDC_NO_VLA__

The integer constant 1 , intended to indicate that the implementation does not
support variable length arrays or variably modified types.

6.10.9 Pragma operator

Semantics

    _Pragma ( string-literal )
  

is processed as follows: The string literal is destringized by deleting any encoding prefix, deleting
the leading and trailing double-quotes, replacing each escape sequence \" by a double-quote, and
replacing each escape sequence \\ by a single backslash. The resulting sequence of characters
is processed through translation phase 3 to produce preprocessing tokens that are executed as if
they were the pp-tokens in a pragma directive. The original four preprocessing tokens in the unary
operator expression are removed.

    #pragma listing on "..\listing.dir"
  

can also be expressed as:

    _Pragma ("listing on \"..\\listing.dir\"")
  

The latter form is processed in the same way whether it appears literally as shown, or results from macro replacement, as in:

    #define LISTING(x) PRAGMA(listing on #x)
    #define PRAGMA(x) _Pragma(#x)
  

    LISTING (..\listing.dir)
  

6.11 Future language directions

6.11.1 Floating types

6.11.2 Linkages of identifiers

6.11.3 External names

6.11.4 Character escape sequences

6.11.5 Storage-class specifiers

6.11.6 Function declarators

6.11.7 Function definitions

6.11.8 Pragma directives

6.11.9 Predefined macro names

7. Library

7.1 Introduction

7.1.1 Definitions of terms

Forward references: character handling (7.4), the setlocale function (7.11.1.1).

7.1.2 Standard headers

<assert.h> <math.h> <stdlib.h>
<complex.h> <setjmp.h> <stdnoreturn.h>
<ctype.h> <signal.h> <string.h>
<errno.h> <stdalign.h> <tgmath.h>
<fenv.h> <stdarg.h> <threads.h>
<float.h> <stdatomic.h> <time.h>
<inttypes.h> <stdbool.h> <uchar.h>
<iso646.h> <stddef.h> <wchar.h>
<limits.h> <stdint.h> <wctype.h>
<locale.h> <stdio.h>

Forward references: diagnostics (7.2).

7.1.3 Reserved identifiers

• All identifiers that begin with an underscore and either an uppercase letter or another under-
  score are always reserved for any use, except those identifiers which are lexically identical to
  keywords.187)
• All identifiers that begin with an underscore are always reserved for use as identifiers with file
  scope in both the ordinary and tag name spaces.
• Each macro name in any of the following subclauses (including the future library directions)
  is reserved for use as specified if any of its associated headers is included; unless explicitly
  stated otherwise (see 7.1.4).
• All identifiers with external linkage in any of the following subclauses (including the future
  library directions) and errno are always reserved for use as identifiers with external linkage.188)
• Each identifier with file scope listed in any of the following subclauses (including the future
  library directions) is reserved for use as a macro name and as an identifier with file scope in
  the same name space if any of its associated headers is included.

7.1.4 Use of library functions

• by use of its associated header (possibly generating a macro expansion)

          #include <stdlib.h>
          const char *str;
          /* ... */
          i = atoi(str);
        

• by use of its associated header (assuredly generating a true function reference)

          #include <stdlib.h>
          #undef atoi
          const char *str;
          /* ... */
          i = atoi(str);