6.2 New-Style Function Prototypes

The 1990 ISO C standard’s most sweeping change to the language is the function prototype borrowed from the C++ language. By specifying the number and types of parameters for each function, every regular compile gets the benefits of argument and parameter checking (similar to those of lint) for each function call, while arguments are automatically converted (just as with an assignment) to the type expected by the function. The 1990 ISO C standard includes rules that govern the mixing of old- and new-style function declarations since there are many, many lines of existing C code that could and should be converted to use prototypes.

The 1999 ISO C standard made old-style function declarations obsolete.

6.2.1 Writing New Code

When you write an entirely new program, use new-style function declarations (function prototypes) in headers and new-style function declarations and definitions in other C source files. However, if someone might port the code to a system with a pre-ISO C compiler, use the macro __STDC__ (which is defined only for ISO C compilation systems) in both header and source files. Refer to 6.2.3 Mixing Considerations for an example.

An ISO C-conforming compiler must issue a diagnostic whenever two incompatible declarations for the same object or function are in the same scope. If all functions are declared and defined with prototypes and the appropriate headers are included by the correct source files, all calls should agree with the definition of the functions. This protocol eliminates one of the most common C programming mistakes.

6.2.2 Updating Existing Code

If you have an existing application and want the benefits of function prototypes, a number of possibilities for updating exist, depending on how much of the code you would like to change:

1. Recompile without making any changes.

   Even with no coding changes, the compiler warns you about mismatches in parameter type and number when invoked with the– v option.

2. Add function prototypes only to the headers.

   All calls to global functions are covered.

3. Add function prototypes to the headers and start each source file with function prototypes for its local (static) functions.

   All calls to functions are covered, but this method requires typing the interface for each local function twice in the source file.

4. Change all function declarations and definitions to use function prototypes.

For most programmers, choices 2 and 3 are probably the best cost/benefit compromise. Unfortunately, these options are precisely the ones that require detailed knowledge of the rules for mixing old and new styles.

6.2.3 Mixing Considerations

For function prototype declarations to work with old-style function definitions, both must specify functionally identical interfaces or have compatible types using ISO C’s terminology.

For functions with varying arguments, you cannot mix ISO C’s ellipsis notation and the old-style varargs() function definition. For functions with a fixed number of parameters, you can specify the types of the parameters as they were passed in previous implementations.

In K&R C, each argument was converted just before it was passed to the called function according to the default argument promotions. These promotions specified that all integral types narrower than int were promoted to int size, and any float argument was promoted to double, which simplified both the compiler and libraries. Function prototypes are more expressive, as the specified parameter type is what is passed to the function.

Thus, if a function prototype is written for an existing (old-style) function definition,the function prototype should not contain any parameters with any of the following types: char, signed char, unsigned char, float, short, signed short, unsigned short.

Two complications remain with writing prototypes: typedef names and the promotion rules for narrow unsigned types.

If parameters in old-style functions were declared using typedef names, such as off_t and ino_t, you must know whether the typedef name designates a type that is affected by the default argument promotions. For these two, off_t is a long, you can use it in a function prototype; ino_t used to be an unsigned short, so if it were used in a prototype, the compiler issues a diagnostic because the old-style definition and the prototype specify different and incompatible interfaces.

Determining what should be used instead of an unsigned short is complicated. The biggest incompatibility between K&R C and the 1990 ISO C compiler is the promotion rule for the widening of unsigned char and unsigned short to an int value. (See 6.4 Promotions: Unsigned Versus Value Preserving.) The parameter type that matches this old-style parameter depends on the compilation mode used when you compile:

• -Xs and– Xt should use unsigned int

• –Xa and– Xc should use int

The best approach is to change the old-style definition to specify either int or unsigned int and use the matching type in the function prototype. You can always assign its value to a local variable with the narrower type, if necessary, after you enter the function.

Be carefule about the use of ID’s in prototypes that may be affected by preprocessing. Consider the following example:

#define status 23
void my_exit(int status);   /* Normally, scope begins */
                            /* and ends with prototype */

Do not mix function prototypes with old-style function declarations that contain narrow types.

void foo(unsigned char, unsigned short);
void foo(i, j) unsigned char i; unsigned short j; {...}

Appropriate use of __STDC__ produces a header file that can be used for both the old and new compilers:

header.h:
    struct s { /* .  .  .  */ };
    #ifdef __STDC__
       void errmsg(int, ...);
       struct s *f(const char *);
       int g(void);
    #else
      void errmsg();
      struct s *f();
      int g();
    #endif

The following function uses prototypes and can still be compiled on an older system:

struct s *
#ifdef __STDC__
    f(const char *p)
#else
    f(p) char *p;
#endif
{
    /* .  .  .  */
}

The following example shows an updated source file (as with choice 3 above). The local function still uses an old-style definition, but a prototype is included for newer compilers:

source.c:
   #include “header.h”
      typedef /* .  .  .  */ MyType;
   #ifdef __STDC__
      static void del(MyType *);
      /* .  .  .  */
      static void
      del(p)
      MyType *p;
      {
      /* .  .  .  */
      }
      /* .  .  .  */