Stepping back a little, it's always been good practice to
declare functions, static or otherwise, before using them. (C99
makes this not just good practice, but a requirement.) And ever
since ANSI C appeared, it's been good practice to use prototypes
in function declarations and definitions. So the advice about
declaring functions applies to all functions, not just to static
functions.
Now to matters of layout, which is what your question really
boils down to. Non-static functions in "serious" programs should
usually be declared by including the associated headers, so all
you see in the .c source file is usually a few #include directives.
Static functions should almost never be declared in headers: You
made them static because you wanted their names to be visible only
inside one module, so why would you export those names to other
modules? Thus, static functions are usually declared differently
from external functions -- the declarations themselves look the
same, apart from `static', but their placement is different.
Two principal styles of arranging functions within a module
are commonly seen. One puts the top-level functions -- main(),
for example -- early in the file, with subordinate functions later
and low-level "leaf" functions last of all. In this style the
function's definition usually appears after at least one of its
calls, perhaps after all of them, so good practice (or C99's
mandate) calls for putting a separate declaration somewhere prior
to the first use. The top of the file is a pretty good location.
Some people (I'm one of them) dislike telling the compiler the
same thing twice; it irks us to declare that foo() takes two int
arguments and returns a double, and then turn right around and
write the actual definition of foo() with two int arguments and a
double result. When we get irked enough, we sometimes take advantage
of the fact that a function's definition can also serve as its
declaration: If the definition appears before the function's first
use, no separate declaration is needed. So we write the module
"upside-down" or "Pascal-style:" low-level "leaf" functions at the
top, followed by intermediate-level functions, and the Big Kahuna
last of all, each function declared by its own definition.
If you've got two or more mutually recursive functions -- f()
calls g() *and* g() calls f() -- you won't be able to use the
definitions-are-declarations strategy for all of them. If f()
appears first, its call to g() appears before the definition of g()
and you'll need to insert a separate declaration of g() somewhere
before f() in the file.
If we have all exported