Style Change: NULL->nullptr

src/svg/parser/SkSVGParser.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 "SkSVGParser.h"
@@ skipping 20 matching lines @@
 #include "SkSVGText.h"
 #include "SkSVGUse.h"
 #include "SkTSearch.h"
 #include <stdio.h>
 
 static int gGeneratedMatrixID = 0;
 
 SkSVGParser::SkSVGParser(SkXMLParserError* errHandler) :
     SkXMLParser(errHandler),
     fHead(&fEmptyPaint), fIDs(256),
-        fXMLWriter(&fStream), fCurrElement(NULL), fInSVG(false), fSuppressPaint(false) {
+        fXMLWriter(&fStream), fCurrElement(nullptr), fInSVG(false), fSuppressPaint(false) {
     fLastTransform.reset();
     fEmptyPaint.f_fill.set("black");
     fEmptyPaint.f_stroke.set("none");
     fEmptyPaint.f_strokeMiterlimit.set("4");
     fEmptyPaint.f_fillRule.set("winding");
     fEmptyPaint.f_opacity.set("1");
-    fEmptyPaint.fNext = NULL;
+    fEmptyPaint.fNext = nullptr;
     for (int index = SkSVGPaint::kInitial + 1; index < SkSVGPaint::kTerminal; index++) {
         SkString* initial = fEmptyPaint[index];
         if (initial->size() == 0)
             continue;
         fLastFlush[index]->set(*initial);
     }
 }
 
 SkSVGParser::~SkSVGParser() {
 }
@@ skipping 63 matching lines @@
     SkASSERT(fEmptyPaint[field]);
     return *fEmptyPaint[field];
 }
 
 bool SkSVGParser::isStrokeAndFill(  SkSVGPaint** strokeState, SkSVGPaint** fillState) {
     SkSVGPaint* walking = fHead;
     bool stroke = false;
     bool fill = false;
     bool strokeSet = false;
     bool fillSet = false;
-    while (walking != NULL) {
+    while (walking != nullptr) {
         if (strokeSet == false && walking->f_stroke.size() > 0) {
             stroke = walking->f_stroke.equals("none") == false;
             *strokeState = walking;
             strokeSet = true;
         }
         if (fillSet == false && walking->f_fill.size() > 0) {
             fill = walking->f_fill.equals("none") == false;
             *fillState = walking;
             fillSet = true;
         }
         walking = walking->fNext;
     }
     return stroke && fill;
 }
 
 bool SkSVGParser::onAddAttribute(const char name[], const char value[]) {
     return onAddAttributeLen(name, value, strlen(value));
 }
 
 bool SkSVGParser::onAddAttributeLen(const char name[], const char value[], size_t len) {
-    if (fCurrElement == NULL)    // this signals we should ignore attributes for this element
+    if (fCurrElement == nullptr)    // this signals we should ignore attributes for this element
         return true;
     if (fCurrElement->fIsDef == false && fCurrElement->fIsNotDef == false)
         return false; // also an ignored element
     size_t nameLen = strlen(name);
     int attrIndex = findAttribute(fCurrElement, name, nameLen, false);
     if (attrIndex == -1) {
         attrIndex = findAttribute(&fCurrElement->fPaintState, name, nameLen, true);
         if (attrIndex >= 0) {
             fCurrElement->fPaintState.addAttribute(*this, attrIndex, value, len);
             return false;
@@ skipping 31 matching lines @@
         return false;
     const char* nextColon = strchr(name, ':');
     if (nextColon && (size_t)(nextColon - name) < len)
         return false;
     SkSVGTypes type = GetType(name, len);
 //    SkASSERT(type >= 0);
     if (type < 0) {
         type = SkSVGType_G;
 //        return true;
     }
-    SkSVGElement* parent = fParents.count() > 0 ? fParents.top() : NULL;
+    SkSVGElement* parent = fParents.count() > 0 ? fParents.top() : nullptr;
     SkSVGElement* element = CreateElement(type, parent);
     bool result = false;
     if (parent) {
         element->fParent = parent;
         result = fParents.top()->onStartElement(element);
     } else
         *fChildren.append() = element;
     if (strncmp(name, "svg", len) != 0)
         *fParents.append() = element;
     fCurrElement = element;
@@ skipping 14 matching lines @@
 static int32_t strokeFillID = 0;
 
 void SkSVGParser::translate(SkSVGElement* element, bool isDef) {
     SkSVGPaint::Push(&fHead, &element->fPaintState);
     bool isFlushable = element->isFlushable();
     if ((element->fIsDef == false && element->fIsNotDef == false) ||
         (element->fIsDef && isDef == false && element->fIsNotDef == false) ||
         (element->fIsDef == false && isDef && element->fIsNotDef)) {
         isFlushable = false;
     }
-    SkSVGPaint* strokeState = NULL, * fillState = NULL;
+    SkSVGPaint* strokeState = nullptr, * fillState = nullptr;
     if (isFlushable)
         element->fPaintState.setSave(*this);
     if (isFlushable && isStrokeAndFill(&strokeState, &fillState)) {
         SkString& elementID = element->f_id;
         if (elementID.size() == 0) {
             elementID.set("sf");
             elementID.appendS32(++strokeFillID);
         }
         SkString saveStroke(strokeState->f_stroke);
         SkString saveFill(fillState->f_fill);
@@ skipping 30 matching lines @@
     _startElement("matrix");
     char idStr[24];
     strcpy(idStr, "sk_matrix");
     sprintf(idStr + strlen(idStr), "%d", gGeneratedMatrixID);
     _addAttribute("id", idStr);
     stringID->set(idStr);
     const char* str = string.c_str();
     SkASSERT(strncmp(str, "matrix(", 7) == 0);
     str += 6;
     const char* strEnd = strrchr(str, ')');
-    SkASSERT(strEnd != NULL);
+    SkASSERT(strEnd != nullptr);
     SkString mat(str, strEnd - str);
     ConvertToArray(mat);
     const char* elems[6];
     static const int order[] = {0, 3, 1, 4, 2, 5};
     const int* orderPtr = order;
     str = mat.c_str();
     strEnd = str + mat.size();
     while (str < strEnd) {
         elems[*orderPtr++] = str;
         while (str < strEnd && *str != ',' )
             str++;
         str++;
     }
     string.reset();
     for (int index = 0; index < 6; index++) {
         const char* end = strchr(elems[index], ',');
-        if (end == NULL)
+        if (end == nullptr)
             end= strchr(elems[index], ']');
         string.append(elems[index], end - elems[index] + 1);
     }
     string.remove(string.size() - 1, 1);
     string.append(",0,0,1]");
     _addAttribute("matrix", string);
     _endElement();  // matrix
 }
 
 static bool is_whitespace(char ch) {
@@ skipping 30 matching lines @@
 undoLastComma:
     while (is_whitespace(valCh[--index]))
         ;
     if (valCh[index] == ',')
         valCh[index] = ' ';
 }
 
 #define CASE_NEW(type) case SkSVGType_##type : created = new SkSVG##type(); break
 
 SkSVGElement* SkSVGParser::CreateElement(SkSVGTypes type, SkSVGElement* parent) {
-    SkSVGElement* created = NULL;
+    SkSVGElement* created = nullptr;
     switch (type) {
         CASE_NEW(Circle);
         CASE_NEW(ClipPath);
         CASE_NEW(Defs);
         CASE_NEW(Ellipse);
         CASE_NEW(FeColorMatrix);
         CASE_NEW(Filter);
         CASE_NEW(G);
         CASE_NEW(Image);
         CASE_NEW(Line);
         CASE_NEW(LinearGradient);
         CASE_NEW(Mask);
         CASE_NEW(Metadata);
         CASE_NEW(Path);
         CASE_NEW(Polygon);
         CASE_NEW(Polyline);
         CASE_NEW(RadialGradient);
         CASE_NEW(Rect);
         CASE_NEW(Stop);
         CASE_NEW(SVG);
         CASE_NEW(Symbol);
         CASE_NEW(Text);
         CASE_NEW(Tspan);
         CASE_NEW(Use);
         default:
             SkASSERT(0);
-            return NULL;
+            return nullptr;
     }
     created->fParent = parent;
     bool isDef = created->fIsDef = created->isDef();
     bool isNotDef = created->fIsNotDef = created->isNotDef();
     if (isDef) {
         SkSVGElement* up = parent;
         while (up && up->fIsDef == false) {
             up->fIsDef = true;
             up = up->fParent;
         }
@@ skipping 35 matching lines @@
 };
 
 const int kSVGTypeNamesSize = SK_ARRAY_COUNT(gSVGTypeNames);
 
 SkSVGTypes SkSVGParser::GetType(const char match[], size_t len ) {
     int index = SkStrSearch(&gSVGTypeNames[0].fName, kSVGTypeNamesSize, match,
         len, sizeof(gSVGTypeNames[0]));
     return index >= 0 && index < kSVGTypeNamesSize ? gSVGTypeNames[index].fType :
         (SkSVGTypes) -1;
 }