Style Change: NULL->nullptr

src/pathops/SkOpSegment.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpCoincidence.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 32 matching lines @@
 #undef T
 
 SkOpAngle* SkOpSegment::activeAngle(SkOpSpanBase* start, SkOpSpanBase** startPtr,
         SkOpSpanBase** endPtr, bool* done) {
     if (SkOpAngle* result = activeAngleInner(start, startPtr, endPtr, done)) {
         return result;
     }
     if (SkOpAngle* result = activeAngleOther(start, startPtr, endPtr, done)) {
         return result;
     }
-    return NULL;
+    return nullptr;
 }
 
 SkOpAngle* SkOpSegment::activeAngleInner(SkOpSpanBase* start, SkOpSpanBase** startPtr,
         SkOpSpanBase** endPtr, bool* done) {
     SkOpSpan* upSpan = start->upCastable();
     if (upSpan) {
         if (upSpan->windValue() || upSpan->oppValue()) {
             SkOpSpanBase* next = upSpan->next();
             if (!*endPtr) {
                 *startPtr = start;
@@ skipping 20 matching lines @@
             if (!downSpan->done()) {
                 if (downSpan->windSum() != SK_MinS32) {
                     return spanToAngle(start, downSpan);
                 }
                 *done = false;
             }
         } else {
             SkASSERT(downSpan->done());
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 SkOpAngle* SkOpSegment::activeAngleOther(SkOpSpanBase* start, SkOpSpanBase** startPtr,
         SkOpSpanBase** endPtr, bool* done) {
     SkOpPtT* oPtT = start->ptT()->next();
     SkOpSegment* other = oPtT->segment();
     SkOpSpanBase* oSpan = oPtT->span();
     return other->activeAngleInner(oSpan, startPtr, endPtr, done);
 }
 
@@ skipping 185 matching lines @@
                     path->cubicTo(ePtr[1], ePtr[2], ePtr[3]);
                     break;
                 default:
                     SkASSERT(0);
             }
         }
     }
 }
 
 SkOpPtT* SkOpSegment::addMissing(double t, SkOpSegment* opp, SkChunkAlloc* allocator) {
-    SkOpSpanBase* existing = NULL;
+    SkOpSpanBase* existing = nullptr;
     SkOpSpanBase* test = &fHead;
     double testT;
     do {
         if ((testT = test->ptT()->fT) >= t) {
             if (testT == t) {
                 existing = test;
             }
             break;
         }
     } while ((test = test->upCast()->next()));
@@ skipping 55 matching lines @@
 #if DEBUG_ADD_T
             SkDebugf("%s insert t=%1.9g segID=%d spanID=%d\n", __FUNCTION__, t,
                     span->segment()->debugID(), span->debugID());
 #endif
             span->bumpSpanAdds();
             return span->ptT();
         }
         SkASSERT(span != &fTail);
     } while ((span = span->upCast()->next()));
     SkASSERT(0);
-    return NULL;
+    return nullptr;
 }
 
 // choose a solitary t and pt value; remove aliases; align the opposite ends
 void SkOpSegment::align() {
     debugValidate();
     SkOpSpanBase* span = &fHead;
     if (!span->aligned()) {
         span->alignEnd(0, fPts[0]);
     }
     while ((span = span->upCast()->next())) {
@@ skipping 125 matching lines @@
         last = nextSegment->markAngle(maxWinding, sumWinding, nextAngle);
     }
     nextAngle->setLastMarked(last);
 }
 
 // at this point, the span is already ordered, or unorderable
 int SkOpSegment::computeSum(SkOpSpanBase* start, SkOpSpanBase* end,
         SkOpAngle::IncludeType includeType) {
     SkASSERT(includeType != SkOpAngle::kUnaryXor);
     SkOpAngle* firstAngle = this->spanToAngle(end, start);
-    if (NULL == firstAngle || NULL == firstAngle->next()) {
+    if (nullptr == firstAngle || nullptr == firstAngle->next()) {
         return SK_NaN32;
     }
     // if all angles have a computed winding,
     //  or if no adjacent angles are orderable,
     //  or if adjacent orderable angles have no computed winding,
     //  there's nothing to do
     // if two orderable angles are adjacent, and both are next to orderable angles,
     //  and one has winding computed, transfer to the other
-    SkOpAngle* baseAngle = NULL;
+    SkOpAngle* baseAngle = nullptr;
     bool tryReverse = false;
     // look for counterclockwise transfers
     SkOpAngle* angle = firstAngle->previous();
     SkOpAngle* next = angle->next();
     firstAngle = next;
     do {
         SkOpAngle* prior = angle;
         angle = next;
         next = angle->next();
         SkASSERT(prior->next() == angle);
         SkASSERT(angle->next() == next);
         if (prior->unorderable() || angle->unorderable() || next->unorderable()) {
-            baseAngle = NULL;
+            baseAngle = nullptr;
             continue;
         }
         int testWinding = angle->starter()->windSum();
         if (SK_MinS32 != testWinding) {
             baseAngle = angle;
             tryReverse = true;
             continue;
         }
         if (baseAngle) {
             ComputeOneSum(baseAngle, angle, includeType);
-            baseAngle = SK_MinS32 != angle->starter()->windSum() ? angle : NULL;
+            baseAngle = SK_MinS32 != angle->starter()->windSum() ? angle : nullptr;
         }
     } while (next != firstAngle);
     if (baseAngle && SK_MinS32 == firstAngle->starter()->windSum()) {
         firstAngle = baseAngle;
         tryReverse = true;
     }
     if (tryReverse) {
-        baseAngle = NULL;
+        baseAngle = nullptr;
         SkOpAngle* prior = firstAngle;
         do {
             angle = prior;
             prior = angle->previous();
             SkASSERT(prior->next() == angle);
             next = angle->next();
             if (prior->unorderable() || angle->unorderable() || next->unorderable()) {
-                baseAngle = NULL;
+                baseAngle = nullptr;
                 continue;
             }
             int testWinding = angle->starter()->windSum();
             if (SK_MinS32 != testWinding) {
                 baseAngle = angle;
                 continue;
             }
             if (baseAngle) {
                 ComputeOneSumReverse(baseAngle, angle, includeType);
-                baseAngle = SK_MinS32 != angle->starter()->windSum() ? angle : NULL;
+                baseAngle = SK_MinS32 != angle->starter()->windSum() ? angle : nullptr;
             }
         } while (prior != firstAngle);
     }
     return start->starter(end)->windSum();
 }
 
 void SkOpSegment::detach(const SkOpSpan* span) {
     if (span->done()) {
         --fDoneCount;
     }
@@ skipping 47 matching lines @@
     int step = start->step(end);
     SkOpSegment* other = this->isSimple(nextStart, &step);  // advances nextStart
     if (other) {
     // mark the smaller of startIndex, endIndex done, and all adjacent
     // spans with the same T value (but not 'other' spans)
 #if DEBUG_WINDING
         SkDebugf("%s simple\n", __FUNCTION__);
 #endif
         SkOpSpan* startSpan = start->starter(end);
         if (startSpan->done()) {
-            return NULL;
+            return nullptr;
         }
         markDone(startSpan);
         *nextEnd = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
         return other;
     }
     SkOpSpanBase* endNear = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
     SkASSERT(endNear == end);  // is this ever not end?
     SkASSERT(endNear);
     SkASSERT(start != endNear);
     SkASSERT((start->t() < endNear->t()) ^ (step < 0));
     // more than one viable candidate -- measure angles to find best
     int calcWinding = computeSum(start, endNear, SkOpAngle::kBinaryOpp);
     bool sortable = calcWinding != SK_NaN32;
     if (!sortable) {
         *unsortable = true;
         markDone(start->starter(end));
-        return NULL;
+        return nullptr;
     }
     SkOpAngle* angle = this->spanToAngle(end, start);
     if (angle->unorderable()) {
         *unsortable = true;
         markDone(start->starter(end));
-        return NULL;
+        return nullptr;
     }
 #if DEBUG_SORT
     SkDebugf("%s\n", __FUNCTION__);
     angle->debugLoop();
 #endif
     int sumMiWinding = updateWinding(end, start);
     if (sumMiWinding == SK_MinS32) {
         *unsortable = true;
         markDone(start->starter(end));
-        return NULL;
+        return nullptr;
     }
     int sumSuWinding = updateOppWinding(end, start);
     if (operand()) {
         SkTSwap<int>(sumMiWinding, sumSuWinding);
     }
     SkOpAngle* nextAngle = angle->next();
-    const SkOpAngle* foundAngle = NULL;
+    const SkOpAngle* foundAngle = nullptr;
     bool foundDone = false;
     // iterate through the angle, and compute everyone's winding
     SkOpSegment* nextSegment;
     int activeCount = 0;
     do {
         nextSegment = nextAngle->segment();
         bool activeAngle = nextSegment->activeOp(xorMiMask, xorSuMask, nextAngle->start(),
                 nextAngle->end(), op, &sumMiWinding, &sumSuWinding);
         if (activeAngle) {
             ++activeCount;
@@ skipping 17 matching lines @@
                     last->segment()->debugID(), last->debugID());
             if (!last->final()) {
                 SkDebugf(" windSum=%d", last->upCast()->windSum());
             }
             SkDebugf("\n");
 #endif
         }
     } while ((nextAngle = nextAngle->next()) != angle);
     start->segment()->markDone(start->starter(end));
     if (!foundAngle) {
-        return NULL;
+        return nullptr;
     }
     *nextStart = foundAngle->start();
     *nextEnd = foundAngle->end();
     nextSegment = foundAngle->segment();
 #if DEBUG_WINDING
     SkDebugf("%s from:[%d] to:[%d] start=%d end=%d\n",
             __FUNCTION__, debugID(), nextSegment->debugID(), *nextStart, *nextEnd);
  #endif
     return nextSegment;
 }
 
 SkOpSegment* SkOpSegment::findNextWinding(SkTDArray<SkOpSpanBase*>* chase,
         SkOpSpanBase** nextStart, SkOpSpanBase** nextEnd, bool* unsortable) {
     SkOpSpanBase* start = *nextStart;
     SkOpSpanBase* end = *nextEnd;
     SkASSERT(start != end);
     int step = start->step(end);
     SkOpSegment* other = this->isSimple(nextStart, &step);  // advances nextStart
     if (other) {
     // mark the smaller of startIndex, endIndex done, and all adjacent
     // spans with the same T value (but not 'other' spans)
 #if DEBUG_WINDING
         SkDebugf("%s simple\n", __FUNCTION__);
 #endif
         SkOpSpan* startSpan = start->starter(end);
         if (startSpan->done()) {
-            return NULL;
+            return nullptr;
         }
         markDone(startSpan);
         *nextEnd = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
         return other;
     }
     SkOpSpanBase* endNear = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
     SkASSERT(endNear == end);  // is this ever not end?
     SkASSERT(endNear);
     SkASSERT(start != endNear);
     SkASSERT((start->t() < endNear->t()) ^ (step < 0));
     // more than one viable candidate -- measure angles to find best
     int calcWinding = computeSum(start, endNear, SkOpAngle::kUnaryWinding);
     bool sortable = calcWinding != SK_NaN32;
     if (!sortable) {
         *unsortable = true;
         markDone(start->starter(end));
-        return NULL;
+        return nullptr;
     }
     SkOpAngle* angle = this->spanToAngle(end, start);
     if (angle->unorderable()) {
         *unsortable = true;
         markDone(start->starter(end));
-        return NULL;
+        return nullptr;
     }
 #if DEBUG_SORT
     SkDebugf("%s\n", __FUNCTION__);
     angle->debugLoop();
 #endif
     int sumWinding = updateWinding(end, start);
     SkOpAngle* nextAngle = angle->next();
-    const SkOpAngle* foundAngle = NULL;
+    const SkOpAngle* foundAngle = nullptr;
     bool foundDone = false;
     // iterate through the angle, and compute everyone's winding
     SkOpSegment* nextSegment;
     int activeCount = 0;
     do {
         nextSegment = nextAngle->segment();
         bool activeAngle = nextSegment->activeWinding(nextAngle->start(), nextAngle->end(),
                 &sumWinding);
         if (activeAngle) {
             ++activeCount;
@@ skipping 17 matching lines @@
                     last->segment()->debugID(), last->debugID());
             if (!last->final()) {
                 SkDebugf(" windSum=%d", last->upCast()->windSum());
             }
             SkDebugf("\n");
 #endif
         }
     } while ((nextAngle = nextAngle->next()) != angle);
     start->segment()->markDone(start->starter(end));
     if (!foundAngle) {
-        return NULL;
+        return nullptr;
     }
     *nextStart = foundAngle->start();
     *nextEnd = foundAngle->end();
     nextSegment = foundAngle->segment();
 #if DEBUG_WINDING
     SkDebugf("%s from:[%d] to:[%d] start=%d end=%d\n",
             __FUNCTION__, debugID(), nextSegment->debugID(), *nextStart, *nextEnd);
  #endif
     return nextSegment;
 }
 
 SkOpSegment* SkOpSegment::findNextXor(SkOpSpanBase** nextStart, SkOpSpanBase** nextEnd,
         bool* unsortable) {
     SkOpSpanBase* start = *nextStart;
     SkOpSpanBase* end = *nextEnd;
     SkASSERT(start != end);
     int step = start->step(end);
     SkOpSegment* other = this->isSimple(nextStart, &step);  // advances nextStart
     if (other) {
     // mark the smaller of startIndex, endIndex done, and all adjacent
     // spans with the same T value (but not 'other' spans)
 #if DEBUG_WINDING
         SkDebugf("%s simple\n", __FUNCTION__);
 #endif
         SkOpSpan* startSpan = start->starter(end);
         if (startSpan->done()) {
-            return NULL;
+            return nullptr;
         }
         markDone(startSpan);
         *nextEnd = step > 0 ? (*nextStart)->upCast()->next() : (*nextStart)->prev();
         return other;
     }
     SkDEBUGCODE(SkOpSpanBase* endNear = step > 0 ? (*nextStart)->upCast()->next() \
             : (*nextStart)->prev());
     SkASSERT(endNear == end);  // is this ever not end?
     SkASSERT(endNear);
     SkASSERT(start != endNear);
     SkASSERT((start->t() < endNear->t()) ^ (step < 0));
     SkOpAngle* angle = this->spanToAngle(end, start);
     if (!angle || angle->unorderable()) {
         *unsortable = true;
         markDone(start->starter(end));
-        return NULL;
+        return nullptr;
     }
 #if DEBUG_SORT
     SkDebugf("%s\n", __FUNCTION__);
     angle->debugLoop();
 #endif
     SkOpAngle* nextAngle = angle->next();
-    const SkOpAngle* foundAngle = NULL;
+    const SkOpAngle* foundAngle = nullptr;
     bool foundDone = false;
     // iterate through the angle, and compute everyone's winding
     SkOpSegment* nextSegment;
     int activeCount = 0;
     do {
         nextSegment = nextAngle->segment();
         ++activeCount;
         if (!foundAngle || (foundDone && activeCount & 1)) {
             foundAngle = nextAngle;
             if (!(foundDone = nextSegment->done(nextAngle))) {
                 break;
             }
         }
         nextAngle = nextAngle->next();
     } while (nextAngle != angle);
     start->segment()->markDone(start->starter(end));
     if (!foundAngle) {
-        return NULL;
+        return nullptr;
     }
     *nextStart = foundAngle->start();
     *nextEnd = foundAngle->end();
     nextSegment = foundAngle->segment();
 #if DEBUG_WINDING
     SkDebugf("%s from:[%d] to:[%d] start=%d end=%d\n",
             __FUNCTION__, debugID(), nextSegment->debugID(), *nextStart, *nextEnd);
  #endif
     return nextSegment;
 }
 
 SkOpGlobalState* SkOpSegment::globalState() const {
     return contour()->globalState(); 
 }
 
 void SkOpSegment::init(SkPoint pts[], SkScalar weight, SkOpContour* contour, SkPath::Verb verb) {
     fContour = contour;
-    fNext = NULL;
+    fNext = nullptr;
     fOriginal[0] = pts[0];
     fOriginal[1] = pts[SkPathOpsVerbToPoints(verb)];
     fPts = pts;
     fWeight = weight;
     fVerb = verb;
     fCubicType = SkDCubic::kUnsplit_SkDCubicType;
     fCount = 0;
     fDoneCount = 0;
     fTopsFound = false;
     fVisited = false;
     SkOpSpan* zeroSpan = &fHead;
-    zeroSpan->init(this, NULL, 0, fPts[0]);
+    zeroSpan->init(this, nullptr, 0, fPts[0]);
     SkOpSpanBase* oneSpan = &fTail;
     zeroSpan->setNext(oneSpan);
     oneSpan->initBase(this, zeroSpan, 1, fPts[SkPathOpsVerbToPoints(fVerb)]);
     SkDEBUGCODE(fID = globalState()->nextSegmentID());
 }
 
 bool SkOpSegment::isClose(double t, const SkOpSegment* opp) const {
     SkDPoint cPt = this->dPtAtT(t);
     SkDVector dxdy = (*CurveDSlopeAtT[this->verb()])(this->pts(), this->weight(), t);
     SkDLine perp = {{ cPt, {cPt.fX + dxdy.fY, cPt.fY - dxdy.fX} }};
@@ skipping 16 matching lines @@
     SkOpSpan* span = this->head();
     do {
         this->markDone(span);
     } while ((span = span->next()->upCastable()));
 }
 
 SkOpSpanBase* SkOpSegment::markAndChaseDone(SkOpSpanBase* start, SkOpSpanBase* end) {
     int step = start->step(end);
     SkOpSpan* minSpan = start->starter(end);
     markDone(minSpan);
-    SkOpSpanBase* last = NULL;
+    SkOpSpanBase* last = nullptr;
     SkOpSegment* other = this;
     while ((other = other->nextChase(&start, &step, &minSpan, &last))) {
         if (other->done()) {
             SkASSERT(!last);
             break;
         }
         other->markDone(minSpan);
     }
     return last;
 }
 
 bool SkOpSegment::markAndChaseWinding(SkOpSpanBase* start, SkOpSpanBase* end, int winding,
         SkOpSpanBase** lastPtr) {
     SkOpSpan* spanStart = start->starter(end);
     int step = start->step(end);
     bool success = markWinding(spanStart, winding);
-    SkOpSpanBase* last = NULL;
+    SkOpSpanBase* last = nullptr;
     SkOpSegment* other = this;
     while ((other = other->nextChase(&start, &step, &spanStart, &last))) {
         if (spanStart->windSum() != SK_MinS32) {
             SkASSERT(spanStart->windSum() == winding);
             SkASSERT(!last);
             break;
         }
         (void) other->markWinding(spanStart, winding);
     }
     if (lastPtr) {
         *lastPtr = last;
     }
     return success;
 }
 
 bool SkOpSegment::markAndChaseWinding(SkOpSpanBase* start, SkOpSpanBase* end,
         int winding, int oppWinding, SkOpSpanBase** lastPtr) {
     SkOpSpan* spanStart = start->starter(end);
     int step = start->step(end);
     bool success = markWinding(spanStart, winding, oppWinding);
-    SkOpSpanBase* last = NULL;
+    SkOpSpanBase* last = nullptr;
     SkOpSegment* other = this;
     while ((other = other->nextChase(&start, &step, &spanStart, &last))) {
         if (spanStart->windSum() != SK_MinS32) {
             if (this->operand() == other->operand()) {
                 if (spanStart->windSum() != winding || spanStart->oppSum() != oppWinding) {
                     this->globalState()->setWindingFailed();
                     return false;
                 }
             } else {
                 SkASSERT(spanStart->windSum() == oppWinding);
@@ skipping 37 matching lines @@
 
 SkOpSpanBase* SkOpSegment::markAngle(int maxWinding, int sumWinding, int oppMaxWinding,
                                    int oppSumWinding, const SkOpAngle* angle) {
     SkASSERT(angle->segment() == this);
     if (UseInnerWinding(maxWinding, sumWinding)) {
         maxWinding = sumWinding;
     }
     if (oppMaxWinding != oppSumWinding && UseInnerWinding(oppMaxWinding, oppSumWinding)) {
         oppMaxWinding = oppSumWinding;
     }
-    SkOpSpanBase* last = NULL;
+    SkOpSpanBase* last = nullptr;
     // caller doesn't require that this marks anything
     (void) markAndChaseWinding(angle->start(), angle->end(), maxWinding, oppMaxWinding, &last);
 #if DEBUG_WINDING
     if (last) {
         SkDebugf("%s last segment=%d span=%d", __FUNCTION__,
                 last->segment()->debugID(), last->debugID());
         if (!last->final()) {
             SkDebugf(" windSum=");
             SkPathOpsDebug::WindingPrintf(last->upCast()->windSum());
         }
@@ skipping 54 matching lines @@
     if (!SkDPoint::ApproximatelyEqual(testPt, base->fPt)) {
         return false;
     }
     return !this->ptsDisjoint(base->fT, base->fPt, testT, testPt);
 }
 
 static SkOpSegment* set_last(SkOpSpanBase** last, SkOpSpanBase* endSpan) {
     if (last) {
         *last = endSpan;
     }
-    return NULL;
+    return nullptr;
 }
 
 SkOpSegment* SkOpSegment::nextChase(SkOpSpanBase** startPtr, int* stepPtr, SkOpSpan** minPtr,
         SkOpSpanBase** last) const {
     SkOpSpanBase* origStart = *startPtr;
     int step = *stepPtr;
     SkOpSpanBase* endSpan = step > 0 ? origStart->upCast()->next() : origStart->prev();
     SkASSERT(endSpan);
     SkOpAngle* angle = step > 0 ? endSpan->fromAngle() : endSpan->upCast()->toAngle();
     SkOpSpanBase* foundSpan;
     SkOpSpanBase* otherEnd;
     SkOpSegment* other;
-    if (angle == NULL) {
+    if (angle == nullptr) {
         if (endSpan->t() != 0 && endSpan->t() != 1) {
-            return NULL;
+            return nullptr;
         }
         SkOpPtT* otherPtT = endSpan->ptT()->next();
         other = otherPtT->segment();
         foundSpan = otherPtT->span();
         otherEnd = step > 0 ? foundSpan->upCast()->next() : foundSpan->prev();
     } else {
         int loopCount = angle->loopCount();
         if (loopCount > 2) {
             return set_last(last, endSpan);
         }
         const SkOpAngle* next = angle->next();
-        if (NULL == next) {
-            return NULL;
+        if (nullptr == next) {
+            return nullptr;
         }
 #if DEBUG_WINDING
         if (angle->debugSign() != next->debugSign() && !angle->segment()->contour()->isXor()
                 && !next->segment()->contour()->isXor()) {
             SkDebugf("%s mismatched signs\n", __FUNCTION__);
         }
 #endif
         other = next->segment();
         foundSpan = endSpan = next->start();
         otherEnd = next->end();
     }
     int foundStep = foundSpan->step(otherEnd);
     if (*stepPtr != foundStep) {
         return set_last(last, endSpan);
     }
     SkASSERT(*startPtr);
     if (!otherEnd) {
-        return NULL;
+        return nullptr;
     }
 //    SkASSERT(otherEnd >= 0);
     SkOpSpan* origMin = step < 0 ? origStart->prev() : origStart->upCast();
     SkOpSpan* foundMin = foundSpan->starter(otherEnd);
     if (foundMin->windValue() != origMin->windValue()
             || foundMin->oppValue() != origMin->oppValue()) {
           return set_last(last, endSpan);
     }
     *startPtr = foundSpan;
     *stepPtr = foundStep;
@@ skipping 19 matching lines @@
 // curve/curve intersection should now do a pretty good job of finding coincident runs so 
 // this may be only be necessary for line/curve pairs -- so skip unless this is a line and the
 // the opp is not a line
 bool SkOpSegment::missingCoincidence(SkOpCoincidence* coincidences, SkChunkAlloc* allocator) {
     if (this->verb() != SkPath::kLine_Verb) {
         return false;
     }
     if (this->done()) {
         return false;
     }
-    SkOpSpan* prior = NULL;
+    SkOpSpan* prior = nullptr;
     SkOpSpanBase* spanBase = &fHead;
     do {
         SkOpPtT* ptT = spanBase->ptT(), * spanStopPtT = ptT;
         SkASSERT(ptT->span() == spanBase);
         while ((ptT = ptT->next()) != spanStopPtT) {
             if (ptT->deleted()) {
                 continue;
             }
             SkOpSegment* opp = ptT->span()->segment();
             if (opp->verb() == SkPath::kLine_Verb) {
@@ skipping 11 matching lines @@
             }
             SkOpSpan* span = spanBase->upCastable();
             // FIXME?: this assumes that if the opposite segment is coincident then no more
             // coincidence needs to be detected. This may not be true.
             if (span && span->containsCoincidence(opp)) { 
                 continue;
             }
             if (spanBase->containsCoinEnd(opp)) {
                 continue;
             } 
-            SkOpPtT* priorPtT = NULL, * priorStopPtT;
+            SkOpPtT* priorPtT = nullptr, * priorStopPtT;
             // find prior span containing opp segment
-            SkOpSegment* priorOpp = NULL;
+            SkOpSegment* priorOpp = nullptr;
             SkOpSpan* priorTest = spanBase->prev();
             while (!priorOpp && priorTest) {
                 priorStopPtT = priorPtT = priorTest->ptT();
                 while ((priorPtT = priorPtT->next()) != priorStopPtT) {
                     if (priorPtT->deleted()) {
                         continue;
                     }
                     SkOpSegment* segment = priorPtT->span()->segment();
                     if (segment == opp) {
                         prior = priorTest;
@@ skipping 26 matching lines @@
                     coincidences->add(priorPtT, ptT, oppStart, oppEnd, allocator);
                 }
                 clear_visited(&fHead);
                 return true;
             }
     swapBack:
             if (swapped) {
                 SkTSwap(priorPtT, ptT);
             }
         }
-    } while ((spanBase = spanBase->final() ? NULL : spanBase->upCast()->next()));
+    } while ((spanBase = spanBase->final() ? nullptr : spanBase->upCast()->next()));
     clear_visited(&fHead);
     return false;
 }
 
 // if a span has more than one intersection, merge the other segments' span as needed
 void SkOpSegment::moveMultiples() {
     debugValidate();
     SkOpSpanBase* test = &fHead;
     do {
         int addCount = test->spanAddsCount();
@@ skipping 25 matching lines @@
                 if (oppPrev->spanAddsCount() == addCount) {
                     continue;
                 }
                 if (oppPrev->deleted()) {
                     continue;
                 }
                 oppFirst = oppPrev;
             }
             SkOpSpanBase* oppNext = oppSpan;
             SkOpSpanBase* oppLast = oppSpan;
-            while ((oppNext = oppNext->final() ? NULL : oppNext->upCast()->next())) {
+            while ((oppNext = oppNext->final() ? nullptr : oppNext->upCast()->next())) {
                 if (!roughly_equal(oppNext->t(), oppSpan->t())) {
                     break;
                 }
                 if (oppNext->spanAddsCount() == addCount) {
                     continue;
                 }
                 if (oppNext->deleted()) {
                     continue;
                 }
                 oppLast = oppNext;
@@ skipping 33 matching lines @@
                     }
                     oppSegment->debugValidate();
                     goto checkNextSpan;
                 }
         tryNextSpan: 
                 ;
             } while (oppTest != oppLast && (oppTest = oppTest->upCast()->next()));
         } while ((testPtT = testPtT->next()) != startPtT);
 checkNextSpan: 
         ;
-    } while ((test = test->final() ? NULL : test->upCast()->next()));
+    } while ((test = test->final() ? nullptr : test->upCast()->next()));
     debugValidate();
 }
 
 // Move nearby t values and pts so they all hang off the same span. Alignment happens later.
 void SkOpSegment::moveNearby() {
     debugValidate();
     SkOpSpanBase* spanS = &fHead;
     do {
         SkOpSpanBase* test = spanS->upCast()->next();
         SkOpSpanBase* next;
         if (spanS->contains(test)) {
             if (!test->final()) {
                 test->upCast()->detach(spanS->ptT());
                 continue;
             } else if (spanS != &fHead) {
                 spanS->upCast()->detach(test->ptT());
                 spanS = test;
                 continue;
             }
         }
         do {  // iterate through all spans associated with start
             SkOpPtT* startBase = spanS->ptT();
-            next = test->final() ? NULL : test->upCast()->next();
+            next = test->final() ? nullptr : test->upCast()->next();
             do {
                 SkOpPtT* testBase = test->ptT();
                 do {
                     if (startBase == testBase) {
                         goto checkNextSpan;
                     }
                     if (testBase->duplicate()) {
                         continue;
                     }
                     if (this->match(startBase, testBase->segment(), testBase->fT, testBase->fPt)) {
@@ skipping 69 matching lines @@
         *oppSumWinding = *sumSuWinding -= oppDeltaSum;
     }
     SkASSERT(!DEBUG_LIMIT_WIND_SUM || SkTAbs(*sumWinding) <= DEBUG_LIMIT_WIND_SUM);
     SkASSERT(!DEBUG_LIMIT_WIND_SUM || SkTAbs(*oppSumWinding) <= DEBUG_LIMIT_WIND_SUM);
 }
 
 void SkOpSegment::sortAngles() {
     SkOpSpanBase* span = &this->fHead;
     do {
         SkOpAngle* fromAngle = span->fromAngle();
-        SkOpAngle* toAngle = span->final() ? NULL : span->upCast()->toAngle();
+        SkOpAngle* toAngle = span->final() ? nullptr : span->upCast()->toAngle();
         if (!fromAngle && !toAngle) {
             continue;
         }
 #if DEBUG_ANGLE
         bool wroteAfterHeader = false;
 #endif
         SkOpAngle* baseAngle = fromAngle;
         if (fromAngle && toAngle) {
 #if DEBUG_ANGLE
             SkDebugf("%s [%d] tStart=%1.9g [%d]\n", __FUNCTION__, debugID(), span->t(),
@@ skipping 33 matching lines @@
                         wroteAfterHeader = true;
                     }
 #endif
                     if (!oAngle->loopContains(baseAngle)) {
                         baseAngle->insert(oAngle);
                     }
                 }
             }
         } while ((ptT = ptT->next()) != stopPtT);
         if (baseAngle->loopCount() == 1) {
-            span->setFromAngle(NULL);
+            span->setFromAngle(nullptr);
             if (toAngle) {
-                span->upCast()->setToAngle(NULL);
+                span->upCast()->setToAngle(nullptr);
             }
-            baseAngle = NULL;
+            baseAngle = nullptr;
         }
 #if DEBUG_SORT
         SkASSERT(!baseAngle || baseAngle->loopCount() > 1);
 #endif
     } while (!span->final() && (span = span->upCast()->next()));
 }
 
 // return true if midpoints were computed
 bool SkOpSegment::subDivide(const SkOpSpanBase* start, const SkOpSpanBase* end,
         SkOpCurve* edge) const {
@@ skipping 199 matching lines @@
     int absOut = SkTAbs(outerWinding);
     int absIn = SkTAbs(innerWinding);
     bool result = absOut == absIn ? outerWinding < 0 : absOut < absIn;
     return result;
 }
 
 int SkOpSegment::windSum(const SkOpAngle* angle) const {
     const SkOpSpan* minSpan = angle->start()->starter(angle->end());
     return minSpan->windSum();
 }