Signedness of an Enum is undefined in standard C++ #6017

I am reviewing code, and came accross the following in chain.h.

//! Check whether this block index entry is valid up to the passed validity level.
bool IsValid(enum BlockStatus nUpTo = BLOCK_VALID_TRANSACTIONS) const
{
    assert(!(nUpTo & ~BLOCK_VALID_MASK)); // Only validity flags allowed.
    if (nStatus & BLOCK_FAILED_MASK)
        return false;
    return ((nStatus & BLOCK_VALID_MASK) >= nUpTo);
}

//! Raise the validity level of this block index entry.
//! Returns true if the validity was changed.
bool RaiseValidity(enum BlockStatus nUpTo)
{
    assert(!(nUpTo & ~BLOCK_VALID_MASK)); // Only validity flags allowed.
    if (nStatus & BLOCK_FAILED_MASK)
        return false;
    if ((nStatus & BLOCK_VALID_MASK) < nUpTo) {
        nStatus = (nStatus & ~BLOCK_VALID_MASK) | nUpTo;
        return true;
    }
    return false;
}

Now I don't think there is a problem per se, but from what I can see the standard says that nUpTo may be either signed or unsigned. Is this a problem when combined with the various bitwise operations, or even comparison operator < ? My compiler complains.

Edit: Here's what the C++03 standard (ISO/IEC 14882:2003) document says in 7.2-5 (Enumeration declarations):

The underlying type of an enumeration is an integral type that can represent all the enumerator values defined in the enumeration. It is implementation-defined which integral type is used as the underlying type for an enumeration except that the underlying type shall not be larger than int unless the value of an enumerator cannot fit in an int or unsigned int.

Right. May make sense to change the passed-in type to unsigned int instead. On the other hand, with C++11 it is possible to define the type of an enumeration and this problem goes away, so as this doesn't cause any immediate problems may be better to wait for that.

This could be addressed now that we've started using c++11.

Awesome. Thanks.