[cfe-commits] r45961 - in /cfe/trunk: AST/Expr.cpp test/Sema/conditional-expr.c

[Steve Naroff]

Author: snaroff
Date: Mon Jan 14 10:10:57 2008
New Revision: 45961

URL: http://llvm.org/viewvc/llvm-project?rev=45961&view=rev
Log:

Revert r45951, Chris says it violates the C99 spec.


Modified:
    cfe/trunk/AST/Expr.cpp
    cfe/trunk/test/Sema/conditional-expr.c

Modified: cfe/trunk/AST/Expr.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/AST/Expr.cpp?rev=45961&r1=45960&r2=45961&view=diff

==============================================================================
--- cfe/trunk/AST/Expr.cpp (original)
+++ cfe/trunk/AST/Expr.cpp Mon Jan 14 10:10:57 2008
@@ -929,47 +929,36 @@
   return true;
 }
 
-/// Helper function for isNullPointerConstant. This routine skips all
-/// explicit casts, implicit casts and paren expressions.
-const Expr * getNullPointerConstantExpr(const Expr *exp) {
-  if (const CastExpr *CE = dyn_cast<CastExpr>(exp)) {
-    return getNullPointerConstantExpr(CE->getSubExpr());
-  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(exp)) {
-    return getNullPointerConstantExpr(ICE->getSubExpr());
-  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(exp)) {
-    // Accept ((void*)0) as a null pointer constant, as many other
-    // implementations do.
-    return getNullPointerConstantExpr(PE->getSubExpr());
-  }
-  return exp;
-}
-
 /// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
 /// integer constant expression with the value zero, or if this is one that is
 /// cast to void*.
 bool Expr::isNullPointerConstant(ASTContext &Ctx) const {
-  const CastExpr *CE = dyn_cast<CastExpr>(this);
-  const Expr *e = getNullPointerConstantExpr(this);
-  
-  if (CE) {
-    bool castToVoidStar = false;
-    // Check if the highest precedence cast is "void *".
+  // Strip off a cast to void*, if it exists.
+  if (const CastExpr *CE = dyn_cast<CastExpr>(this)) {
+    // Check that it is a cast to void*.
     if (const PointerType *PT = dyn_cast<PointerType>(CE->getType())) {
       QualType Pointee = PT->getPointeeType();
-      if (Pointee.getQualifiers() == 0 && Pointee->isVoidType())
-        castToVoidStar = true;
+      if (Pointee.getQualifiers() == 0 && Pointee->isVoidType() && // to void*
+          CE->getSubExpr()->getType()->isIntegerType())            // from int.
+        return CE->getSubExpr()->isNullPointerConstant(Ctx);
     }
-    // This cast must be an integer type or void *.
-    if (!CE->getType()->isIntegerType() && !castToVoidStar)
-      return false;
-  } else if (!e->getType()->isIntegerType()) {
-    // This expression must be an integer type.
-    return false;
+  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
+    // Ignore the ImplicitCastExpr type entirely.
+    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
+  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
+    // Accept ((void*)0) as a null pointer constant, as many other
+    // implementations do.
+    return PE->getSubExpr()->isNullPointerConstant(Ctx);
   }
+  
+  // This expression must be an integer type.
+  if (!getType()->isIntegerType())
+    return false;
+  
   // If we have an integer constant expression, we need to *evaluate* it and
   // test for the value 0.
   llvm::APSInt Val(32);
-  return e->isIntegerConstantExpr(Val, Ctx, 0, true) && Val == 0;
+  return isIntegerConstantExpr(Val, Ctx, 0, true) && Val == 0;
 }
 
 unsigned OCUVectorElementExpr::getNumElements() const {

Modified: cfe/trunk/test/Sema/conditional-expr.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Sema/conditional-expr.c?rev=45961&r1=45960&r2=45961&view=diff

==============================================================================
--- cfe/trunk/test/Sema/conditional-expr.c (original)
+++ cfe/trunk/test/Sema/conditional-expr.c Mon Jan 14 10:10:57 2008
@@ -1,8 +1,8 @@
 // RUN: clang -fsyntax-only -verify -pedantic %s
 void foo() {
   *(0 ? (double *)0 : (void *)0) = 0;
-  *(0 ? (double *)0 : (void *)(int *)0) = 0;
-  *(0 ? (double *)0 : (void *)(double *)0) = 0;
+  *(0 ? (double *)0 : (void *)(int *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}}
+  *(0 ? (double *)0 : (void *)(double *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}}
   *(0 ? (double *)0 : (int *)(void *)0) = 0; // expected-warning {{pointer type mismatch ('double *' and 'int *')}}
   *(0 ? (double *)0 : (double *)(void *)0) = 0;
   *((void *) 0) = 0; // expected-error {{incomplete type 'void' is not assignable}}