Missing function information: implicit function prototyping

Operation of a C compiler

There are 2 kinds of compilers:

Two-pass compilers:

The compiler reads the source code twice to compile (= translate) the program
In the 1st pass, the compiler will:

In the 2nd pass, the compiler will:

Use the gathered information on the variables and functions to translate the function calls
(E.g., insert the necessary conversion instructions if the data types are mismatched)

One-pass compilers:

The compiler reads the source code once to compile (= translate) the program
In an one-pass compiler, the compiler will:

Advantages and disadvantages of one-pass and two-pass compilers

Two-pass compilers:

The compiler will have available information on all defined functions before the compiler starts translation the function calls
However: the compilation time is longer (because the compiler will read the source program twice)

One-pass compilers:

The compilation time is shorter (because the compiler will read the source program only once)

However: the compiler will not have the information on functions that are defined after its function call !!!

Example:

int main( int argc, char *argv[] ) { double a, b; a = 4.0; b = square( a ); // <---- Compiler do NOT know: // 1. the data type of the parameter // 2. the data type of the return value } double square( double x ) // ONLY NOW the compiler can find the data types { double r; // Define a local variable r = x * x; // Statement return ( r ); // Return statement }

Examples of one-pass and two-pass compilers
- Two-pass compiler:
- One-pass compiler:

Missing function definition...

64,000 question:

What should the compiler do when it needs to translate a function call and it does not have information on the data type of the parameters and return value:

int main( int argc, char *argv[] ) { double a, b; a = 4.0; b = square( a ); // <---- What to do ??? } .....

Possible answers:

Stop and report an error

Make an assumption on the data type of the parameters and the return value

(and translate the function call using this assumption)

This is the choice made in the C compiler !!!!!!!!
(Historical reason: Kerrighan and Ritchie designed C to write UNIX. Most functions that they wrote had int typed parameters. So they made C make this assumption to save time....)

Implicit function prototyping

When the (original) C compiler encounter the use of a function for the first time, it will:

Check whether the function has been defined or declared
If the function has define or declared, the C compiler will use the given function prototype in performing the translation
If the function has not been define or declared, the C compiler will make the following function prototype assumption:

(This was what I learn back in 1980 or so....)

Note:

Apparently the GNU C compiler (gcc) made a different assumption:

Consequence of this practice....

Example: missing function prototype information

int main( int argc, char *argv[] ) { double a, b; a = 4.0; b = square( a ); // <---- First use // square() has not been defined yet !!! // The GNU C compiler will assume it is: int square(double) !!! } double square( double x ) // Now the C ompiler detects that the assumption was wrong { double r; // Define a local variable r = x * x; // Statement return ( r ); // Return statement }

Observation:

The function square() havs not been defined before they were used
(Their definitions appears after they were used !!!)

Therefore, the C compiler does not know the data types of the parameters (and return value) and:

The C compiler will make the implicit assumptions that the data type of the parameters (and return value) are integers !!!

Consequence:

When you compile the above program, you will get the following compiler error:
The implicit declaration is the assumption that the C compiler made on the data types of the parameters

Example Program: (Demo above code)
- Prog file: click here
How to run the program: