[dcl.pre] - C++17 → C++20

Files changed (1) hide show

tmp/tmppgjr32ad/{from.md → to.md} +201 -0

tmp/tmppgjr32ad/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,201 @@

+## Preamble <a id="dcl.pre">[[dcl.pre]]</a>
+Declarations generally specify how names are to be interpreted.
+Declarations have the form
+``` bnf
+declaration-seq:
+    declaration
+    declaration-seq declaration
+```
+``` bnf
+declaration:
+    block-declaration
+    nodeclspec-function-declaration
+    function-definition
+    template-declaration
+    deduction-guide
+    explicit-instantiation
+    explicit-specialization
+    export-declaration
+    linkage-specification
+    namespace-definition
+    empty-declaration
+    attribute-declaration
+    module-import-declaration
+```
+``` bnf
+block-declaration:
+    simple-declaration
+    asm-declaration
+    namespace-alias-definition
+    using-declaration
+    using-enum-declaration
+    using-directive
+    static_assert-declaration
+    alias-declaration
+    opaque-enum-declaration
+```
+``` bnf
+nodeclspec-function-declaration:
+    attribute-specifier-seqₒₚₜ declarator ';'
+```
+``` bnf
+alias-declaration:
+    using identifier attribute-specifier-seqₒₚₜ '=' defining-type-id ';'
+```
+``` bnf
+simple-declaration:
+    decl-specifier-seq init-declarator-listₒₚₜ ';'
+    attribute-specifier-seq decl-specifier-seq init-declarator-list ';'
+    attribute-specifier-seqₒₚₜ decl-specifier-seq ref-qualifierₒₚₜ '[' identifier-list ']' initializer ';'
+```
+``` bnf
+static_assert-declaration:
+  static_assert '(' constant-expression ')' ';'
+  static_assert '(' constant-expression ',' string-literal ')' ';'
+```
+``` bnf
+empty-declaration:
+    ';'
+```
+``` bnf
+attribute-declaration:
+    attribute-specifier-seq ';'
+```
+[*Note 1*: *asm-declaration*s are described in  [[dcl.asm]], and
+*linkage-specification*s are described in  [[dcl.link]];
+*function-definition*s are described in  [[dcl.fct.def]] and
+*template-declaration*s and *deduction-guide*s are described in
+[[temp.deduct.guide]]; *namespace-definition*s are described in
+[[namespace.def]], *using-declaration*s are described in
+[[namespace.udecl]] and *using-directive*s are described in
+[[namespace.udir]]. — *end note*]
+A *simple-declaration* or *nodeclspec-function-declaration* of the form
+``` bnf
+attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
+```
+is divided into three parts. Attributes are described in  [[dcl.attr]].
+*decl-specifier*s, the principal components of a *decl-specifier-seq*,
+are described in  [[dcl.spec]]. *declarator*s, the components of an
+*init-declarator-list*, are described in [[dcl.decl]]. The
+*attribute-specifier-seq* appertains to each of the entities declared by
+the *declarator*s of the *init-declarator-list*.
+[*Note 2*: In the declaration for an entity, attributes appertaining to
+that entity may appear at the start of the declaration and after the
+*declarator-id* for that declaration. — *end note*]
+[*Example 1*:
+``` cpp
+[[noreturn]] void f [[noreturn]] ();    // OK
+```
+— *end example*]
+Except where otherwise specified, the meaning of an
+*attribute-declaration* is *implementation-defined*.
+A declaration occurs in a scope [[basic.scope]]; the scope rules are
+summarized in  [[basic.lookup]]. A declaration that declares a function
+or defines a class, namespace, template, or function also has one or
+more scopes nested within it. These nested scopes, in turn, can have
+declarations nested within them. Unless otherwise stated, utterances in
+[[dcl.dcl]] about components in, of, or contained by a declaration or
+subcomponent thereof refer only to those components of the declaration
+that are *not* nested within scopes nested within the declaration.
+In a *simple-declaration*, the optional *init-declarator-list* can be
+omitted only when declaring a class [[class]] or enumeration
+[[dcl.enum]], that is, when the *decl-specifier-seq* contains either a
+*class-specifier*, an *elaborated-type-specifier* with a *class-key*
+[[class.name]], or an *enum-specifier*. In these cases and whenever a
+*class-specifier* or *enum-specifier* is present in the
+*decl-specifier-seq*, the identifiers in these specifiers are among the
+names being declared by the declaration (as *class-name*s, *enum-name*s,
+or *enumerator*s, depending on the syntax). In such cases, the
+*decl-specifier-seq* shall introduce one or more names into the program,
+or shall redeclare a name introduced by a previous declaration.
+[*Example 2*:
+``` cpp
+enum { };           // error
+typedef class { };  // error
+```
+— *end example*]
+In a *static_assert-declaration*, the *constant-expression* shall be a
+contextually converted constant expression of type `bool`
+[[expr.const]]. If the value of the expression when so converted is
+`true`, the declaration has no effect. Otherwise, the program is
+ill-formed, and the resulting diagnostic message [[intro.compliance]]
+shall include the text of the *string-literal*, if one is supplied,
+except that characters not in the basic source character set
+[[lex.charset]] are not required to appear in the diagnostic message.
+[*Example 3*:
+``` cpp
+static_assert(sizeof(int) == sizeof(void*), "wrong pointer size");
+```
+— *end example*]
+An *empty-declaration* has no effect.
+A *simple-declaration* with an *identifier-list* is called a *structured
+binding declaration* [[dcl.struct.bind]]. If the *decl-specifier-seq*
+contains any *decl-specifier* other than `static`, `thread_local`,
+`auto` [[dcl.spec.auto]], or *cv-qualifier*s, the program is ill-formed.
+The *initializer* shall be of the form “`=` *assignment-expression*”, of
+the form “`{` *assignment-expression* `}`”, or of the form “`(`
+*assignment-expression* `)`”, where the *assignment-expression* is of
+array or non-union class type.
+Each *init-declarator* in the *init-declarator-list* contains exactly
+one *declarator-id*, which is the name declared by that
+*init-declarator* and hence one of the names declared by the
+declaration. The *defining-type-specifier*s [[dcl.type]] in the
+*decl-specifier-seq* and the recursive *declarator* structure of the
+*init-declarator* describe a type [[dcl.meaning]], which is then
+associated with the name being declared by the *init-declarator*.
+If the *decl-specifier-seq* contains the `typedef` specifier, the
+declaration is called a *typedef declaration* and the name of each
+*init-declarator* is declared to be a *typedef-name*, synonymous with
+its associated type [[dcl.typedef]]. If the *decl-specifier-seq*
+contains no `typedef` specifier, the declaration is called a *function
+declaration* if the type associated with the name is a function type
+[[dcl.fct]] and an *object declaration* otherwise.
+Syntactic components beyond those found in the general form of
+declaration are added to a function declaration to make a
+*function-definition*. An object declaration, however, is also a
+definition unless it contains the `extern` specifier and has no
+initializer [[basic.def]]. An object definition causes storage of
+appropriate size and alignment to be reserved and any appropriate
+initialization [[dcl.init]] to be done.
+A *nodeclspec-function-declaration* shall declare a constructor,
+destructor, or conversion function.
+[*Note 3*: A *nodeclspec-function-declaration* can only be used in a
+*template-declaration* [[temp.pre]], *explicit-instantiation*
+[[temp.explicit]], or *explicit-specialization*
+[[temp.expl.spec]]. — *end note*]

Diff to HTML by rtfpessoa