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

Files changed (1) hide show

tmp/tmp91_eqb2t/{from.md → to.md} +37 -31

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

@@ -9,27 +9,27 @@ described here. For example, a particular language linkage may be
 associated with a particular form of representing names of objects and
 functions with external linkage, or with a particular calling
 convention, etc. — *end note*]
 The default language linkage of all function types, function names, and
-variable names is C++language linkage. Two function types with different
-language linkages are distinct types even if they are otherwise
-identical.
-Linkage ([[basic.link]]) between C++and non-C++code fragments can be
 achieved using a *linkage-specification*:
 ``` bnf
 linkage-specification:
- 'extern' string-literal '{' declaration-seqₒₚₜ '}'
- 'extern' string-literal declaration
 ```
 The *string-literal* indicates the required language linkage. This
-International Standard specifies the semantics for the *string-literal*s
-`"C"` and `"C++"`. Use of a *string-literal* other than `"C"` or `"C++"`
-is conditionally-supported, with *implementation-defined* semantics.
 [*Note 2*: Therefore, a linkage-specification with a *string-literal*
 that is unknown to the implementation requires a
 diagnostic. — *end note*]
@@ -37,27 +37,33 @@ diagnostic. — *end note*]
 be taken from the document defining that language. For example, `Ada`
 (not `ADA`) and `Fortran` or `FORTRAN`, depending on the
 vintage. — *end note*]
 Every implementation shall provide for linkage to functions written in
-the C programming language, `"C"`, and linkage to C++functions, `"C++"`.
 [*Example 1*:
 ``` cpp
-complex sqrt(complex);          // C++linkage by default
 extern "C" {
   double sqrt(double);          // C linkage
 }
 ```
 — *end example*]
 Linkage specifications nest. When linkage specifications nest, the
 innermost one determines the language linkage. A linkage specification
 does not establish a scope. A *linkage-specification* shall occur only
-in namespace scope ([[basic.scope]]). In a *linkage-specification*, the
 specified language linkage applies to the function types of all function
 declarators, function names with external linkage, and variable names
 with external linkage declared within the *linkage-specification*.
 [*Example 2*:
@@ -65,17 +71,17 @@ with external linkage declared within the *linkage-specification*.
 ``` cpp
 extern "C"                      // the name f1 and its function type have C language linkage;
   void f1(void(*pf)(int));      // pf is a pointer to a C function
 extern "C" typedef void FUNC();
-FUNC f2;                        // the name f2 has C++language linkage and the
                                 // function's type has C language linkage
 extern "C" FUNC f3;             // the name of function f3 and the function's type have C language linkage
-void (*pf2)(FUNC*);             // the name of the variable pf2 has C++linkage and the type
-                                // of pf2 is ``pointer to C++function that takes one parameter of type
                                 // pointer to C function''
 extern "C" {
   static void f4();             // the name of the function f4 has internal linkage (not C language linkage)
                                 // and the function's type has C language linkage.
 }
@@ -105,39 +111,39 @@ functions.
 ``` cpp
 extern "C" typedef void FUNC_c();
 class C {
   void mf1(FUNC_c*);            // the name of the function mf1 and the member function's type have
-                                // C++language linkage; the parameter has type ``pointer to C function''
   FUNC_c mf2;                   // the name of the function mf2 and the member function's type have
-                                // C++language linkage
-  static FUNC_c* q;             // the name of the data member q has C++language linkage and
                                 // the data member's type is ``pointer to C function''
 };
 extern "C" {
   class X {
     void mf();                  // the name of the function mf and the member function's type have
-                                // C++language linkage
-    void mf2(void(*)());        // the name of the function mf2 has C++language linkage;
                                 // the parameter has type ``pointer to C function''
   };
 }
 ```
 — *end example*]
 If two declarations declare functions with the same name and
-parameter-type-list ([[dcl.fct]]) to be members of the same namespace
-or declare objects with the same name to be members of the same
-namespace and the declarations give the names different language
-linkages, the program is ill-formed; no diagnostic is required if the
-declarations appear in different translation units. Except for functions
-with C++linkage, a function declaration without a linkage specification
-shall not precede the first linkage specification for that function. A
 function can be declared without a linkage specification after an
 explicit linkage specification has been seen; the linkage explicitly
 specified in the earlier declaration is not affected by such a function
 declaration.
@@ -167,28 +173,28 @@ namespace scope. — *end note*]
 int x;
 namespace A {
   extern "C" int f();
   extern "C" int g() { return 1; }
   extern "C" int h();
-  extern "C" int x();               // ill-formed: same name as global-space object x
 }
 namespace B {
   extern "C" int f();               // A::f and B::f refer to the same function
-  extern "C" int g() { return 1; }  // ill-formed, the function g with C language linkage has two definitions
 }
 int A::f() { return 98; }           // definition for the function f with C language linkage
 extern "C" int h() { return 97; }   // definition for the function h with C language linkage
                                     // A::h and ::h refer to the same function
 ```
 — *end example*]
 A declaration directly contained in a *linkage-specification* is treated
-as if it contains the `extern` specifier ([[dcl.stc]]) for the purpose
-of determining the linkage of the declared name and whether it is a
 definition. Such a declaration shall not specify a storage class.
 [*Example 5*:
 ``` cpp

 associated with a particular form of representing names of objects and
 functions with external linkage, or with a particular calling
 convention, etc. — *end note*]
 The default language linkage of all function types, function names, and
+variable names is C++ language linkage. Two function types with
+different language linkages are distinct types even if they are
+otherwise identical.
+Linkage [[basic.link]] between C++ and non-C++ code fragments can be
 achieved using a *linkage-specification*:
 ``` bnf
 linkage-specification:
+    extern string-literal '{' declaration-seqₒₚₜ '}'
+    extern string-literal declaration
 ```
 The *string-literal* indicates the required language linkage. This
+document specifies the semantics for the *string-literal*s `"C"` and
+`"C++"`. Use of a *string-literal* other than `"C"` or `"C++"` is
+conditionally-supported, with *implementation-defined* semantics.
 [*Note 2*: Therefore, a linkage-specification with a *string-literal*
 that is unknown to the implementation requires a
 diagnostic. — *end note*]
 be taken from the document defining that language. For example, `Ada`
 (not `ADA`) and `Fortran` or `FORTRAN`, depending on the
 vintage. — *end note*]
 Every implementation shall provide for linkage to functions written in
+the C programming language, `"C"`, and linkage to C++ functions,
+`"C++"`.
 [*Example 1*:
 ``` cpp
+complex sqrt(complex);          // C++{} linkage by default
 extern "C" {
   double sqrt(double);          // C linkage
 }
 ```
 — *end example*]
+A *module-import-declaration* shall not be directly contained in a
+*linkage-specification*. A *module-import-declaration* appearing in a
+linkage specification with other than C++ language linkage is
+conditionally-supported with *implementation-defined* semantics.
 Linkage specifications nest. When linkage specifications nest, the
 innermost one determines the language linkage. A linkage specification
 does not establish a scope. A *linkage-specification* shall occur only
+in namespace scope [[basic.scope]]. In a *linkage-specification*, the
 specified language linkage applies to the function types of all function
 declarators, function names with external linkage, and variable names
 with external linkage declared within the *linkage-specification*.
 [*Example 2*:
 ``` cpp
 extern "C"                      // the name f1 and its function type have C language linkage;
   void f1(void(*pf)(int));      // pf is a pointer to a C function
 extern "C" typedef void FUNC();
+FUNC f2;                        // the name f2 has C++{} language linkage and the
                                 // function's type has C language linkage
 extern "C" FUNC f3;             // the name of function f3 and the function's type have C language linkage
+void (*pf2)(FUNC*);             // the name of the variable pf2 has C++{} linkage and the type
+                                // of pf2 is ``pointer to C++{} function that takes one parameter of type
                                 // pointer to C function''
 extern "C" {
   static void f4();             // the name of the function f4 has internal linkage (not C language linkage)
                                 // and the function's type has C language linkage.
 }
 ``` cpp
 extern "C" typedef void FUNC_c();
 class C {
   void mf1(FUNC_c*);            // the name of the function mf1 and the member function's type have
+                                // C++{} language linkage; the parameter has type ``pointer to C function''
   FUNC_c mf2;                   // the name of the function mf2 and the member function's type have
+                                // C++{} language linkage
+  static FUNC_c* q;             // the name of the data member q has C++{} language linkage and
                                 // the data member's type is ``pointer to C function''
 };
 extern "C" {
   class X {
     void mf();                  // the name of the function mf and the member function's type have
+                                // C++{} language linkage
+    void mf2(void(*)());        // the name of the function mf2 has C++{} language linkage;
                                 // the parameter has type ``pointer to C function''
   };
 }
 ```
 — *end example*]
 If two declarations declare functions with the same name and
+parameter-type-list [[dcl.fct]] to be members of the same namespace or
+declare objects with the same name to be members of the same namespace
+and the declarations give the names different language linkages, the
+program is ill-formed; no diagnostic is required if the declarations
+appear in different translation units. Except for functions with C++
+linkage, a function declaration without a linkage specification shall
+not precede the first linkage specification for that function. A
 function can be declared without a linkage specification after an
 explicit linkage specification has been seen; the linkage explicitly
 specified in the earlier declaration is not affected by such a function
 declaration.
 int x;
 namespace A {
   extern "C" int f();
   extern "C" int g() { return 1; }
   extern "C" int h();
+  extern "C" int x();               // error: same name as global-space object x
 }
 namespace B {
   extern "C" int f();               // A::f and B::f refer to the same function
+  extern "C" int g() { return 1; }  // error: the function g with C language linkage has two definitions
 }
 int A::f() { return 98; }           // definition for the function f with C language linkage
 extern "C" int h() { return 97; }   // definition for the function h with C language linkage
                                     // A::h and ::h refer to the same function
 ```
 — *end example*]
 A declaration directly contained in a *linkage-specification* is treated
+as if it contains the `extern` specifier [[dcl.stc]] for the purpose of
+determining the linkage of the declared name and whether it is a
 definition. Such a declaration shall not specify a storage class.
 [*Example 5*:
 ``` cpp

Diff to HTML by rtfpessoa