Initializing enum with strings

[Russell Shaw]

Hi,
gcc-3.4 complains about non-integers in:

enum {IDENTIFIER = "<identifier>", WIDGETDEF = "widgetdef"};

even if i cast the strings to integers.

[Richard Bos]

Russell Shaw <rjshawN_o@s_pam.netspace.net.au> wrote:

gcc-3.4 complains about non-integers in:

enum {IDENTIFIER = "<identifier>", WIDGETDEF = "widgetdef"};
And so it should. Enumeration constants can only have integral values.
If you want enum constants with string values, you're probably trying to
do something which you needn't, or shouldn't, do. Why would you need
such constants in the first place?
even if i cast the strings to integers.

That doesn't even make sense. What would you cast to integer, a pointer
to a string literal? That's possible, in theory - but it doesn't make
sense. The value will be useless.

Richard

[Chris Dollin]

Russell Shaw wrote:

Hi,
gcc-3.4 complains about non-integers in:

enum {IDENTIFIER = "<identifier>", WIDGETDEF = "widgetdef"};

even if i cast the strings to integers.

Well, what did you expect?

The enum identifiers have integer values. Casting a string
to an integer doesn't get you anything terribly interesting
or reliable.

--
Chris "electric hedgehog" Dollin
It's called *extreme* programming, not *stupid* programming.

[Russell Shaw]

Richard Bos wrote:

Russell Shaw <rjshawN_o@s_pam.netspace.net.au> wrote:

gcc-3.4 complains about non-integers in:

enum {IDENTIFIER = "<identifier>", WIDGETDEF = "widgetdef"};

And so it should. Enumeration constants can only have integral values.
If you want enum constants with string values, you're probably trying to
do something which you needn't, or shouldn't, do. Why would you need
such constants in the first place?

Because i'm using the constants in a lexer, and they can do double duty
for error message printouts. I need to use them multiple places in the
code, and if i use the strings directly, i'm not guaranteed to get the
same pointer value every time.

even if i cast the strings to integers.

That doesn't even make sense. What would you cast to integer, a pointer
to a string literal? That's possible, in theory - but it doesn't make
sense. The value will be useless.

Richard

char *str = "abcd"; declares a pointer to a string, so i wanted to
use pointers like this as inits for the enum.

[William Ahern]

Russell Shaw <rjshawN_o@s_pam.netspace.net.au> wrote:

Hi,
gcc-3.4 complains about non-integers in:

enum {IDENTIFIER = "<identifier>", WIDGETDEF = "widgetdef"};

even if i cast the strings to integers.

Enum's can't be pointers, only integers. The typical solution is to map
the enum string description to the enum itself using an array:

In C89, assuming your enums are sequential and start from zero

const char *enummap[] = {
"<identifier>",
"widgetdef",
};

and in C99, assuming nothing but the usual constraints

const char *enummap[] = {
.[WIDGETDEF] = "widgetdef",
.[IDENTIFIER] = "<identifier>",
};

(Note that the array will be as large as your largest enum, so this might
not work out well if your enums are meant to be utilized bitwise.)

- Bill

[Me]

> >>gcc-3.4 complains about non-integers in:

enum {IDENTIFIER = "<identifier>", WIDGETDEF = "widgetdef"};

And so it should. Enumeration constants can only have integral values.
If you want enum constants with string values, you're probably trying to
do something which you needn't, or shouldn't, do. Why would you need
such constants in the first place?

Because i'm using the constants in a lexer, and they can do double duty
for error message printouts. I need to use them multiple places in the
code, and if i use the strings directly, i'm not guaranteed to get the
same pointer value every time.

const char * const IDENTIFIER = "<identifier>";

Now you are guaranteed (and you really don't want to use the string
constant directly anyway, your compiler can't warn against inadvertant
typos that way). Even if your implementation allows something that
questionable, it doesn't guarantee they can be casted back to a string
or even that are distinct values when casted to an integer type. For
what you're trying to do, I would probably do something like:

#define TOKEN(F) \
F(IDENTIFIER, "<identifier>") \
F(WIDGETDEF, "widgetdef")

#define tok(a,b) a = b,
enum Token {
TOKEN(tok)
NUM_TOKENS
};
#undef tok

#define tok(a,b) b,
const char * const token2str[NUM_TOKENS] = {
TOKEN(tok)
};
#undef tok

[Lawrence Kirby]

On Tue, 05 Jul 2005 19:17:01 -0700, Me wrote:

>>gcc-3.4 complains about non-integers in:
>>
>>enum {IDENTIFIER = "<identifier>", WIDGETDEF = "widgetdef"};
>
> And so it should. Enumeration constants can only have integral values.
> If you want enum constants with string values, you're probably trying to
> do something which you needn't, or shouldn't, do. Why would you need
> such constants in the first place?

Because i'm using the constants in a lexer, and they can do double duty
for error message printouts. I need to use them multiple places in the
code, and if i use the strings directly, i'm not guaranteed to get the
same pointer value every time.

const char * const IDENTIFIER = "<identifier>";

However you're creating an unnecessary pointer object here. Better is:

static const char IDENTIFIER[] = "<identifier>";

A string literal is essentially an unnamed static array of char, all you
need to do is create a named version, as this does.

Lawrence

[Dave Thompson]

On 5 Jul 2005 19:17:01 -0700, "Me" <an*****************@yahoo.com>
wrote:

<snip> For what you're trying to do, I would probably do something like:

#define TOKEN(F) \
F(IDENTIFIER, "<identifier>") \
F(WIDGETDEF, "widgetdef")

#define tok(a,b) a = b,
enum Token {
TOKEN(tok)
NUM_TOKENS
};
#undef tok

#define tok(a,b) b,
const char * const token2str[NUM_TOKENS] = {
TOKEN(tok)
};
#undef tok

Obviously you meant #define tok(a,b) a, in the first case
and #define tok(a,b) [a] = b, or just b, in the second.

- David.Thompson1 at worldnet.att.net

[Russell Shaw]

Dave Thompson wrote:

On 5 Jul 2005 19:17:01 -0700, "Me" <an*****************@yahoo.com>
wrote:

<snip> For what you're trying to do, I would probably do something like:

#define TOKEN(F) \
F(IDENTIFIER, "<identifier>") \
F(WIDGETDEF, "widgetdef")

#define tok(a,b) a = b,
enum Token {
TOKEN(tok)
NUM_TOKENS
};
#undef tok

#define tok(a,b) b,
const char * const token2str[NUM_TOKENS] = {
TOKEN(tok)
};
#undef tok

Obviously you meant #define tok(a,b) a, in the first case
and #define tok(a,b) [a] = b, or just b, in the second.

- David.Thompson1 at worldnet.att.net

You should be able to cast a const string pointer to an int so that
one could do: enum {an_enum = (int)"the first enum"}. It's cleaner
than #defines.

[Keith Thompson]

Russell Shaw <rjshawN_o@s_pam.netspace.net.au> writes:
[...]

You should be able to cast a const string pointer to an int so that
one could do: enum {an_enum = (int)"the first enum"}. It's cleaner
than #defines.

gcc complains "enumerator value for `an_enum' not integer constant".

The message is actually slightly misleading; it has to be a constant
expression, not an integer constant. But gcc is correct; a cast of an
address cannot be part of an integer constant expression.

You can convert a pointer to an int in a context that doesn't require
a constant expression, but the result is not necessarily useful. For
example, if pointers are 8 bytes and ints are 4 bytes, two distinct
pointer values might convert to the same int value.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Peter Nilsson]

Keith Thompson wrote:

Russell Shaw <rjshawN_o@s_pam.netspace.net.au> writes:
[...]

You should be able to cast a const string pointer to an int so that
one could do: enum {an_enum = (int)"the first enum"}.
The type of "the first enum" is not const qualified.
It's cleaner than #defines.
gcc complains "enumerator value for `an_enum' not integer constant".

The message is actually slightly misleading; it has to be a constant
expression, not an integer constant.

More precisely, it must be an integer constant expression.
But gcc is correct; a cast of an address cannot be part of an integer
constant expression.

You can convert a pointer to an int in a context that doesn't require
a constant expression, but the result is not necessarily useful. For
example, if pointers are 8 bytes and ints are 4 bytes, two distinct
pointer values might convert to the same int value.

This notwithstanding, and as has been pointed out elsethread, there's
always...

const char the_first_enum[] = "the first enum";

Synchronising enums and strings has also been discussed in clc before.

--
Peter