Style Change: NULL->nullptr

src/core/SkRegion.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkAtomics.h"
@@ skipping 176 matching lines @@
 char* SkRegion::toString() {
     Iterator iter(*this);
     int count = 0;
     while (!iter.done()) {
         count++;
         iter.next();
     }
     // 4 ints, up to 10 digits each plus sign, 3 commas, '(', ')', SkRegion() and '\0'
     const int max = (count*((11*4)+5))+11+1;
     char* result = (char*)sk_malloc_throw(max);
-    if (result == NULL) {
-        return NULL;
+    if (result == nullptr) {
+        return nullptr;
     }
     count = sprintf(result, "SkRegion(");
     iter.reset(*this);
     while (!iter.done()) {
         const SkIRect& r = iter.rect();
         count += sprintf(result+count, "(%d,%d,%d,%d)", r.fLeft, r.fTop, r.fRight, r.fBottom);
         iter.next();
     }
     count += sprintf(result+count, ")");
     return result;
@@ skipping 192 matching lines @@
         return true;
     }
     if (rgn.isRect()) {
         return this->contains(rgn.getBounds());
     }
 
     /*
      *  A contains B is equivalent to
      *  B - A == 0
      */
-    return !Oper(rgn, *this, kDifference_Op, NULL);
+    return !Oper(rgn, *this, kDifference_Op, nullptr);
 }
 
 const SkRegion::RunType* SkRegion::getRuns(RunType tmpStorage[],
                                            int* intervals) const {
     SkASSERT(tmpStorage && intervals);
     const RunType* runs = tmpStorage;
 
     if (this->isEmpty()) {
         tmpStorage[0] = kRunTypeSentinel;
         *intervals = 0;
@@ skipping 69 matching lines @@
         return true;
     }
     if (weAreARect) {
         return rgn.intersects(this->getBounds());
     }
     if (theyAreARect) {
         return this->intersects(rgn.getBounds());
     }
 
     // both of us are complex
-    return Oper(*this, rgn, kIntersect_Op, NULL);
+    return Oper(*this, rgn, kIntersect_Op, nullptr);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkRegion::operator==(const SkRegion& b) const {
     SkDEBUGCODE(validate();)
     SkDEBUGCODE(b.validate();)
 
     if (this == &b) {
         return true;
@@ skipping 14 matching lines @@
         return false;
     }
     return  ah->fRunCount == bh->fRunCount &&
             !memcmp(ah->readonly_runs(), bh->readonly_runs(),
                     ah->fRunCount * sizeof(SkRegion::RunType));
 }
 
 void SkRegion::translate(int dx, int dy, SkRegion* dst) const {
     SkDEBUGCODE(this->validate();)
 
-    if (NULL == dst) {
+    if (nullptr == dst) {
         return;
     }
     if (this->isEmpty()) {
         dst->setEmpty();
     } else if (this->isRect()) {
         dst->setRect(fBounds.fLeft + dx, fBounds.fTop + dy,
                      fBounds.fRight + dx, fBounds.fBottom + dy);
     } else {
         if (this == dst) {
             dst->fRunHead = dst->fRunHead->ensureWritable();
@@ skipping 520 matching lines @@
     const RunType* b_runs = rgnb->getRuns(tmpB, &b_intervals);
 
     int dstCount = compute_worst_case_count(a_intervals, b_intervals);
     SkAutoSTMalloc<256, RunType> array(dstCount);
 
 #ifdef SK_DEBUG
 //  Sometimes helpful to seed everything with a known value when debugging
 //  sk_memset32((uint32_t*)array.get(), 0x7FFFFFFF, dstCount);
 #endif
 
-    int count = operate(a_runs, b_runs, array.get(), op, NULL == result);
+    int count = operate(a_runs, b_runs, array.get(), op, nullptr == result);
     SkASSERT(count <= dstCount);
 
     if (result) {
         SkASSERT(count >= 0);
         return result->setRuns(array.get(), count);
     } else {
         return (QUICK_EXIT_TRUE_COUNT == count) || !isRunCountEmpty(count);
     }
 }
 
 bool SkRegion::op(const SkRegion& rgna, const SkRegion& rgnb, Op op) {
     SkDEBUGCODE(this->validate();)
     return SkRegion::Oper(rgna, rgnb, op, this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkBuffer.h"
 
 size_t SkRegion::writeToMemory(void* storage) const {
-    if (NULL == storage) {
+    if (nullptr == storage) {
         size_t size = sizeof(int32_t); // -1 (empty), 0 (rect), runCount
         if (!this->isEmpty()) {
             size += sizeof(fBounds);
             if (this->isComplex()) {
                 size += 2 * sizeof(int32_t);    // ySpanCount + intervalCount
                 size += fRunHead->fRunCount * sizeof(RunType);
             }
         }
         return size;
     }
@@ skipping 179 matching lines @@
 }
 
 void SkRegion::Iterator::reset(const SkRegion& rgn) {
     fRgn = &rgn;
     if (rgn.isEmpty()) {
         fDone = true;
     } else {
         fDone = false;
         if (rgn.isRect()) {
             fRect = rgn.fBounds;
-            fRuns = NULL;
+            fRuns = nullptr;
         } else {
             fRuns = rgn.fRunHead->readonly_runs();
             fRect.set(fRuns[3], fRuns[0], fRuns[4], fRuns[1]);
             fRuns += 5;
             // Now fRuns points to the 2nd interval (or x-sentinel)
         }
     }
 }
 
 void SkRegion::Iterator::next() {
     if (fDone) {
         return;
     }
 
-    if (fRuns == NULL) {   // rect case
+    if (fRuns == nullptr) {   // rect case
         fDone = true;
         return;
     }
 
     const RunType* runs = fRuns;
 
     if (runs[0] < kRunTypeSentinel) { // valid X value
         fRect.fLeft = runs[0];
         fRect.fRight = runs[1];
         runs += 2;
@@ skipping 71 matching lines @@
             right > r.fLeft && left < r.fRight) {
         if (rgn.isRect()) {
             if (left < r.fLeft) {
                 left = r.fLeft;
             }
             if (right > r.fRight) {
                 right = r.fRight;
             }
             fLeft = left;
             fRight = right;
-            fRuns = NULL;    // means we're a rect, not a rgn
+            fRuns = nullptr;    // means we're a rect, not a rgn
             fDone = false;
         } else {
             const SkRegion::RunType* runs = rgn.fRunHead->findScanline(y);
             runs += 2;  // skip Bottom and IntervalCount
             for (;;) {
                 // runs[0..1] is to the right of the span, so we're done
                 if (runs[0] >= right) {
                     break;
                 }
                 // runs[0..1] is to the left of the span, so continue
@@ skipping 10 matching lines @@
             }
         }
     }
 }
 
 bool SkRegion::Spanerator::next(int* left, int* right) {
     if (fDone) {
         return false;
     }
 
-    if (fRuns == NULL) {   // we're a rect
+    if (fRuns == nullptr) {   // we're a rect
         fDone = true;   // ok, now we're done
         if (left) {
             *left = fLeft;
         }
         if (right) {
             *right = fRight;
         }
         return true;    // this interval is legal
     }
 
@@ skipping 23 matching lines @@
 bool SkRegion::debugSetRuns(const RunType runs[], int count) {
     // we need to make a copy, since the real method may modify the array, and
     // so it cannot be const.
 
     SkAutoTArray<RunType> storage(count);
     memcpy(storage.get(), runs, count * sizeof(RunType));
     return this->setRuns(storage.get(), count);
 }
 
 #endif