Re: [PATCH 3/3] grep: get rid of useless x < 0 comparison on an enum member

["Ævar Arnfjörð Bjarmason" <avarab@gmail.com>]

On Sun, Nov 6, 2011 at 16:03, Andreas Schwab <schwab@linux-m68k.org> wrote:
> Ævar Arnfjörð Bjarmason <avarab@gmail.com> writes:
>
>> Remove an "p->field < 0" comparison in grep.c that'll always be
>> false. In this case "p" is a "grep_pat" where "field" is defined as:
>>
>>       enum grep_header_field field;
>>
>> And grep_header_field is in turn defined as:
>>
>>     enum grep_header_field {
>>       GREP_HEADER_AUTHOR = 0,
>>       GREP_HEADER_COMMITTER
>>     };
>>
>> Meaning that this comparison will always be false.
>
> The underlying integer type is implementation-defined, and can be any
> signed or unsigned integer type that can represent all enumerations.

Yes, but as far as I can tell since we've done "= 0" there that
doesn't apply to us. To quote the ANSI C Standard (ANSI X3J11/88-090):

    3.5.2.2 Enumeration specifiers

    Syntax

              enum-specifier:
                      enum  identifier<opt> { enumerator-list }
                      enum  identifier

              enumerator-list:
                      enumerator
                      enumerator-list , enumerator

              enumerator:
                      enumeration-constant
                      enumeration-constant = constant-expression

    Constraints

       The expression that defines the value of an enumeration constant
    shall be an integral constant expression that has a value
    representable as an int.

    Semantics

       The identifiers in an enumerator list are declared as constants
    that have type int and may appear wherever such are permitted./52/ An
    enumerator with = defines its enumeration constant as the value of the
    constant expression.  If the first enumerator has no = , the value of
    its enumeration constant is 0.  Each subsequent enumerator with no =
    defines its enumeration constant as the value of the constant
    expression obtained by adding 1 to the value of the previous
    enumeration constant.  (A combination of both forms of enumerators may
    produce enumeration constants with values that duplicate other values
    in the same enumeration.) The enumerators of an enumeration are also
    known as its members.

       Each enumerated type shall be compatible with an integer type; the
    choice of type is implementation-defined.

    Example

             enum hue { chartreuse, burgundy, claret=20, winedark };
             /*...*/
             enum hue col, *cp;
             /*...*/
             col = claret;
             cp = &col;
             /*...*/
             /*...*/ (*cp != burgundy) /*...*/

    makes hue the tag of an enumeration, and then declares col as an
    object that has that type and cp as a pointer to an object that has
    that type.  The enumerated values are in the set {0, 1, 20, 21}.

I.e. we'll always have GREP_HEADER_AUTHOR = 0 and
GREP_HEADER_COMMITTER = 1, we'll never have GREP_HEADER_AUTHOR = and
GREP_HEADER_COMMITTER = <some int>.