3

Local function declaration seems to be permitted in gcc, and I found a discussion on this: Is there any use for local function declarations?

However, my question is: is it allowed by ISO C standard? If it is, how to explain the following phenomenon which makes it puzzling:

int main(void) {
    int f(void);
    f();
}
void g(void) {
    /* g has no idea about f. It seems that the decl is limited within its
     * scope */
    f(); 
}
int f(void) {}

while

int main(void) {
    int f(void);
    f();
}
void f(void); /* error because disagreement with the local declaration (local
             declaration goes beyound its scope?) */
void f(void) { /* definition here */ }

According to the C99 standard: function names are in the same naming category. So we shall discuss the scoping mechanism to explain this. But how?

Actually, I'm working on a compiler course project which requires us to implement a simplified version of C compiler. I was trying to deal with this case but got confused.

EDIT: I know it's a common knowledge that C is procedure-oriented and requires function names to be unique. But this local style of declaration stirs clear situation, and it's hard for me to understand its principle/rule.

Community
  • 1
  • 1
Determinant
  • 3,886
  • 7
  • 31
  • 47
  • 1
    You should parse it as "{local {function declaration}}", not "{{local function} declaration}". The declaration is local, not the function. – Kerrek SB Apr 07 '14 at 06:18
  • @KerrekSB I know that. But from the second example, we can see it also has some global effects. My question is how to explain it. – Determinant Apr 07 '14 at 06:24
  • [this](http://stackoverflow.com/q/22497876/2549281) may be helpfull – Dabo Apr 07 '14 at 06:43
  • @Determinant Sorry I misunderstood your question. Hence I've removed my answer. The function declaration in `main` and the function declaration outside it don't share scope. However, you have two declaration of different types with the same name. You can have only one function definition of `f`. – ajay Apr 07 '14 at 06:54
  • @ajay That's alright. Thanks anyway. :) – Determinant Apr 07 '14 at 06:57
  • @Determinant I think problem is not because of disagreement with the local declaration since they don't share scope. Problem is you can't call `f` in `main` as well as outside `main` since there can be only one definition of `f` and it cannot match both declaration as they have different return type. – ajay Apr 07 '14 at 07:09
  • @ajay Very interesting idea. So maybe the error message of gcc is too friendly for us to see through this? – Determinant Apr 07 '14 at 07:17
  • @Determinant That's very much possible because I don't see any other problem with your code. You should show us more code so that we can reproduce the error. That's the only way to fully diagnose the problem. – ajay Apr 07 '14 at 07:40
  • @ajay I didn't encounter any "problem". As I said in the question, I'm working on a simplified C compiler project (course homework). So it's important for me to understand the actual rule behind the scene. – Determinant Apr 07 '14 at 07:47

3 Answers3

4

Both ISO C and C++ permit local function declarations. In each case the scope of the function declaration ends at the end of the local scope. However, the function declaration and its definition have external linkage so they still need to be acceptable to the linker.

In your sample:

int main(void) {
 int f(void);
 f();
}
void f(void);
void f(void) {  }

This code compiles without error, as either C or C++. In C is should link (usually), but in C++ it will not (because of "typesafe linkage"). There will be an unresolved external for int f(void);.

[If this does not answer your question because of difficulties with your English, please clarify and I'll edit the answer.]

The C standard contains the following. n1570/S6.7.1/7:

The declaration of an identifier for a function that has block scope shall have no explicit storage-class specifier other than extern.

Clearly local function declarations are explicitly permitted.

n1570 S6.2.2/5 on external linkage:

If the declaration of an identifier for a function has no storage-class specifier, its linkage is determined exactly as if it were declared with the storage-class specifier extern. If the declaration of an identifier for an object has file scope and no storage-class specifier, its linkage is external.

So local function declarations have external linkage. This is obvious: if they had internal or no linkage, they could not link to anything.

david.pfx
  • 10,520
  • 3
  • 30
  • 63
  • I see. So you mean it is an exceptional situation? I'm curious about why I can't find any description on this in C99 standard document. – Determinant Apr 07 '14 at 13:38
  • Thanks. One last question: where is the description of "function declaration and its definition have external linkage" in standard? – Determinant Apr 07 '14 at 14:18
  • Sorry for my impatience of reading the document. Got it eventually. Thanks! – Determinant Apr 07 '14 at 15:21
  • Came across a library that conditionally puts this section of code in namespace when compiled in c++. Does the c++ standard specify the namespace of the local function? MSVC in vs2022 seems to resolve to global namespace for local functions? – shangjiaxuan Oct 15 '22 at 17:08
  • @shangjiaxuan: That's a new question and needs to asked as such. – david.pfx Oct 16 '22 at 22:57
0

To fix the second example you need to declare f in main with proper return type

int main(void) {
    void f(void);  // function declaration
    f(); // calling function
}  // scope of f ends here

void f(void) {}

This way you inform compiler what to look for, and later it finds it indeed. Hope it helps.

Dabo
  • 2,371
  • 2
  • 18
  • 26
  • 1
    Since the scope of `f` ends, how does it conflict with global declaration? I know it's a common sense that C is procedure oriented and require function name to be unique. But this local style of declaration stir the clear situation, and it's hard for me to understand its rule. – Determinant Apr 07 '14 at 06:59
  • you just need to inform compiler before you use the function what kind of function it is. You can put global prototype prior to `main`, you can define the function it self before you use it, or you can put local declaration with proper return type, these are all legal ways to make things work – Dabo Apr 07 '14 at 07:05
  • by the way this is clear to you why you have error when your function prototype does not correlate with function definition, for example you have `int foo(void);` prototype and `char foo(void){}` function. You declare something, but later it is not defined. It is exactly the same with local function declaration. You declare there is `f` returning `int` but there is no such `f`. – Dabo Apr 07 '14 at 07:12
  • Well..Sorry, but I think you don't understand my question very clearly. I shall apologise my poor Enligsh.. – Determinant Apr 07 '14 at 07:19
0

Local extern declarations indeed work just like ones outside the function except with limited scope, or alternately just like local static declarations except that the entity is externally accessible by linkage.

Why? Well, why not? It's just an extrapolation of the general rules for declarations and the extern specifier into a specific context.

I can't recall ever (purposely) using a local extern function declaration, but a few times I've hacked in a debugging variable using a local extern variable declaration. The extern declaration can be placed in some highly nested code and pass data to a debug printer in another TU.

Potatoswatter
  • 134,909
  • 25
  • 265
  • 421