C89: Compile-time constant required for initialiser?

[Tomás Ó hÉilidhe]

I've been developing a C89 microcontroller application for a while
now and I've been testing its compilation using gcc. I've gotten zero
errors and zero warnings with gcc, but now that I've moved over to the
micrcontroller compiler I'm getting all sorts of errors.

One thing I'd like to clarify is the need (in C89) for a compile-
time constant in the initialiser of a variable. The compiler rejects the
following source file:

/* Start foo.c */

int const a = 7;

int b = a;

/* End foo.c */
It says that the initialiser of "b" needs to be a compile-time
constant. Is it true that the initialiser of a non-const global object
needs to be a compile-time constant in C89? Or is this just a short
coming of the compiler?

Another related question:

/* Start bar.c */

void Func(void)
{
int const x = 7;

int const y = x;
}

/* End bar.c

In the snippet immediately above, the compiler fails because y's
initialiser isn't a compile-time constant. How does C89 view this? (If
"y" is made non-const, then the compiler accepts the code, but I'm
wondering if a _const_ local automatic variable's initialiser must be a
compile-time constant in C89?)

--
Tomás Ó hÉilidhe

[Thad Smith]

Tomás Ó hÉilidhe wrote:

One thing I'd like to clarify is the need (in C89) for a compile-
time constant in the initialiser of a variable. The compiler rejects the
following source file:

/* Start foo.c */

int const a = 7;
int b = a;

/* End foo.c */

It says that the initialiser of "b" needs to be a compile-time
constant. Is it true that the initialiser of a non-const global object
needs to be a compile-time constant in C89?

Yes. The same is true of C99. The declaration of a, above, has a
different meaning in C than C++.

Or is this just a short coming of the compiler?

No.

Another related question:

/* Start bar.c */
void Func(void)
{
int const x = 7;
int const y = x;
}
/* End bar.c

In the snippet immediately above, the compiler fails because y's
initialiser isn't a compile-time constant. How does C89 view this?

That is a valid initialization, assuming that y is not declared static.

(If "y" is made non-const, then the compiler accepts the code, but I'm
wondering if a _const_ local automatic variable's initialiser must be a
compile-time constant in C89?)

That looks like a compiler bug to me.

--
Thad

[pete]

Tomás Ó hÉilidhe wrote:

>
I've been developing a C89 microcontroller application for a while
now and I've been testing its compilation using gcc. I've gotten zero
errors and zero warnings with gcc, but now that I've moved over to the
micrcontroller compiler I'm getting all sorts of errors.

One thing I'd like to clarify is the need (in C89) for a compile-
time constant in the initialiser of a variable.
The compiler rejects the following source file:

/* Start foo.c */

int const a = 7;

int b = a;

/* End foo.c */

It says that the initialiser of "b" needs to be a compile-time
constant. Is it true that the initialiser of a non-const global object
needs to be a compile-time constant in C89?

Yes.
Here's the relevant concept:
global objects have static duration and therefore
are initialized before main starts executing.

Or is this just a short
coming of the compiler?

No.

Another related question:

/* Start bar.c */

void Func(void)
{
int const x = 7;

int const y = x;
}

/* End bar.c

In the snippet immediately above, the compiler fails because y's
initialiser isn't a compile-time constant. How does C89 view this?

It shouldn't be that way.
Func is useless, but flawless.

(If "y" is made non-const, then the compiler accepts the code,
but I'm wondering if a _const_ local automatic
variable's initialiser must be a compile-time constant in C89?)

No. Absolutely not.

char *str_cpy(char *s1, const char *s2)
{
char *const p1 = s1;

while ((*s1++ = *s2++) != '\0') {
;
}
return p1;
}

--
pete

[Ben Pfaff]

"Tomás Ó hÉilidhe" <to*@lavabit.co mwrites:

I've been developing a C89 microcontroller application for a while
now and I've been testing its compilation using gcc. I've gotten zero
errors and zero warnings with gcc, but now that I've moved over to the
micrcontroller compiler I'm getting all sorts of errors.

....

Is it true that the initialiser of a non-const global object
needs to be a compile-time constant in C89?

Yes. (GCC complains about this too. Are you sure that you
didn't compile your program as C++? C++ allows this.)

....

void Func(void)
{
int const x = 7;

int const y = x;
}

....

In the snippet immediately above, the compiler fails because y's
initialiser isn't a compile-time constant. How does C89 view this?

This code is fine.

(If "y" is made non-const, then the compiler accepts the code,
but I'm wondering if a _const_ local automatic variable's
initialiser must be a compile-time constant in C89?)

No, it need not be.
--
"Some programming practices beg for errors;
this one is like calling an 800 number
and having errors delivered to your door."
--Steve McConnell

[Tomás Ó hÉilidhe]

Thad Smith <Th*******@acm. orgwrote in
news:47******** *************** @auth.newsreade r.octanews.com:

> Another related question:

/* Start bar.c */
void Func(void)
{
int const x = 7;
int const y = x;
}
/* End bar.c

In the snippet immediately above, the compiler fails because y's
initialiser isn't a compile-time constant. How does C89 view this?

That is a valid initialization, assuming that y is not declared
static.

Is that to say that static variables within functions get exactly the same
treatment as global variables when it comes to initialisation? That is to
say, should I C89 compiler reject the following?:
void Func(void)
{
static int a = (0,2);
}

(I use the comma operator so as not to yield a compile-time constant).

--
Tomás Ó hÉilidhe

[pete]

Tomás Ó hÉilidhe wrote:

Is that to say that static variables within
functions get exactly the same
treatment as global variables when it comes to initialisation?

Yes.
Here's the relevant concept:
static variables within functions and global objects,
have static duration and therefore
are initialized before main starts executing.

That is to
say, should I C89 compiler reject the following?:

Yes.

void Func(void)
{
static int a = (0,2);
}

(I use the comma operator so as not to yield a compile-time constant).

--
pete

[pete]

pete wrote:

>
Tomás Ó hÉilidhe wrote:

Is that to say that static variables within
functions get exactly the same
treatment as global variables when it comes to initialisation?

Yes.
Here's the relevant concept:
static variables within functions and global objects,
have static duration and therefore
are initialized before main starts executing.

That is to
say, should I C89 compiler reject the following?:

Yes.

void Func(void)
{
static int a = (0,2);
}

(I use the comma operator
so as not to yield a compile-time constant).

Though,
the relevant concept doesn't explain what's wrong with (0,2),
so I'll stop repeating it.

--
pete

[Tomás Ó hÉilidhe]

pete <pf*****@mindsp ring.comwrote in news:47******** ***@mindspring. com:

Though,
the relevant concept doesn't explain what's wrong with (0,2),
so I'll stop repeating it.

What's wrong with (0,2)? It evaluates to an R-value whose type is int and
whose value is 2. Fair enough it's not a compile-time constant... but what
exactly are you saying is wrong with it?
--
Tomás Ó hÉilidhe

[pete]

Tomás Ó hÉilidhe wrote:

>
pete <pf*****@mindsp ring.comwrote in news:47******** ***@mindspring. com:

Though,
the relevant concept doesn't explain what's wrong with (0,2),
so I'll stop repeating it.

What's wrong with (0,2)?
It evaluates to an R-value whose type is int and whose value is 2.
Fair enough it's not a compile-time constant...
but what exactly are you saying is wrong with it?

It's not a "constant expression".
What I was getting at,
was that since objects with static duration
are initialised before main starts executing,
they need to be initialised with compile time constants.
However, the value of (0,2) is capable of being evaluated
at a glance, even before compile time,
and the only reason that it is not considered a
constant expression is because of the rules banning comma
operators from evaluated parts of constant expressions.

The problem is that there is no such term as
"compile-time constant" in the standard.
Where a "compile-time constant" is needed,
a "constant expression" is called for.

ISO/IEC 9899: 1990
6.5.7 Initialization
All the expressions in an initializer for an object that has static
storage duration or in an initializer list for an object that has
aggregate or union type shall be constant expressions.

But I think you knew that already.

--
pete

[Flash Gordon]

Tomás Ó hÉilidhe wrote, On 09/12/07 22:14:

I've been developing a C89 microcontroller application for a while
now and I've been testing its compilation using gcc. I've gotten zero
errors and zero warnings with gcc, but now that I've moved over to the
micrcontroller compiler I'm getting all sorts of errors.

<snip>

Something that others have not mentioned which may help you is that by
default gcc permits all sorts of extensions some of which are
incompatible with the C standard. To get it to follow the standard you
should use "gcc -ansi -pedantic" to get a lot more useful warnings try
"gcc -ansi -pedantic -Wall -Wextra".
--
Flash Gordon