Init

cppdraft/dcl/link.md

@@ -0,0 +1,180 @@
+[dcl.link]
+
+# 9 Declarations [[dcl]](./#dcl)
+
+## 9.12 Linkage specifications [dcl.link]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9126)
+
+All functions and variables whose names have external linkage
+and all function types
+have a [*language linkage*](#def:language_linkage "9.12 Linkage specifications [dcl.link]")[.](#1.sentence-1)
+
+[*Note [1](#note-1)*:
+
+Some of the properties associated with an entity with language linkage
+are specific to each implementation and are not described here[.](#1.sentence-2)
+
+For
+example, a particular language linkage might be associated with a
+particular form of representing names of objects and functions with
+external linkage, or with a particular calling convention, etc[.](#1.sentence-3)
+
+— *end note*]
+
+The default language linkage of all function types, functions, and
+variables is C++ language linkage[.](#1.sentence-4)
+
+Two function types with
+different language linkages are distinct types even if they are
+otherwise identical[.](#1.sentence-5)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9142)
+
+[Linkage](basic.link "6.7 Program and linkage [basic.link]") between C++ and non-C++ code fragments can
+be achieved using a [*linkage-specification*](#nt:linkage-specification "9.12 Linkage specifications [dcl.link]"):
+
+[linkage-specification:](#nt:linkage-specification "9.12 Linkage specifications [dcl.link]")  
+extern [*unevaluated-string*](lex.string.uneval#nt:unevaluated-string "5.13.6 Unevaluated strings [lex.string.uneval]") { [*declaration-seq*](dcl.pre#nt:declaration-seq "9.1 Preamble [dcl.pre]")opt }  
+extern [*unevaluated-string*](lex.string.uneval#nt:unevaluated-string "5.13.6 Unevaluated strings [lex.string.uneval]") [*name-declaration*](dcl.pre#nt:name-declaration "9.1 Preamble [dcl.pre]")
+
+The [*unevaluated-string*](lex.string.uneval#nt:unevaluated-string "5.13.6 Unevaluated strings [lex.string.uneval]") indicates the required language linkage[.](#2.sentence-2)
+
+[*Note [2](#note-2)*:
+
+Escape sequences and [*universal-character-name*](lex.universal.char#nt:universal-character-name "5.3.2 Universal character names [lex.universal.char]")*s* have been replaced ([[lex.string.uneval]](lex.string.uneval "5.13.6 Unevaluated strings"))[.](#2.sentence-3)
+
+— *end note*]
+
+This document specifies the semantics for the[*unevaluated-string*](lex.string.uneval#nt:unevaluated-string "5.13.6 Unevaluated strings [lex.string.uneval]")*s* "C" and "C++"[.](#2.sentence-4)
+
+Use of an [*unevaluated-string*](lex.string.uneval#nt:unevaluated-string "5.13.6 Unevaluated strings [lex.string.uneval]") other than "C" or "C++" is conditionally-supported,
+with implementation-defined semantics[.](#2.sentence-5)
+
+[*Note [3](#note-3)*:
+
+Therefore, a [*linkage-specification*](#nt:linkage-specification "9.12 Linkage specifications [dcl.link]") with a language linkage
+that is unknown to the implementation requires a diagnostic[.](#2.sentence-6)
+
+— *end note*]
+
+*Recommended practice*: The spelling of the language linkage should be taken
+from the document defining that language[.](#2.sentence-7)
+
+For example, Ada (not ADA) andFortran or FORTRAN, depending on the vintage[.](#2.sentence-8)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9175)
+
+Every implementation shall provide for linkage to the C programming language,"C", and C++, "C++"[.](#3.sentence-1)
+
+[*Example [1](#example-1)*: complex sqrt(complex); // C++ language linkage by defaultextern "C" {double sqrt(double); // C language linkage} — *end example*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9189)
+
+A [*module-import-declaration*](module.import#nt:module-import-declaration "10.3 Import declaration [module.import]") appearing in
+a linkage specification with other than C++ language linkage
+is conditionally-supported withimplementation-defined semantics[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9196)
+
+Linkage specifications nest[.](#5.sentence-1)
+
+When linkage specifications nest, the
+innermost one determines the language linkage[.](#5.sentence-2)
+
+[*Note [4](#note-4)*:
+
+A linkage specification does not establish a scope[.](#5.sentence-3)
+
+— *end note*]
+
+A [*linkage-specification*](#nt:linkage-specification "9.12 Linkage specifications [dcl.link]") shall inhabit a namespace scope[.](#5.sentence-4)
+
+In a [*linkage-specification*](#nt:linkage-specification "9.12 Linkage specifications [dcl.link]"),
+the specified language linkage applies
+to the function types of all function declarators and
+to all functions and variables whose names have external linkage[.](#5.sentence-5)
+
+[*Example [2](#example-2)*: extern "C" // f1 and its function type have C language linkage;void f1(void(*pf)(int)); // pf is a pointer to a C functionextern "C" typedef void FUNC();
+FUNC f2; // f2 has C++ language linkage and// its type has C language linkageextern "C" FUNC f3; // f3 and its type have C language linkagevoid (*pf2)(FUNC*); // the variable pf2 has C++ language linkage; its type// 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,// so f4 has no language linkage; its type has C language linkage}extern "C" void f5() {extern void f4(); // OK, name linkage (internal) and function type linkage (C language linkage)// obtained from previous declaration.}extern void f4(); // OK, name linkage (internal) and function type linkage (C language linkage)// obtained from previous declaration.void f6() {extern void f4(); // OK, name linkage (internal) and function type linkage (C language linkage)// obtained from previous declaration.} — *end example*]
+
+A C language linkage is ignored
+in determining the language linkage of
+class members,
+friend functions with a trailing [*requires-clause*](temp.pre#nt:requires-clause "13.1 Preamble [temp.pre]"), and the
+function type of non-static class member functions[.](#5.sentence-6)
+
+[*Example [3](#example-3)*: extern "C" typedef void FUNC_c();
+
+class C {void mf1(FUNC_c*); // the function mf1 and its type have C++ language linkage;// the parameter has type “pointer to C function'' FUNC_c mf2; // the function mf2 and its type have C++ language linkagestatic FUNC_c* q; // the data member q has C++ language linkage;// its type is “pointer to C function''};
+
+extern "C" {class X {void mf(); // the function mf and its type have C++ language linkagevoid mf2(void(*)()); // the function mf2 has C++ language linkage;// the parameter has type “pointer to C function''};} — *end example*]
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9271)
+
+If two declarations of an entity give it different language linkages, the
+program is ill-formed; no diagnostic is required if neither declaration
+is reachable from the other[.](#6.sentence-1)
+
+A redeclaration of an entity without a linkage specification
+inherits the language linkage of the entity and (if applicable) its type[.](#6.sentence-2)
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9279)
+
+Two declarations declare the same entity
+if they (re)introduce the same name,
+one declares a function or variable with C language linkage,
+and the other declares such an entity or declares a variable
+that belongs to the global scope[.](#7.sentence-1)
+
+[*Example [4](#example-4)*: 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 functionextern "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 linkageextern "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*]
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9307)
+
+A declaration directly contained in a[*linkage-specification*](#nt:linkage-specification "9.12 Linkage specifications [dcl.link]") is treated as if it contains theextern specifier ([[dcl.stc]](dcl.stc "9.2.2 Storage class specifiers")) for the purpose of determining the linkage of the
+declared name and whether it is a definition[.](#8.sentence-1)
+
+Such a declaration shall
+not have a [*storage-class-specifier*](dcl.stc#nt:storage-class-specifier "9.2.2 Storage class specifiers [dcl.stc]")[.](#8.sentence-2)
+
+[*Example [5](#example-5)*: extern "C" double f();static double f(); // errorextern "C" int i; // declarationextern "C" {int i; // definition}extern "C" static void g(); // error — *end example*]
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9327)
+
+[*Note [5](#note-5)*:
+
+Because the language linkage is part of a function type, when
+indirecting through a pointer to C function, the function to
+which the resulting lvalue refers is considered a C function[.](#9.sentence-1)
+
+— *end note*]
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/declarations.tex#L9334)
+
+Linkage from C++ to entities defined in other languages and to entities
+defined in C++ from other languages is implementation-defined and
+language-dependent[.](#10.sentence-1)
+
+Only where the object layout strategies of two
+language implementations are similar enough can such linkage be
+achieved[.](#10.sentence-2)