[Bug c++/16711] New: Bug in reporting integral constant expressions problems

["romixlev at yahoo dot com" <gcc-bugzilla@gcc.gnu.org>]

G++ 3.4.1 rejects some integral constant expressions that were allowed in the
earlier versions. The same file compiled with GCC as a C file does not produce
any errors. This report seems to be related to Bugzilla Bug 16489.

The sample file below (sample.cc) contains comments explaining the problem.


How to reproduce the bug:
g++ sample.cc


---------------------------------------------------------------------------

/*
// Bug report for gcc version 3.4.1 (Mandrakelinux (Cooker) 3.4.1-1mdk)

// Recent versions of G++ refuse to accept some 
// constant expressions which contain casts into 
// non integral types, e.g. into pointer types.
// It says a cast to anything
// but integral or enumaration type is not an integral constant
// expression.


// Such expressions are often produced by some
// tools generating C++ code as their output.
// Previously, these expressions were accepted by
// G++.

// Size of array should be an integral constant expression, or?
// But G++ does not complain about this expression
*/
int array [((int)(void*)1)];

enum MyEnum
{
   /*
   // Here we use the same constant_expression,
   // but as a value of the enumerator.
   // G++ doesn't like it for some reason
   */
   ONE = ((int)((void*)1))
};

  
int main(int argc)
{
  switch(argc)
  {
    /*
    // Here we use the same constant_expression
    // as a case value of switch statement
    // G++ does not like it at this place, too.
    */
    case ((int)(void*)1): break;
    case 2: break;
  }

  return 0;
}

/*
    There are three places in this program, that
    are using the same integer constant_expression.
    
    Earlier versions of G++, <= 3.2.X, didn't have
    this problem and accepted all three occurences
    of the constant_expression without any problems.
    More over, all other C++ compilers (Borland C++,
    Visual C++, etc) do not complain about this code.

    If this file is compiled as a C file, no errors
    are reported by GCC.

    It looks like the switch to the new C++
    parser and corresponding changes in the G++
    code introduced this behavior. And it looks
    like it is a bug in G++.
    
    After looking at the Changelog file, it seems
    that the following change could have introduced 
    such a behavior:
    
        2004-03-19  Giovanni Bajo  <giovannibajo@gcc.gnu.org>

	PR c++/14545
	* parser.c (cp_parser_functional_cast): A cast to anything
	but integral or enumaration type is not an integral constant
	expression.
    
    Probably, only the final type of the integral constant expression
    should be integral or enumeration. But in the middle of such
    expressions, it should probably be possible to cast to some other
    types, at least into pointer types, since conversions between
    pointers and integers do not involve any run-time computations.

*/

-- 
           Summary: Bug in reporting integral constant expressions problems
           Product: gcc
           Version: 3.4.1
            Status: UNCONFIRMED
          Severity: critical
          Priority: P2
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: romixlev at yahoo dot com
                CC: gcc-bugs at gcc dot gnu dot org


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=16711