MallocGrowableArray

runtime/platform/assert.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef PLATFORM_ASSERT_H_
 #define PLATFORM_ASSERT_H_
 
 // TODO(5411406): include sstream for now, once we have a Utils::toString()
 // implemented for all the primitive types we can replace the usage of
 // sstream by Utils::toString()
@@ skipping 47 matching lines @@
   void LessThan(const E& left, const A& right);
 
   template<typename E, typename A>
   void LessEqual(const E& left, const A& right);
 
   template<typename E, typename A>
   void GreaterThan(const E& left, const A& right);
 
   template<typename E, typename A>
   void GreaterEqual(const E& left, const A& right);
+#endif
 
   template<typename T>
-  void NotNull(const T p);
-#endif
+  T NotNull(const T p);
 
  private:
   const char* const file_;
   const int line_;
   const Kind kind_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DynamicAssertionHelper);
 };
 
 
@@ skipping 126 matching lines @@
 
 template<typename E, typename A>
 void DynamicAssertionHelper::GreaterEqual(const E& left, const A& right) {
   if (left >= right) return;
   std::ostringstream ess, ass;
   ess << left;
   ass << right;
   std::string es = ess.str(), as = ass.str();
   Fail("expected: %s >= %s", es.c_str(), as.c_str());
 }
+#endif
 
 
 template<typename T>
-void DynamicAssertionHelper::NotNull(const T p) {
-  if (p != NULL) return;
+T DynamicAssertionHelper::NotNull(const T p) {
+  if (p != NULL) return p;
   Fail("expected: not NULL, found NULL");
+  return NULL;
 }
-#endif
 
 }  // namespace dart
 
 
 #define FATAL(error)                                                           \
   dart::Assert(__FILE__, __LINE__).Fail("%s", error)
 
 #define FATAL1(format, p1)                                                     \
   dart::Assert(__FILE__, __LINE__).Fail(format, (p1))
 
@@ skipping 15 matching lines @@
 
 #define ASSERT(cond)                                                           \
   do {                                                                         \
     if (!(cond)) dart::Assert(__FILE__, __LINE__).Fail("expected: %s", #cond); \
   } while (false)
 
 // DEBUG_ASSERT allows identifiers in condition to be undeclared in release
 // mode.
 #define DEBUG_ASSERT(cond) ASSERT(cond)
 
+// Returns 'ptr'; useful for initializer lists:
+//   class Foo { Foo(int* ptr) : ptr_(ASSERT_NOTNULL(ptr)) ...
+#define ASSERT_NOTNULL(ptr)                                                    \
+  dart::Assert(__FILE__, __LINE__).NotNull((ptr))
+
 #else  // if defined(DEBUG)
 
 // In order to avoid variable unused warnings for code that only uses
 // a variable in an ASSERT or EXPECT, we make sure to use the macro
 // argument.
 #define ASSERT(condition) do {} while (false && (condition))
 
 #define DEBUG_ASSERT(cond)
 
+#define ASSERT_NOTNULL(ptr) (ptr)
+
 #endif  // if defined(DEBUG)
 
 
 // The COMPILE_ASSERT macro can be used to verify that a compile time
 // expression is true. For example, you could use it to verify the
 // size of a static array:
 //
 //   COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES);
 //
 // or to make sure a struct is smaller than a certain size:
@@ skipping 63 matching lines @@
 
 #define FAIL1(format, p1)                                                      \
   dart::Expect(__FILE__, __LINE__).Fail(format, (p1))
 
 #define FAIL2(format, p1, p2)                                                  \
   dart::Expect(__FILE__, __LINE__).Fail(format, (p1), (p2))
 
 #endif  // defined(TESTING)
 
 #endif  // PLATFORM_ASSERT_H_