Style Change: NULL->nullptr

src/pathops/SkPathOpsTSect.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChunkAlloc.h"
 #include "SkPathOpsBounds.h"
 #include "SkPathOpsRect.h"
@@ skipping 94 matching lines @@
 
     bool hasOppT(double t) const {
         return SkToBool(oppT(t));
     }
 
     int hullsIntersect(SkTSpan<OppCurve, TCurve>* span, bool* start, bool* oppStart);
     void init(const TCurve& );
     void initBounds(const TCurve& );
 
     bool isBounded() const {
-        return fBounded != NULL;
+        return fBounded != nullptr;
     }
 
     bool linearsIntersect(SkTSpan<OppCurve, TCurve>* span);
     double linearT(const SkDPoint& ) const;
 
     void markCoincident() {
         fCoinStart.markCoincident();
         fCoinEnd.markCoincident();
     }
 
     const SkTSpan* next() const {
         return fNext;
     }
 
     bool onlyEndPointsInCommon(const SkTSpan<OppCurve, TCurve>* opp, bool* start,
             bool* oppStart, bool* ptsInCommon);
 
     const TCurve& part() const {
         return fPart;
     }
 
     bool removeAllBounded();
     bool removeBounded(const SkTSpan<OppCurve, TCurve>* opp);
 
     void reset() {
-        fBounded = NULL;
+        fBounded = nullptr;
     }
 
     void resetBounds(const TCurve& curve) {
         fIsLinear = fIsLine = false;
         initBounds(curve);
     }
 
     bool split(SkTSpan* work, SkChunkAlloc* heap) {
         return splitAt(work, (work->fStartT + work->fEndT) * 0.5, heap);
     }
@@ skipping 48 matching lines @@
 class SkTSect {
 public:
     SkTSect(const TCurve& c  PATH_OPS_DEBUG_T_SECT_PARAMS(int id));
     static void BinarySearch(SkTSect* sect1, SkTSect<OppCurve, TCurve>* sect2,
             SkIntersections* intersections);
 
     // for testing only
     bool debugHasBounded(const SkTSpan<OppCurve, TCurve>* ) const;
 
     const SkTSect<OppCurve, TCurve>* debugOpp() const {
-        return SkDEBUGRELEASE(fOppSect, NULL);
+        return SkDEBUGRELEASE(fOppSect, nullptr);
     }
 
     const SkTSpan<TCurve, OppCurve>* debugSpan(int id) const;
     const SkTSpan<TCurve, OppCurve>* debugT(double t) const;
     void dump() const;
     void dumpBoth(SkTSect<OppCurve, TCurve>* ) const;
     void dumpBounded(int id) const;
     void dumpBounds() const;
     void dumpCoin() const;
     void dumpCoinCurves() const;
@@ skipping 224 matching lines @@
     do {
         if (between(work->fStartT, t, work->fEndT)) {
             return true;
         }
     } while ((work = work->fNext));
     return false;
 }
 
 template<typename TCurve, typename OppCurve>
 const SkTSect<OppCurve, TCurve>* SkTSpan<TCurve, OppCurve>::debugOpp() const {
-    return SkDEBUGRELEASE(fDebugSect->debugOpp(), NULL);
+    return SkDEBUGRELEASE(fDebugSect->debugOpp(), nullptr);
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<OppCurve, TCurve>* SkTSpan<TCurve, OppCurve>::findOppSpan(
         const SkTSpan<OppCurve, TCurve>* opp) const {
     SkTSpanBounded<OppCurve, TCurve>* bounded = fBounded;
     while (bounded) {
         SkTSpan<OppCurve, TCurve>* test = bounded->fBounded;
         if (opp == test) {
             return test;
         }
         bounded = bounded->fNext;
     }
-    return NULL;
+    return nullptr;
 }
 
 // returns 0 if no hull intersection
 //         1 if hulls intersect
 //         2 if hulls only share a common endpoint
 //        -1 if linear and further checking is required
 template<typename TCurve, typename OppCurve>
 int SkTSpan<TCurve, OppCurve>::hullCheck(const SkTSpan<OppCurve, TCurve>* opp,
         bool* start, bool* oppStart) {
     if (fIsLinear) {
@@ skipping 33 matching lines @@
     }
     hullSect = opp->hullCheck(this, oppStart, start);
     if (hullSect >= 0) {
         return hullSect;
     }
     return -1;
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::init(const TCurve& c) {
-    fPrev = fNext = NULL;
+    fPrev = fNext = nullptr;
     fStartT = 0;
     fEndT = 1;
-    fBounded = NULL;
+    fBounded = nullptr;
     resetBounds(c);
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::initBounds(const TCurve& c) {
     fPart = c.subDivide(fStartT, fEndT);
     fBounds.setBounds(fPart);
     fCoinStart.init();
     fCoinEnd.init();
     fBoundsMax = SkTMax(fBounds.width(), fBounds.height());
@@ skipping 112 matching lines @@
 template<typename TCurve, typename OppCurve>
 SkTSpan<OppCurve, TCurve>* SkTSpan<TCurve, OppCurve>::oppT(double t) const {
     SkTSpanBounded<OppCurve, TCurve>* bounded = fBounded;
     while (bounded) {
         SkTSpan<OppCurve, TCurve>* test = bounded->fBounded;
         if (between(test->fStartT, t, test->fEndT)) {
             return test;
         }
         bounded = bounded->fNext;
     }
-    return NULL;
+    return nullptr;
 }
 
 template<typename TCurve, typename OppCurve>
 bool SkTSpan<TCurve, OppCurve>::removeAllBounded() {
     bool deleteSpan = false;
     SkTSpanBounded<OppCurve, TCurve>* bounded = fBounded;
     while (bounded) {
         SkTSpan<OppCurve, TCurve>* opp = bounded->fBounded;
         deleteSpan |= opp->removeBounded(this);
         bounded = bounded->fNext;
@@ skipping 15 matching lines @@
             }
             bounded = bounded->fNext;
         }
         if (!foundStart || !foundEnd) {
             fHasPerp = false;
             fCoinStart.init();
             fCoinEnd.init();
         }
     }
     SkTSpanBounded<OppCurve, TCurve>* bounded = fBounded;
-    SkTSpanBounded<OppCurve, TCurve>* prev = NULL;
+    SkTSpanBounded<OppCurve, TCurve>* prev = nullptr;
     while (bounded) {
         SkTSpanBounded<OppCurve, TCurve>* boundedNext = bounded->fNext;
         if (opp == bounded->fBounded) {
             if (prev) {
                 prev->fNext = boundedNext;
                 return false;
             } else {
                 fBounded = boundedNext;
-                return fBounded == NULL;
+                return fBounded == nullptr;
             }
         }
         prev = bounded;
         bounded = boundedNext;
     }
     SkASSERT(0);
     return false;
 }
 
 template<typename TCurve, typename OppCurve>
@@ skipping 12 matching lines @@
     fPrev = work;
     fNext = work->fNext;
     fIsLinear = work->fIsLinear;
     fIsLine = work->fIsLine;
 
     work->fNext = this;
     if (fNext) {
         fNext->fPrev = this;
     }
     SkTSpanBounded<OppCurve, TCurve>* bounded = work->fBounded;
-    fBounded = NULL;
+    fBounded = nullptr;
     while (bounded) {
         this->addBounded(bounded->fBounded, heap);
         bounded = bounded->fNext;
     }
     bounded = fBounded;
     while (bounded) {
         bounded->fBounded->addBounded(this, heap);
         bounded = bounded->fNext;
     }
     return true;
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::validate() const {
 #if DEBUG_T_SECT
-    SkASSERT(fNext == NULL || fNext != fPrev);
-    SkASSERT(fNext == NULL || this == fNext->fPrev);
-    SkASSERT(fPrev == NULL || this == fPrev->fNext);
+    SkASSERT(fNext == nullptr || fNext != fPrev);
+    SkASSERT(fNext == nullptr || this == fNext->fPrev);
+    SkASSERT(fPrev == nullptr || this == fPrev->fNext);
     SkASSERT(fBounds.width() || fBounds.height() || fCollapsed);
     SkASSERT(fBoundsMax == SkTMax(fBounds.width(), fBounds.height()));
     SkASSERT(0 <= fStartT);
     SkASSERT(fEndT <= 1);
     SkASSERT(fStartT <= fEndT);
     SkASSERT(fBounded);
     this->validateBounded();
     if (fHasPerp) {
         if (fCoinStart.isCoincident()) {
             validatePerpT(fCoinStart.perpT());
@@ skipping 37 matching lines @@
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::validatePerpPt(double t, const SkDPoint& pt) const {
     SkASSERT(fDebugSect->fOppSect->fCurve.ptAtT(t) == pt);
 }
 
 
 template<typename TCurve, typename OppCurve>
 SkTSect<TCurve, OppCurve>::SkTSect(const TCurve& c PATH_OPS_DEBUG_T_SECT_PARAMS(int id))
     : fCurve(c)
     , fHeap(sizeof(SkTSpan<TCurve, OppCurve>) * 4)
-    , fCoincident(NULL)
-    , fDeleted(NULL)
+    , fCoincident(nullptr)
+    , fDeleted(nullptr)
     , fActiveCount(0)
     PATH_OPS_DEBUG_T_SECT_PARAMS(fID(id))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fDebugCount(0))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fDebugAllocatedCount(0))
 {
     fHead = addOne();
     fHead->init(c);
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::addOne() {
     SkTSpan<TCurve, OppCurve>* result;
     if (fDeleted) {
         result = fDeleted;
         result->reset();
         fDeleted = result->fNext;
     } else {
         result = new (fHeap.allocThrow(sizeof(SkTSpan<TCurve, OppCurve>)))(
                 SkTSpan<TCurve, OppCurve>);
-        result->fBounded = NULL;
+        result->fBounded = nullptr;
 #if DEBUG_T_SECT
         ++fDebugAllocatedCount;
 #endif
     }
     result->fHasPerp = false;
     result->fDeleted = false;
     ++fActiveCount; 
     PATH_OPS_DEBUG_T_SECT_CODE(result->fID = fDebugCount++ * 2 + fID);
     SkDEBUGCODE(result->fDebugSect = this);
     return result;
@@ skipping 121 matching lines @@
         test = test->next();
     }
     return result;
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::computePerpendiculars(SkTSect<OppCurve, TCurve>* sect2,
         SkTSpan<TCurve, OppCurve>* first, SkTSpan<TCurve, OppCurve>* last) {
     const OppCurve& opp = sect2->fCurve;
     SkTSpan<TCurve, OppCurve>* work = first;
-    SkTSpan<TCurve, OppCurve>* prior = NULL;
+    SkTSpan<TCurve, OppCurve>* prior = nullptr;
     do {
         if (!work->fHasPerp && !work->fCollapsed) {
             if (prior) {
                 work->fCoinStart = prior->fCoinEnd;
             } else {
                 work->fCoinStart.setPerp(fCurve, work->fStartT, work->fPart[0], opp);
             }
             if (work->fCoinStart.isCoincident()) {
                 double perpT = work->fCoinStart.perpT();
                 if (sect2->coincidentHasT(perpT)) {
@@ skipping 67 matching lines @@
         }
     }
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::extractCoincident(
         SkTSect<OppCurve, TCurve>* sect2,
         SkTSpan<TCurve, OppCurve>* first, SkTSpan<TCurve, OppCurve>* last) {
     first = findCoincidentRun(first, &last);
     if (!first) {
-        return NULL;
+        return nullptr;
     }
     // march outwards to find limit of coincidence from here to previous and next spans
     double startT = first->fStartT;
     double oppStartT SK_INIT_TO_AVOID_WARNING;
     double oppEndT SK_INIT_TO_AVOID_WARNING;
     SkTSpan<TCurve, OppCurve>* prev = first->fPrev;
     SkASSERT(first->fCoinStart.isCoincident());
     SkTSpan<OppCurve, TCurve>* oppFirst = first->findOppT(first->fCoinStart.perpT());
     SkASSERT(last->fCoinEnd.isCoincident());
     bool oppMatched = first->fCoinStart.perpT() < first->fCoinEnd.perpT();
@@ skipping 64 matching lines @@
     sect2->validateBounded();
     last = first->fNext;
     this->removeCoincident(first, false);
     sect2->removeCoincident(oppFirst, true);
     if (deleteEmptySpans) {
         this->deleteEmptySpans();
         sect2->deleteEmptySpans();
     }
     this->validate();
     sect2->validate();
-    return last && !last->fDeleted ? last : NULL;
+    return last && !last->fDeleted ? last : nullptr;
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::findCoincidentRun(
         SkTSpan<TCurve, OppCurve>* first, SkTSpan<TCurve, OppCurve>** lastPtr) {
     SkTSpan<TCurve, OppCurve>* work = first;
-    SkTSpan<TCurve, OppCurve>* lastCandidate = NULL;
-    first = NULL;
+    SkTSpan<TCurve, OppCurve>* lastCandidate = nullptr;
+    first = nullptr;
     // find the first fully coincident span
     do {
         if (work->fCoinStart.isCoincident()) {
 #if DEBUG_T_SECT
             work->validatePerpT(work->fCoinStart.perpT());
             work->validatePerpPt(work->fCoinStart.perpT(), work->fCoinStart.perpPt());
 #endif
             SkASSERT(work->hasOppT(work->fCoinStart.perpT()));
             if (!work->fCoinEnd.isCoincident()) {
                 break;
             }
             lastCandidate = work;
             if (!first) {
                 first = work;
             }
         } else if (first && work->fCollapsed) {
             *lastPtr = lastCandidate;
             return first;
         } else {
-            lastCandidate = NULL;
+            lastCandidate = nullptr;
             SkASSERT(!first);
         }
         if (work == *lastPtr) {
             return first;
         }
         work = work->fNext;
         SkASSERT(work);
     } while (true);
     if (lastCandidate) {
         *lastPtr = lastCandidate;
@@ skipping 209 matching lines @@
         *oppMatched = this->matchedDirection(t, sect2, t2);
         *calcMatched = true;
     }
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::mergeCoincidence(SkTSect<OppCurve, TCurve>* sect2) {
     double smallLimit = 0;
     do {
         // find the smallest unprocessed span
-        SkTSpan<TCurve, OppCurve>* smaller = NULL;
+        SkTSpan<TCurve, OppCurve>* smaller = nullptr;
         SkTSpan<TCurve, OppCurve>* test = fCoincident;
         do {
             if (test->fStartT < smallLimit) {
                 continue;
             }
             if (smaller && smaller->fEndT < test->fStartT) {
                 continue;
             }
             smaller = test;
         } while ((test = test->fNext));
         if (!smaller) {
             return;
         }
         smallLimit = smaller->fEndT;
         // find next larger span
-        SkTSpan<TCurve, OppCurve>* prior = NULL;
-        SkTSpan<TCurve, OppCurve>* larger = NULL;
-        SkTSpan<TCurve, OppCurve>* largerPrior = NULL;
+        SkTSpan<TCurve, OppCurve>* prior = nullptr;
+        SkTSpan<TCurve, OppCurve>* larger = nullptr;
+        SkTSpan<TCurve, OppCurve>* largerPrior = nullptr;
         test = fCoincident;
         do {
             if (test->fStartT < smaller->fEndT) {
                 continue;
             }
             SkASSERT(test->fStartT != smaller->fEndT);
             if (larger && larger->fStartT < test->fStartT) {
                 continue;
             }
             largerPrior = prior;
@@ skipping 15 matching lines @@
             } else {
                 fCoincident = larger->fNext;
             }
         }
     } while (true);
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::prev(
         SkTSpan<TCurve, OppCurve>* span) const {
-    SkTSpan<TCurve, OppCurve>* result = NULL;
+    SkTSpan<TCurve, OppCurve>* result = nullptr;
     SkTSpan<TCurve, OppCurve>* test = fHead;
     while (span != test) {
         result = test;
         test = test->fNext;
         SkASSERT(test);
     }
     return result; 
 }
 
 template<typename TCurve, typename OppCurve>
@@ skipping 109 matching lines @@
         }
         SkASSERT(!span->fDeleted || !opp->debugHasBounded(span));
         bounded = next;
     }
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::spanAtT(double t,
         SkTSpan<TCurve, OppCurve>** priorSpan) {
     SkTSpan<TCurve, OppCurve>* test = fHead;
-    SkTSpan<TCurve, OppCurve>* prev = NULL;
+    SkTSpan<TCurve, OppCurve>* prev = nullptr;
     while (test && test->fEndT < t) {
         prev = test;
         test = test->fNext;
     }
     *priorSpan = prev;
-    return test && test->fStartT <= t ? test : NULL;
+    return test && test->fStartT <= t ? test : nullptr;
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::tail() {
     SkTSpan<TCurve, OppCurve>* result = fHead;
     SkTSpan<TCurve, OppCurve>* next = fHead;
     while ((next = next->fNext)) {
         if (next->fEndT > result->fEndT) {
             result = next;
         }
@@ skipping 39 matching lines @@
     SkTSpan<TCurve, OppCurve>* prev = span->fPrev;
     SkTSpan<TCurve, OppCurve>* next = span->fNext;
     if (prev) {
         prev->fNext = next;
         if (next) {
             next->fPrev = prev;
         }
     } else {
         fHead = next;
         if (next) {
-            next->fPrev = NULL;
+            next->fPrev = nullptr;
         }
     }
 }
 
 template<typename TCurve, typename OppCurve>
 bool SkTSect<TCurve, OppCurve>::updateBounded(SkTSpan<TCurve, OppCurve>* first,
         SkTSpan<TCurve, OppCurve>* last, SkTSpan<OppCurve, TCurve>* oppFirst) {
     SkTSpan<TCurve, OppCurve>* test = first;
     const SkTSpan<TCurve, OppCurve>* final = last->next();
     bool deleteSpan = false;
     do {
         deleteSpan |= test->removeAllBounded();
     } while ((test = test->fNext) != final);
-    first->fBounded = NULL;
+    first->fBounded = nullptr;
     first->addBounded(oppFirst, &fHeap);
     // cannot call validate until remove span range is called
     return deleteSpan;
 }
 
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::validate() const {
 #if DEBUG_T_SECT
     int count = 0;
     if (fHead) {
         const SkTSpan<TCurve, OppCurve>* span = fHead;
         SkASSERT(!span->fPrev);
         SkDEBUGCODE(double last = 0);
         do {
             span->validate();
             SkASSERT(span->fStartT >= last);
             SkDEBUGCODE(last = span->fEndT);
             ++count;
-        } while ((span = span->fNext) != NULL);
+        } while ((span = span->fNext) != nullptr);
     }
     SkASSERT(count == fActiveCount);
     SkASSERT(fActiveCount <= fDebugAllocatedCount);
     int deletedCount = 0;
     const SkTSpan<TCurve, OppCurve>* deleted = fDeleted;
     while (deleted) {
         ++deletedCount;
         deleted = deleted->fNext;
     }
     const SkTSpan<TCurve, OppCurve>* coincident = fCoincident;
     while (coincident) {
         ++deletedCount;
         coincident = coincident->fNext;
     }
     SkASSERT(fActiveCount + deletedCount == fDebugAllocatedCount);
 #endif
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::validateBounded() const {
 #if DEBUG_T_SECT
     if (!fHead) {
         return;
     }
     const SkTSpan<TCurve, OppCurve>* span = fHead;
     do {
         span->validateBounded();
-    } while ((span = span->fNext) != NULL);
+    } while ((span = span->fNext) != nullptr);
 #endif
 }
 
 template<typename TCurve, typename OppCurve>
 int SkTSect<TCurve, OppCurve>::EndsEqual(const SkTSect<TCurve, OppCurve>* sect1,
         const SkTSect<OppCurve, TCurve>* sect2, SkIntersections* intersections) {
     int zeroOneSet = 0;
     if (sect1->fCurve[0] == sect2->fCurve[0]) {
         zeroOneSet |= kZeroS1Set | kZeroS2Set;
         intersections->insert(0, 0, sect1->fCurve[0]);
@@ skipping 86 matching lines @@
     void merge(const SkClosestRecord& mate) {
         fC1Span = mate.fC1Span;
         fC2Span = mate.fC2Span;
         fClosest = mate.fClosest;
         fC1Index = mate.fC1Index;
         fC2Index = mate.fC2Index;
     }
     
     void reset() {
         fClosest = FLT_MAX;
-        SkDEBUGCODE(fC1Span = NULL);
-        SkDEBUGCODE(fC2Span = NULL);
+        SkDEBUGCODE(fC1Span = nullptr);
+        SkDEBUGCODE(fC2Span = nullptr);
         SkDEBUGCODE(fC1Index = fC2Index = -1);
     }
 
     void update(const SkClosestRecord& mate) {
         fC1StartT = SkTMin(fC1StartT, mate.fC1StartT);
         fC1EndT = SkTMax(fC1EndT, mate.fC1EndT);
         fC2StartT = SkTMin(fC2StartT, mate.fC2StartT);
         fC2EndT = SkTMax(fC2EndT, mate.fC2EndT);
     }
 
@@ skipping 248 matching lines @@
         } else if (intersections->isCoincident(index + 1)) {
             intersections->removeOne(index + 1);
             --last;
         } else {
             intersections->setCoincident(index++);
         }
         intersections->setCoincident(index);
     }
     SkASSERT(intersections->used() <= TCurve::kMaxIntersections);
 }