[comp.std.c] linkage specifiers

daniel@terra.ucsc.edu (04/04/91)

What does it mean for an extern linkage specifier
to refer to a non-file scope object?

For example:

	int foo = 2;

	int bar(int foo)
	{
		{
			extern int foo;

			return foo;
		}
	}

Paraphrased from 3.1.2.2: 
  ''If the declaration of an identifier ... contains "extern", the
	identifier has the same linkage as any visible declaration
	of the identifier with file scope.''

This sentence clearly does not apply, because the file-scope 
declaration is not visible; the parameter declaration hides it.

To what object does the extern declaration refer?
It appears to refer to the parameter declaration. 
Is this necessarily the case? Could it denote some
as-yet-unseen file-scope object having external linkage?

Daniel Edelson

diamond@jit345.swstokyo.dec.com (Norman Diamond) (04/04/91)

In article <14094@darkstar.ucsc.edu> daniel@terra.ucsc.edu () writes:
>What does it mean for an extern linkage specifier
>to refer to a non-file scope object?
No meaning.  It cannot do so.

>	int foo = 2;
>	int bar(int foo) {
>		{ extern int foo; return foo; }
>	}
>Paraphrased from 3.1.2.2: 
>  ''If the declaration of an identifier ... contains "extern", the
>	identifier has the same linkage as any visible declaration
>	of the identifier with file scope.''
>This sentence clearly does not apply,
It's not clear to me.
>because the file-scope declaration is not visible;
>the parameter declaration hides it.
Ahhh... you are right, because the first paragraph of section 3.1.2.1
defines visibility.

>To what object does the extern declaration refer?
It must be a declaration of an object with external linkage.
Now, the first foo is also an object with external linkage, so it ends
up being the same object, indirectly.

A more interesting case would be if the first foo were declared static.
Then the third one (the external one) could not be the same as the
first one (the internal one).  However, it still could not be the second
one (the parameter).

>It appears to refer to the parameter declaration. 
>Is this necessarily the case?
Exactly the opposite.  This is necessarily NOT the case.  Always.
Parameters do not have file scope.

>Could it denote some as-yet-unseen file-scope object having external linkage?
Not in this case, but it is possible.  For example:
  int bar(int foo) { { extern int foo; return foo } }
  extern int foo;
Again, the two extern declarations denote the same object, but that is an
indirect result, not due to the quoted part of 3.1.2.2.
--
Norman Diamond       diamond@tkov50.enet.dec.com
If this were the company's opinion, I wouldn't be allowed to post it.