Handling 'initializer element not constant' error

[Gowtham]

Hi,

I had some C code written which initialized a global variable as:

FILE *yyerfp = stdout;

This used to work fine in older versions of gcc. Now, when I tried to
compile this code (with gcc 3.2.3),
I got errors like:

.../Include/Message.h:42: initializer element is not constant

I looked around the www and found that stdin/stdout/stderr are *not*
made const in the newer
versions of gcc.

As a work-around, I thought of this:

FILE *yyerfp; // Uninitialized global

// Initialize it in a separate function
void initializeGloba ls( void )
{
yyerfp = stdout;
}

int main( ... )
{
// Initialize the global before doing anything else
initializeGloba ls();
...
// Do other things
}

But, this code will also be compiled into a shared object, dynamically
loadable from other
languages such as perl etc. and I do not want to change the API
interface there. If I follow
this approach, I also have to add the initializeGloba ls() call in
every perl program which uses
this library.

What is the best way of solving this problem?

Thanks
Gowtham

[Richard Tobin]

In article <29************ *************** *******@l42g200 0hsc.googlegrou ps.com>,
<vi******@gmail .comwrote:

>I have not read much on alternative solutions to errno in C, so is
there a better solution?
Returning the error code is not possible (like pthreads) and an extra
parameter to every function that can fail would be quite annoying.

The C standard recognises the problems with errno and doesn't require
it to be an identifier. It just has to be a macro that produces a
modifiable lvalue. So a threaded implementation can do something
like

#define errno (*__thread_errn o())

where __thread_errno( ) returns a pointer to a per-thread variable.

-- Richard
--
:wq

[Ben Pfaff]

ri*****@cogsci. ed.ac.uk (Richard Tobin) writes:

The C standard recognises the problems with errno and doesn't require
it to be an identifier.

It's definitely an identifier. However, it might not be the name
of a variable with external linkage.
--
"I hope, some day, to learn to read.
It seems to be even harder than writing."
--Richard Heathfield

[Richard Tobin]

In article <87************ @blp.benpfaff.o rg>,
Ben Pfaff <bl*@cs.stanfor d.eduwrote:

>The C standard recognises the problems with errno and doesn't require
it to be an identifier.

>It's definitely an identifier.

Obviously "errno" is an identifier. I should have said that it's a
macro that doesn't have to expand to an identifier.

>However, it might not be the name of a variable with external linkage.

It might not expand to the name of a variable at all.

-- Richard
--
:wq

[dj3vande]

In article <87************ @blp.benpfaff.o rg>,
Ben Pfaff <bl*@cs.stanfor d.eduwrote:

>ri*****@cogsci .ed.ac.uk (Richard Tobin) writes:

>The C standard recognises the problems with errno and doesn't require
it to be an identifier.

It's definitely an identifier. However, it might not be the name
of a variable with external linkage.

errno is explicitly allowed to be a macro (n869 7.5#2).
A brief look through the definitions in n869 indicates that a macro
name is indeed covered under the standardese use of "identifier ", but
it seems that referring to a macro as an identifier in informal use is
gratuitiously confusing, especially when what the macro expands to need
not be an identifier.
dave

--
Dave Vandervies dj3vande at eskimo dot com
I would definitely not be sure that it does what the programmer
intended, even if the programmer was me.
--Christian Bau in comp.lang.c

[Ben Pfaff]

ri*****@cogsci. ed.ac.uk (Richard Tobin) writes:

In article <87************ @blp.benpfaff.o rg>,
Ben Pfaff <bl*@cs.stanfor d.eduwrote:

>>The C standard recognises the problems with errno and doesn't require
it to be an identifier.

>>It's definitely an identifier.

Obviously "errno" is an identifier. I should have said that it's a
macro that doesn't have to expand to an identifier.

>>However, it might not be the name of a variable with external linkage.

It might not expand to the name of a variable at all.

Right. That's one way that it might not be the name of a
variable with external linkage.
--
char a[]="\n .CJacehknorstu" ;int putchar(int);in t main(void){unsi gned long b[]
={0x67dffdff,0x 9aa9aa6a,0xa77f fda9,0x7da6aa6a ,0xa67f6aaa,0xa a9aa9f6,0x11f6} ,*p
=b,i=24;for(;p+ =!*p;*p/=4)switch(0[p]&3)case 0:{return 0;for(p--;i--;i--)case+
2:{i++;if(i)bre ak;else default:continu e;if(0)case 1:putchar(a[i&15]);break;}}}

[Flash Gordon]

Richard Tobin wrote, On 07/05/08 23:29:

In article <29************ *************** *******@l42g200 0hsc.googlegrou ps.com>,
<vi******@gmail .comwrote:

>I have not read much on alternative solutions to errno in C, so is
there a better solution?
Returning the error code is not possible (like pthreads) and an extra
parameter to every function that can fail would be quite annoying.

The C standard recognises the problems with errno and doesn't require
it to be an identifier. It just has to be a macro that produces a
modifiable lvalue. So a threaded implementation can do something
like

#define errno (*__thread_errn o())

where __thread_errno( ) returns a pointer to a per-thread variable.

One real example of this is current versions of glibc where after a bit
of digging I get
# define errno (* __errno_locatio n ())
--
Flash Gordon

[Szabolcs Borsanyi]

Assuming the OP can change the code of the library, he could

initialise yyerfp to NULL and replace all the uses of it with

(yyerfp ? yyerfp : stdout)

It's a pity there isn't a standard way to get initialisation code run.

-- Richard

I'd mention here a few more poins:
- <OFF>The OP want's to initialise his shared library
(although he could avoid it with a different design). [he can
be she]
This is usally possible on a decent operating system by
defining
a function with a magic name.
</OFF>
- Global objects are not quite unusual animals (especially if they are
constant)
and one can design them using e.g. a variant of the singleton
pattern.
In C that would be to define a pointer-to-function, and one can
indeed initialise that
to an other function. In this case:

FILE *yyerrf_default () { return stdout; }
static FILE *yyerrf_ptr;
FILE *yyerrf_user() { return yyerrf_ptr; }
FILE *(*yyerrf)()=yy errf_default;
void yyerrf_set(FILE *F) { yyerrf_ptr=F; yyerrf=yyerrf_u ser; }
#define yyerrf yyerrf() // protected // don't yell // is legal in
c99
#define yyerrf_ptr // protected

(This is a slightly overcomplicated singleton, but of some
unjustified reasons I avoid conditionals.)

Szabolcs