Doubts about Linkage Rules

[fctk]

source: http://rm-f.net/~orange/devel/specif...t.html#3.1.2.2

there are two passages in this paragraph i can't fully understand:

1) "If the declaration of an identifier for an object or a function
contains the storage-class specifier extern , the identifier has the
same linkage as any visible declaration of the identifier with file
scope. If there is no visible declaration with file scope, the
identifier has external linkage."

in particular: "the identifier has the same linkage as /any/ /visible/
declaration of the identifier with file scope"

2) "If, within a translation unit, the same identifier appears with both
internal and external linkage, the behavior is undefined."

i can't imagine an example of an identifier having both internal and
external linkage...

[Vladimir S. Oka]

fctk wrote:

Vladimir S. Oka ha scritto:

Maybe you should try thinking about this particular example in this
way:

static int bar;

Tells the compiler that `bar` is "visible" only internally to the file
in question.

int bar;

Then tells the compiler that it is "visible" externally as well.

Logically, both can't be true at the same time, hence the error.

mmh... but i think there is another error. `static int bar' and `int
bar' are two *definitions* other than two declarations. they are two
definitions of the *same* object.

it is as if i wrote:

static void f1(void) {}
extern void f1(void) {}

isn't it?

Yes, that too. I was just pointing out the other discrepancy.

[fctk]

Diomidis Spinellis ha scritto:

It means that the following is a legal declaration of foo with file
linkage scope:

static int foo;
extern int foo;

[...]

Note that C99 clarifies the *visible* part of the specification as
follows (6.2.2):

"For an identifier declared with the storage-class specifier extern in a
scope in which a *prior* declaration of that identifier is visible, if
the prior declaration specifies internal or external linkage, the
linkage of the identifier at the later declaration is the same as the
linkage specified at the prior declaration. If no prior declaration is
visible, or if the prior declaration specifies no linkage, then the
identifier has external linkage."

sorry but i don't understand.

let me rewrite that example as follows:

static int foo; /* D1 */
/* S1 */
/* S1 */ extern int foo; /* D2 */
/* S1 */ /* S2 */

/* D1 */ : declaration1; first declaration of identifier `foo'
/* D2 */ : declaration2; second declaration of identifier `foo'
/* S1 */ : scope1; scope of the first declaration
/* S2 */ : scope2; scope of the second declaration

i don't understand this passage of the rule: "for an identifier declared
[...] in a scope in which a *prior* declaration of that identifier /is/
/visible/, [...]".

D2 is inside S1. let suppose S1 is "visible" to D2. the problem is D1 is
*not* inside S1, so D2 does not know the existence of D1.

this problem could be resolved by "extending" the scopes in the
following way:

/* S1 */static int foo; /* D1 */
/* S1 */
/* S1 */ /* S2 */ extern int foo; /* D2 */
/* S1 */ /* S2 */

all `foo's would have interal-linkage. (( question: but do the instance
of an identifier which occour in a declaration of that identifier have a
kind of linkage? ))

anyway, this "extension" would contract with this other rule:

"Structure, union, and enumeration tags have scope that begins [...].
Each enumeration constant has scope that begins [...]. Any other
identifier has scope that begins /just/ /after/ the completion of its
declarator."

[Flash Gordon]

Vladimir S. Oka wrote:

fctk wrote:

Vladimir S. Oka ha scritto:

Maybe you should try thinking about this particular example in this
way:

static int bar;

Tells the compiler that `bar` is "visible" only internally to the file
in question.

int bar;

Then tells the compiler that it is "visible" externally as well.

Logically, both can't be true at the same time, hence the error.

mmh... but i think there is another error. `static int bar' and `int
bar' are two *definitions* other than two declarations. they are two
definitions of the *same* object.

it is as if i wrote:

static void f1(void) {}
extern void f1(void) {}

isn't it?

Yes, that too. I was just pointing out the other discrepancy.

Actually no, they are both tentative definitions, where as you example
with functions shows definitions. For example, the following is
completely legal:

static int bar; /* tentative definition */
static int bar; /* tentative definition */
static int bar; /* tentative definition */
static int bar; /* tentative definition */
static int bar = 5; /* definition */

This defines only one object named bar which is of type int and is
initialised to 5.

From section 6.9.2 of n1124.pdf
| A declaration of an identifier for an object that has file scope
| without an initializer, and without a storage-class specifier or with
| the storage-class specifier static, constitutes a tentative
^^^^^^^^^
| definition. If a translation unit contains one or more tentative
^^^^^^^^^^
| definitions for an identifier, and the translation unit contains no
| external definition for that identifier, then the behavior is exactly
| as if the translation unit contains a file scope declaration of that
| identifier, with the composite type as of the end of the translation
| unit, with an initializer equal to 0.

Here is example 1 from the same section:
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 pre vious
int i2; // 6.2.2 renders undefined, linkage disagreement
int i3; // valid tentative definition, refers to pre vious
int i4; // valid tentative definition, refers to pre vious
int i5; // 6.2.2 renders undefined, linkage disagreement
extern int i1; // refers to pre vious, whose linkage is external
extern int i2; // refers to pre vious, whose linkage is internal
extern int i3; // refers to pre vious, whose linkage is external
extern int i4; // refers to pre vious, whose linkage is external
extern int i5; // refers to pre vious, whose linkage is internal

Note that there are only two problem lines in the above example, delete
(or correct) those two lines and it would be completely legal C99 (if
not for the // style comments it would be legal C89 as well).
--
Flash Gordon, living in interesting times.
Web site - http://home.flash-gordon.me.uk/
comp.lang.c posting guidelines and intro:
http://clc-wiki.net/wiki/Intro_to_clc

[Vladimir S. Oka]

Flash Gordon wrote:

Vladimir S. Oka wrote:

fctk wrote:

Vladimir S. Oka ha scritto:
Maybe you should try thinking about this particular example in this
way:

static int bar;

Tells the compiler that `bar` is "visible" only internally to the file
in question.

int bar;

Then tells the compiler that it is "visible" externally as well.

Logically, both can't be true at the same time, hence the error.

mmh... but i think there is another error. `static int bar' and `int
bar' are two *definitions* other than two declarations. they are two
definitions of the *same* object.

it is as if i wrote:

static void f1(void) {}
extern void f1(void) {}

isn't it?

Yes, that too. I was just pointing out the other discrepancy.

Actually no, they are both tentative definitions, where as you example
with functions shows definitions.

Right. I stand corrected on the variable part. Should've been more
careful.

After all, speed /is/ the device of shaitan.