enum may be signed

enum may be signed

[grischka]

In git:2f2ce26ff273aadaf324ec599bf1dd1f67cab560 (Stefan Monnier)

+enum symbol_redirect
+{
+  SYMBOL_PLAINVAL  = 4,
...

  struct Lisp_Symbol
  {
    unsigned gcmarkbit : 1;
...
+  enum symbol_redirect redirect : 3;


Note that this breaks with compilers where enums can be signed (e.g. MSVC),
Because value 4 doesn't fit into 3 bits (signed), it is read as -4 and
breaks related switch statements (e.g. data.c:set_internal)

--- grischka

Re: enum may be signed

[Stefan Monnier]

> +  enum symbol_redirect redirect : 3;

> Note that this breaks with compilers where enums can be signed (e.g. MSVC),
> Because value 4 doesn't fit into 3 bits (signed), it is read as -4 and
> breaks related switch statements (e.g. data.c:set_internal)

Interesting.  I didn't know about that part of the C language.  Is it
possible to specify that this is an unsigned enum somehow?
I've tried "enum symbol_redirect redirect : 3;" but at least GCC didn't
like it.
Of course we can add one more bit (we have plenty of bits left there),
but I'd first like to know how this is usually handled, since it seems
to imply that MSVC always requires one extra bit to store enums.


        Stefan

Re: enum may be signed

[Ken Raeburn]

On May 1, 2010, at 13:56, Stefan Monnier wrote:
> Interesting.  I didn't know about that part of the C language.  Is it
> possible to specify that this is an unsigned enum somehow?

Not really... nothing in standard C supports it (in fact IIRC it doesn't allow enum bitfields anyways, but that's a common extension), and anything MSVC-specific won't help when the next such compiler comes along.

> Of course we can add one more bit (we have plenty of bits left there),
> but I'd first like to know how this is usually handled, since it seems
> to imply that MSVC always requires one extra bit to store enums.

I think adding the extra bit and using "unsigned int" bitfields are the two usual ways to deal with it.

Ken

Re: enum may be signed

[grischka]

Stefan Monnier wrote:
>> +  enum symbol_redirect redirect : 3;
> 
>> Note that this breaks with compilers where enums can be signed (e.g. MSVC),
>> Because value 4 doesn't fit into 3 bits (signed), it is read as -4 and
>> breaks related switch statements (e.g. data.c:set_internal)
> 
> Interesting.  I didn't know about that part of the C language.  Is it
> possible to specify that this is an unsigned enum somehow?
> I've tried "enum symbol_redirect redirect : 3;" but at least GCC didn't
> like it.

Planned for C++0x:
http://en.wikipedia.org/wiki/C%2B%2B0x#Strongly_typed_enumerations

> Of course we can add one more bit (we have plenty of bits left there),
> but I'd first like to know how this is usually handled, since it seems
> to imply that MSVC always requires one extra bit to store enums.

Good old "unsigned redirect : 3;" works as expected.

Btw, check also "enum Lisp_Type type : GCTYPEBITS;".

--- grischka

> 
> 
>         Stefan
> 

Re: enum may be signed

[Tom Tromey]

>>>>> "Stefan" == Stefan Monnier <monnier@iro.umontreal.ca> writes:

Stefan> Interesting.  I didn't know about that part of the C language.  Is it
Stefan> possible to specify that this is an unsigned enum somehow?
Stefan> I've tried "enum symbol_redirect redirect : 3;" but at least GCC didn't
Stefan> like it.
Stefan> Of course we can add one more bit (we have plenty of bits left there),
Stefan> but I'd first like to know how this is usually handled, since it seems
Stefan> to imply that MSVC always requires one extra bit to store enums.

GCC and GDB do something like this:

/* Be conservative and use enum bitfields only with GCC.
   This is copied from gcc 3.3.1, system.h.  */

#if defined(__GNUC__) && (__GNUC__ >= 2)
#define ENUM_BITFIELD(TYPE) enum TYPE
#else
#define ENUM_BITFIELD(TYPE) unsigned int
#endif


Used like:

struct main_type
{
  /* Code for kind of type */

  ENUM_BITFIELD(type_code) code : 8;
...



Continuing to use an enum bitfield on gcc is nice, because gcc will warn
if the enum is too large to fit in the bitfield.

Tom