C89 and variable initialization

Question

C89 (C90, ANSI-C) does not allow intermixing variables declaration with code. I wonder to what extent a variable initialization is considered "code".

Perhaps it's only valid to initialize with constant expressions?

Specifically, if I'm writing C code and I want to play safe (maximize compatibility with ANSI-C compilers), should the following be considered safe?

  void f1(void) { 
      int x = 30;
      int y = 40;
      int z;
      /* ... */
  }

  void f2(void) { 
      int x = 30, y = 40;
      int z;
      /* ... */
  }

  #define MYCONST (90)
  void f3(void) { 
      int x = 3; 
      int y = 4 + MYCONST;
      int z;
      /* ... */
  }

  void f4(void) { 
      int x = 3;
      int y = time(NULL);
      int z = 10 + x;
      /* ... */
  }

Answer 1

should the following be considered safe?

All of your posted code is safe.

1. You may have any number of variable declarations in any scope.
2. The code to initialize the variables may use any method the language provides.

However, it is not legal to declare a variable after code that is not variable declaration.

void foo()
{
   int i = 0;
   i = 2;      // Does not declare a variable.
   int j = 10; // Not legal.
}

The above code works with gcc. However, if you use the -pedantic flag, you will see a warning message that will look something like:

soc.c:5:4: warning: ISO C90 forbids mixed declarations and code [-Wpedantic]
    int j = 10;

Answer 2

C89 does not allows mixing declarations and statements in the same scope. We are referring here to declarations and statements inside functions as statements are not allowed outside functions in C.

int a = foo(a, b);  /* declared at block-scope */

The line above is a (valid C89) declaration, not a statement so all your functions f1, f2, f3, and f4 are valid C89.

However you are allowed to mix declarations and statements in different scopes:

void bar(void)
{
    int i = 0;  /* declaration */
    i++;  /* statement */
    {
        int j = 0;  /* declaration */
        j++;  /* statement */
     }
 }

The function above is valid C89.

Answer 3

The Foreword to the C99 standard itself mentions "mixed declarations and code" as one of the changes from C90. This was IMHO a poor choice of words, since it's not at all clear what "code" means. It can easily refer to everything that can appear in a C source file.

The actual change that was made by C99 was to permit mixing of declarations and statements within a block. The distinction between a declaration and a statement is unambiguously defined by the language syntax.

The line from one of your examples:

int y = time(NULL);

is a declaration, not a statement, even though it results in the execution of some code at run time. The presence or absence of an initializer, and whether that initializer is a constant expression or not, does not affect whether something is considered to be a declaration.

All four of the examples in your question are valid in C89/C90, in C99, and in C11. In each case, the block contains just declarations, no statements.

If you want to mix declarations and statements in C90, you do so by introducing nested blocks:

void func(void) {
    int x = 1; /* a declaration */
    x = 2;     /* a statement; no declarations may follow in C90 */
    {
        int y = 3; /* a declaration */
        y = 4;     /* a statement */
    }
}

The inner block it itself a statement. Because it's a statement, it can appear in that context. Because it's a compound statement, it can itself contain a sequence of declarations followed by a sequence of statements.

Even in C99 or C11, it can be advantageous to introduce nested blocks like this. The scope and lifetime of y end at the closing } of the block that contains its declaration. Restricting the scope of a declaration can make code easier to understand.

(A bit of background: C89 was the standard released by ANSI in 1989. ISO adopted it, with some changes in the document but not in the language it describes, as C90. ISO published an updated standard, C99, which was then adopted by ISO. ISO published another updated standard, C11, which was also adopted by ANSI. According to both ANSI and ISO, the 2011 standard is the current one, and all earlier editions are obsolete. But for historical reasons, the phrase "ANSI C" usually refers to the language described by the 1989 and 1990 editions. I usually try to avoid the phrase "ANSI C", referring instead to "ISO C", plus the publication year if it's relevant.)

Answer 4

All of your examples are legal and can safely be used with conforming ANSI-C compilers.

Compiling your code in gcc with -std=c89 and -pedantic generates no warnings.

Answer 5

F1, f2, f3 are valid but f4 is not since the declaration and definition are mixed