Initializer element not computable at load time

[Clint Olsen]

What about the following is not computable? It seems that the size of foo
is easily computable:

typedef struct {
char *name;
char *data;
} Foo;

int main(void)
{
char data[] = { 'a', 'b', 'c', 'd' };

Foo foo = { "bar", data };

return 0;
}

Thanks,

-Clint

[Joe Wright]

Clint Olsen wrote:

What about the following is not computable? It seems that the size of foo
is easily computable:

typedef struct {
char *name;
char *data;
} Foo;

int main(void)
{
char data[] = { 'a', 'b', 'c', 'd' };

Foo foo = { "bar", data };

return 0;
}

I works here. What seems to be the problem?
--
Joe Wright http://www.jw-wright.com
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

[Eric Sosman]

Clint Olsen wrote:

What about the following is not computable? It seems that the size of foo
is easily computable:

typedef struct {
char *name;
char *data;
} Foo;

int main(void)
{
char data[] = { 'a', 'b', 'c', 'd' };

Foo foo = { "bar", data };

return 0;
}

The size of `foo' is known, yes. What's not known is
the address of the automatic ("stack-resident," on many
implementations) variable `data'.

--
Er*********@sun.com

[CBFalconer]

Clint Olsen wrote:

What about the following is not computable? It seems that the
size of foo is easily computable:

typedef struct {
char *name;
char *data;
} Foo;

int main(void)
{
char data[] = { 'a', 'b', 'c', 'd' };
Foo foo = { "bar", data };
return 0;
}

The size is, but the contents are not (at compilation time). data
is a local variable (automatic), and where it will be located is
not known until main runs. Thus the initializer is NOT a compile
time constant.

If you declare data outside of main, as static, then the address
will be computable.

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[Irrwahn Grausewitz]

Eric Sosman <Er*********@sun.com> wrote:

Clint Olsen wrote:

What about the following is not computable? It seems that the size of foo
is easily computable:

typedef struct {
char *name;
char *data;
} Foo;

int main(void)
{
char data[] = { 'a', 'b', 'c', 'd' };

Foo foo = { "bar", data };

return 0;
}

The size of `foo' is known, yes. What's not known is
the address of the automatic ("stack-resident," on many
implementations) variable `data'.

In C89 this is certainly true, but in C99 it _seems_ to be allowed,
but unfortunately I'm unable to find a corresponding section in the
standard. Maybe someone can help out with a quote? Thanks.

Regards
--
Irrwahn
(ir*******@freenet.de)

[Jack Klein]

On Sat, 18 Oct 2003 01:44:49 +0200, Irrwahn Grausewitz
<ir*******@freenet.de> wrote in comp.lang.c:

Eric Sosman <Er*********@sun.com> wrote:

Clint Olsen wrote:

What about the following is not computable? It seems that the size of foo
is easily computable:

typedef struct {
char *name;
char *data;
} Foo;

int main(void)
{
char data[] = { 'a', 'b', 'c', 'd' };

Foo foo = { "bar", data };

return 0;
}

The size of `foo' is known, yes. What's not known is
the address of the automatic ("stack-resident," on many
implementations) variable `data'.

In C89 this is certainly true, but in C99 it _seems_ to be allowed,
but unfortunately I'm unable to find a corresponding section in the
standard. Maybe someone can help out with a quote? Thanks.

Regards

C90 said this in the constraints section of 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
========

C99 says this in the constraints section of 6.7.8, "Initialization":

========
All the expressions in an initializer for an object that has static
storage duration shall be constant expressions or string literals.
========

So initializing an aggregate (array or structure) or union type with a
non-constant expression is no longer a constraint violation provided
the aggregate does not have static storage duration.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++ ftp://snurse-l.org/pub/acllc-c++/faq

[Irrwahn Grausewitz]

Jack Klein <ja*******@spamcop.net> wrote:

On Sat, 18 Oct 2003 01:44:49 +0200, Irrwahn Grausewitz
<ir*******@freenet.de> wrote in comp.lang.c:

Eric Sosman <Er*********@sun.com> wrote: <snip>

> The size of `foo' is known, yes. What's not known is
>the address of the automatic ("stack-resident," on many
>implementations) variable `data'.

In C89 this is certainly true, but in C99 it _seems_ to be allowed,
but unfortunately I'm unable to find a corresponding section in the
standard. Maybe someone can help out with a quote? Thanks.

C90 said this in the constraints section of 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
========

C99 says this in the constraints section of 6.7.8, "Initialization":

========
All the expressions in an initializer for an object that has static
storage duration shall be constant expressions or string literals.
========

So initializing an aggregate (array or structure) or union type with a
non-constant expression is no longer a constraint violation provided
the aggregate does not have static storage duration.

Hmpf, I read the whole section but didn't read _between_ the lines.

Thank you very much.
--
Irrwahn
(ir*******@freenet.de)