an enum and ntoh question

[poison.summer]

Hello

If I have an enum definition
for instance

typedef enum {
F0 = 0,
F1 = 1,
F2 = 2,
F3 =3
} Ftest;

Ftest a;
and I need to do ntoh, which one to use ntohl or ntohs?

And do I have to cast it back to Ftest?

Thanks a lot!

[Vladimir S. Oka]

po***********@g mail.com wrote:

Hello

If I have an enum definition
for instance

typedef enum {
F0 = 0,
F1 = 1,
F2 = 2,
F3 =3
} Ftest;

Ftest a;
and I need to do ntoh, which one to use ntohl or ntohs?

And do I have to cast it back to Ftest?

Your question is off topic, ntoh*() and hton*() functions not being part
of Standard C.

Also, your question does not seem to be too well framed.

What I think you're asking may be what's the `type` of an `enum`. Well,
the Standard specifies that it has to fit in an `int`. Now, look up how
your functions are declared, and you'll figure out (or not) what to do.
It seems to depend on the size of your `int`.

Cheers

Vladimir

--
If only I could be respected without having to be respectable.

[SM Ryan]

po***********@g mail.com wrote:
# Hello
#
# If I have an enum definition
# for instance
#
# typedef enum {
# F0 = 0,
# F1 = 1,
# F2 = 2,
# F3 =3
# } Ftest;
#
# Ftest a;
# and I need to do ntoh, which one to use ntohl or ntohs?

Why guess? Cast it and you don't have to worry. What are you using it for?
Do you need a long or short result?

# And do I have to cast it back to Ftest?

Ftest is just another integer.

--
SM Ryan http://www.rawbw.com/~wyrmwif/
If you plan to shoplift, let us know.
Thanks

[Vladimir S. Oka]

SM Ryan wrote:

po***********@g mail.com wrote:
# Hello
#
# If I have an enum definition
# for instance
#
# typedef enum {
# F0 = 0,
# F1 = 1,
# F2 = 2,
# F3 =3
# } Ftest;
#
# Ftest a;
# and I need to do ntoh, which one to use ntohl or ntohs?

Why guess? Cast it and you don't have to worry. What are you using it for?
Do you need a long or short result?

# And do I have to cast it back to Ftest?

Ftest is just another integer.

No, it's not, it's a new type called `Ftest`, which is actually an
`enum`. The fact that enums can be represented as ints (as the Standard
assures us) doe snot mean that enums /are/ ints. They're a completely
different beast.

Cheers

Vladimir

[tmp123]

po***********@g mail.com wrote:

Hello

If I have an enum definition
for instance

typedef enum {
F0 = 0,
F1 = 1,
F2 = 2,
F3 =3
} Ftest;

Ftest a;
and I need to do ntoh, which one to use ntohl or ntohs?

And do I have to cast it back to Ftest?

Thanks a lot!

Ftest is in the range [0,3], that fits in an uint16, thus ntohs/htons.

[Chris Torek]

>> po***********@g mail.com wrote:

typedef enum { /* ... */ } Ftest;

SM Ryan wrote:

Ftest is just another integer.

In article <11************ **********@o13g 2000cwo.googleg roups.com>,
Vladimir S. Oka <no****@btopenw orld.com> wrote:No, it's not, it's a new type called `Ftest`, which is actually an
`enum`. The fact that enums can be represented as ints (as the Standard
assures us) doe snot mean that enums /are/ ints. They're a completely
different beast.

Well, more specifically, they are compatible with an integer
type -- we just are not told which one (and compilers can
change "which one" more or less at whim, too).

Peculiarly, however, enumeration *constants* have type "int".

Since the constants have type "int", the only types that really
make sense, as compiler choices, for the enumerated types, are
char, signed char, unsigned char, short, unsigned short, and int.
(Well, in C99, a compiler can use an "extended" type, including
types halfway between char and short for instance -- one might
do this on a Cray, where "char" is 8 bits but "short" is 64.)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[Keith Thompson]

Chris Torek <no****@torek.n et> writes:
[...]

In article <11************ **********@o13g 2000cwo.googleg roups.com>,
Vladimir S. Oka <no****@btopenw orld.com> wrote:

No, it's not, it's a new type called `Ftest`, which is actually an
`enum`. The fact that enums can be represented as ints (as the Standard
assures us) doe snot mean that enums /are/ ints. They're a completely
different beast.
Well, more specifically, they are compatible with an integer
type -- we just are not told which one (and compilers can
change "which one" more or less at whim, too).

Peculiarly, however, enumeration *constants* have type "int".

Since the constants have type "int", the only types that really
make sense, as compiler choices, for the enumerated types, are
char, signed char, unsigned char, short, unsigned short, and int.

Though a sufficiently perverse compiler could make an enumerated type
compatible with signed or unsigned long or long long.
(Well, in C99, a compiler can use an "extended" type, including
types halfway between char and short for instance -- one might
do this on a Cray, where "char" is 8 bits but "short" is 64.)

One probably wouldn't, though; the reasons for "short" being 64 bits
(that the hardware can't directly access quantities smaller than 64
bits) apply equally to enumerated types. (This applies only to *some*
Cray systems, BTW.)

--
Keith Thompson (The_Other_Keit h) 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.

[Thad Smith]

"Vladimir S. Oka" wrote:

po***********@g mail.com wrote:

If I have an enum definition
for instance

typedef enum {
F0 = 0,
F1 = 1,
F2 = 2,
F3 =3
} Ftest;

Ftest a;
and I need to do ntoh, which one to use ntohl or ntohs?

And do I have to cast it back to Ftest?
Your question is off topic, ntoh*() and hton*() functions not being part
of Standard C.

Also, your question does not seem to be too well framed.

What I think you're asking may be what's the `type` of an `enum`. Well,
the Standard specifies that it has to fit in an `int`.

While that's true, there's a subtlety involved: a specific enumeration
type may be stored in a implementation-defined compatible integer type
smaller than an int. It then has the same rank as the compatible
integer type.
Now, look up how
your functions are declared, and you'll figure out (or not) what to do.
It seems to depend on the size of your `int`.

Not necessarily. A specific enumeration type may stored in a short.
The value of the variable should be limited to range of values in the
defined members of the type.

--
Thad

[Jordan Abel]

On 2006-02-04, Thad Smith <Th*******@acm. org> wrote:

"Vladimir S. Oka" wrote:

po***********@g mail.com wrote:

> If I have an enum definition
> for instance
>
> typedef enum {
> F0 = 0,
> F1 = 1,
> F2 = 2,
> F3 =3
> } Ftest;
>
> Ftest a;
> and I need to do ntoh, which one to use ntohl or ntohs?
>
> And do I have to cast it back to Ftest?

Your question is off topic, ntoh*() and hton*() functions not being part
of Standard C.

Also, your question does not seem to be too well framed.

What I think you're asking may be what's the `type` of an `enum`. Well,
the Standard specifies that it has to fit in an `int`.

While that's true, there's a subtlety involved: a specific enumeration
type may be stored in a implementation-defined compatible integer type
smaller than an int. It then has the same rank as the compatible
integer type.

What if there are more than INT_MAX+1 items in the enumeration? Is an
implementation required to reject these, or may it choose long as the
integer type? Or is there undefined behavior?

[Thad Smith]

Jordan Abel wrote:

What if there are more than INT_MAX+1 items in the enumeration? Is an
implementation required to reject these, or may it choose long as the
integer type? Or is there undefined behavior?

No, an implementation is not required to reject a declaration with
more than INT_MAX+1 enumeration constants. If the number of declared
enumeration constants exceeds the translator limit, a diagnostic
/should/ be issued (sorry, no C&V).

An implementation must support at least 1023 enumeration constants
(items) for a single enumeration. It may support more. Because there
may be separate enumeration constants with the same value and
enumeration constants can have assigned values, the number of
enumeration constants in an enumeration type is independent of the
range of values.

Although enumeration constants have type int, a specific enumeration
type may have a smaller range of values, be stored in a smaller int
type, and have a lesser rank. Standard C only supports enumeration
values within the range for type int. Attempting to specify an
enumeration constant with a value outside the range of an int violates
a constraint and requires a diagnostic. A conforming implementation
could still support larger values and provide sufficient storage for
the declared range, but it must still issue the diagnostic (in
conforming mode).

--
Thad