Style Change: NULL->nullptr

src/animator/SkDisplayXMLParser.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 "SkDisplayXMLParser.h"
@@ skipping 53 matching lines @@
     inner.prepend(": ");
     inner.prependS32(getLineNumber());
     inner.prepend(", line ");
     inner.prepend(src);
     parent->setErrorNoun(inner);
 }
 
 
 SkDisplayXMLParser::SkDisplayXMLParser(SkAnimateMaker& maker)
     : INHERITED(&maker.fError), fMaker(maker), fInInclude(maker.fInInclude),
-        fInSkia(maker.fInInclude), fCurrDisplayable(NULL)
+        fInSkia(maker.fInInclude), fCurrDisplayable(nullptr)
 {
 }
 
 SkDisplayXMLParser::~SkDisplayXMLParser() {
     if (fCurrDisplayable && fMaker.fChildren.find(fCurrDisplayable) < 0)
         delete fCurrDisplayable;
     for (Parent* parPtr = fParents.begin() + 1; parPtr < fParents.end(); parPtr++) {
         SkDisplayable* displayable = parPtr->fDisplayable;
         if (displayable == fCurrDisplayable)
             continue;
         SkASSERT(fMaker.fChildren.find(displayable) < 0);
         if (fMaker.fHelpers.find(displayable) < 0)
             delete displayable;
     }
 }
 
 
 
 bool SkDisplayXMLParser::onAddAttribute(const char name[], const char value[]) {
     return onAddAttributeLen(name, value, strlen(value));
 }
 
 bool SkDisplayXMLParser::onAddAttributeLen(const char attrName[], const char attrValue[],
                                         size_t attrValueLen)
 {
-    if (fCurrDisplayable == NULL)    // this signals we should ignore attributes for this element
+    if (fCurrDisplayable == nullptr)    // this signals we should ignore attributes for this element
         return strncmp(attrName, "xmlns", sizeof("xmlns") - 1) != 0;
     SkDisplayable*  displayable = fCurrDisplayable;
     SkDisplayTypes  type = fCurrType;
 
     if (strcmp(attrName, "id") == 0) {
-        if (fMaker.find(attrValue, attrValueLen, NULL)) {
+        if (fMaker.find(attrValue, attrValueLen, nullptr)) {
             fError->setNoun(attrValue, attrValueLen);
             fError->setCode(SkXMLParserError::kDuplicateIDs);
             return true;
         }
 #ifdef SK_DEBUG
         displayable->_id.set(attrValue, attrValueLen);
         displayable->id = displayable->_id.c_str();
 #endif
         fMaker.idsSet(attrValue, attrValueLen, displayable);
         int parentIndex = fParents.count() - 1;
         if (parentIndex > 0) {
             SkDisplayable* parent = fParents[parentIndex - 1].fDisplayable;
             parent->setChildHasID();
         }
         return false;
     }
     const char* name = attrName;
     const SkMemberInfo* info = SkDisplayType::GetMember(&fMaker, type, &name);
-    if (info == NULL) {
+    if (info == nullptr) {
         fError->setNoun(name);
         fError->setCode(SkXMLParserError::kUnknownAttributeName);
         return true;
     }
-    if (info->setValue(fMaker, NULL, 0, info->getCount(), displayable, info->getType(), attrValue,
+    if (info->setValue(fMaker, nullptr, 0, info->getCount(), displayable, info->getType(), attrValue,
             attrValueLen))
         return false;
     if (fMaker.fError.hasError()) {
         fError->setNoun(attrValue, attrValueLen);
         return true;
     }
-    SkDisplayable* ref = NULL;
+    SkDisplayable* ref = nullptr;
     if (fMaker.find(attrValue, attrValueLen, &ref) == false) {
         ref = fMaker.createInstance(attrValue, attrValueLen);
-        if (ref == NULL) {
+        if (ref == nullptr) {
             fError->setNoun(attrValue, attrValueLen);
             fError->setCode(SkXMLParserError::kErrorInAttributeValue);
             return true;
         } else
             fMaker.helperAdd(ref);
     }
     if (info->fType != SkType_MemberProperty) {
         fError->setNoun(name);
         fError->setCode(SkXMLParserError::kUnknownAttributeName);
         return true;
@@ skipping 26 matching lines @@
         if (parentIndex > 0) {
             SkDisplayable* parent = fParents[parentIndex - 1].fDisplayable;
             bool result = parent->addChild(fMaker, displayable);
             if (fMaker.hasError())
                 return true;
             if (result == false) {
                 int infoCount;
                 const SkMemberInfo* info =
                     SkDisplayType::GetMembers(&fMaker, fParents[parentIndex - 1].fType, &infoCount);
                 const SkMemberInfo* foundInfo;
-                if ((foundInfo = searchContainer(info, infoCount)) != NULL) {
+                if ((foundInfo = searchContainer(info, infoCount)) != nullptr) {
                     parent->setReference(foundInfo, displayable);
         //          if (displayable->isHelper() == false)
                         fMaker.helperAdd(displayable);
                 } else {
                     fMaker.setErrorCode(SkDisplayXMLParserError::kElementTypeNotAllowedInParent);
                     return true;
                 }
             }
             if (parent->childrenNeedDisposing())
                 delete displayable;
         }
         fParents.remove(parentIndex);
     }
-    fCurrDisplayable = NULL;
+    fCurrDisplayable = nullptr;
     if (fInInclude == false && SK_strcasecmp(elem, "screenplay") == 0) {
         if (fMaker.fInMovie == false) {
             fMaker.fEnableTime = fMaker.getAppTime();
 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
             if (fMaker.fDebugTimeBase == (SkMSec) -1)
                 fMaker.fDebugTimeBase = fMaker.fEnableTime;
             SkString debugOut;
             SkMSec time = fMaker.getAppTime();
             debugOut.appendS32(time - fMaker.fDebugTimeBase);
             debugOut.append(" onLoad enable=");
             debugOut.appendS32(fMaker.fEnableTime - fMaker.fDebugTimeBase);
             SkDebugf("%s\n", debugOut.c_str());
 #endif
-            fMaker.fEvents.doEvent(fMaker, SkDisplayEvent::kOnload, NULL);
+            fMaker.fEvents.doEvent(fMaker, SkDisplayEvent::kOnload, nullptr);
             if (fMaker.fError.hasError())
                 return true;
-            fMaker.fEvents.removeEvent(SkDisplayEvent::kOnload, NULL);
+            fMaker.fEvents.removeEvent(SkDisplayEvent::kOnload, nullptr);
 
         }
         fInSkia = false;
     }
     return false;
 }
 
 bool SkDisplayXMLParser::onStartElement(const char name[])
 {
     return onStartElementLen(name, strlen(name));
 }
 
 bool SkDisplayXMLParser::onStartElementLen(const char name[], size_t len) {
-    fCurrDisplayable = NULL; // init so we'll ignore attributes if we exit early
+    fCurrDisplayable = nullptr; // init so we'll ignore attributes if we exit early
 
     if (SK_strncasecmp(name, "screenplay", len) == 0) {
         fInSkia = true;
         if (fInInclude == false)
             fMaker.idsSet(name, len, &fMaker.fScreenplay);
         return false;
     }
     if (fInSkia == false)
         return false;
 
     SkDisplayable* displayable = fMaker.createInstance(name, len);
-    if (displayable == NULL) {
+    if (displayable == nullptr) {
         fError->setNoun(name, len);
         fError->setCode(SkXMLParserError::kUnknownElement);
         return true;
     }
     SkDisplayTypes type = displayable->getType();
     Parent record = { displayable, type };
     *fParents.append() = record;
     if (fParents.count() == 1)
         fMaker.childrenAdd(displayable);
     else {
         Parent* parent = fParents.end() - 2;
         if (displayable->setParent(parent->fDisplayable)) {
             fError->setNoun(name, len);
             getError()->setCode(SkDisplayXMLParserError::kParentElementCantContain);
             return true;
         }
     }
 
     // set these for subsequent calls to addAttribute()
     fCurrDisplayable = displayable;
     fCurrType = type;
     return false;
 }
 
 const SkMemberInfo* SkDisplayXMLParser::searchContainer(const SkMemberInfo* infoBase,
                                                          int infoCount) {
-    const SkMemberInfo* bestDisplayable = NULL;
-    const SkMemberInfo* lastResort = NULL;
+    const SkMemberInfo* bestDisplayable = nullptr;
+    const SkMemberInfo* lastResort = nullptr;
     for (int index = 0; index < infoCount; index++) {
         const SkMemberInfo* info = &infoBase[index];
         if (info->fType == SkType_BaseClassInfo) {
             const SkMemberInfo* inherited = info->getInherited();
             const SkMemberInfo* result = searchContainer(inherited, info->fCount);
-            if (result != NULL)
+            if (result != nullptr)
                 return result;
             continue;
         }
         Parent* container = fParents.end() - 1;
         SkDisplayTypes type = (SkDisplayTypes) info->fType;
         if (type == SkType_MemberProperty)
             type = info->propertyType();
         SkDisplayTypes containerType = container->fType;
         if (type == containerType && (type == SkType_Rect || type == SkType_Polygon ||
             type == SkType_Array || type == SkType_Int || type == SkType_Bitmap))
@@ skipping 16 matching lines @@
                     bestDisplayable = info;
                 else
                     lastResort = info;
             }
         }
     }
     if (bestDisplayable)
         return bestDisplayable;
     if (lastResort)
         return lastResort;
-    return NULL;
+    return nullptr;
 }