Style Change: NULL->nullptr

src/animator/SkMemberInfo.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 "SkMemberInfo.h"
@@ skipping 87 matching lines @@
 }
 
 size_t SkMemberInfo::getSize(const SkDisplayable* displayable) const {
     size_t byteSize;
     switch (fType) {
         case SkType_MemberProperty:
             byteSize = GetSize(propertyType());
             break;
         case SkType_Array: {
             SkDisplayTypes type;
-            if (displayable == NULL)
+            if (displayable == nullptr)
                 return sizeof(int);
             if (displayable->getType() == SkType_Array) {
                 SkDisplayArray* dispArray = (SkDisplayArray*) displayable;
                 type = dispArray->values.getType();
             } else
                 type = propertyType();
             SkTDOperandArray* array = (SkTDOperandArray*) memberData(displayable);
             byteSize = GetSize(type) * array->count();
             } break;
         default:
@@ skipping 65 matching lines @@
     int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType,
     const char rawValue[], size_t rawValueLen) const
 {
     SkString valueStr(rawValue, rawValueLen);
     SkScriptValue scriptValue;
     scriptValue.fType = SkType_Unknown;
     scriptValue.fOperand.fS32 = 0;
     SkDisplayTypes type = getType();
     SkAnimatorScript engine(maker, displayable, type);
     if (arrayStorage)
-        displayable = NULL;
+        displayable = nullptr;
     bool success = true;
-    void* untypedStorage = NULL;
+    void* untypedStorage = nullptr;
     if (displayable && fType != SkType_MemberProperty && fType != SkType_MemberFunction)
         untypedStorage = (SkTDOperandArray*) memberData(displayable);
 
     if (type == SkType_ARGB) {
         // for both SpiderMonkey and SkiaScript, substitute any #xyz or #xxyyzz first
             // it's enough to expand the colors into 0xFFxxyyzz
         const char* poundPos;
-        while ((poundPos = strchr(valueStr.c_str(), '#')) != NULL) {
+        while ((poundPos = strchr(valueStr.c_str(), '#')) != nullptr) {
             size_t offset = poundPos - valueStr.c_str();
             if (valueStr.size() - offset < 4)
                 break;
             char r = poundPos[1];
             char g = poundPos[2];
             char b = poundPos[3];
             if (is_hex(r) == false || is_hex(g) == false || is_hex(b) == false)
                 break;
             char hex = poundPos[4];
             if (is_hex(hex) == false) {
@@ skipping 36 matching lines @@
                 const char* script = valueStr.c_str();
                 success = engine.evaluateScript(&script, &scriptValue);
                 if (success == false) {
                     maker.setScriptError(engine);
                     return false;
                 }
             }
             SkASSERT(success);
             if (scriptValue.fType == SkType_Displayable) {
                 if (type == SkType_String) {
-                    const char* charPtr = NULL;
+                    const char* charPtr = nullptr;
                     maker.findKey(scriptValue.fOperand.fDisplayable, &charPtr);
                     scriptValue.fOperand.fString = new SkString(charPtr);
                     scriptValue.fType = SkType_String;
                     engine.SkScriptEngine::track(scriptValue.fOperand.fString);
                     break;
                 }
                 SkASSERT(SkDisplayType::IsDisplayable(&maker, type));
                 if (displayable)
                     displayable->setReference(this, scriptValue.fOperand.fDisplayable);
                 else
@@ skipping 79 matching lines @@
         SkString& raw) const {
     return setValue(maker, arrayStorage, storageOffset, maxStorage, displayable, outType, raw.c_str(),
         raw.size());
 }
 
 bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
     int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
     SkScriptValue& scriptValue) const
 {
     SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ?
-        arrayStorage->begin() : NULL;
+        arrayStorage->begin() : nullptr;
     if (storage)
         storage += storageOffset;
     SkDisplayTypes type = getType();
     if (fType == SkType_MemberProperty) {
         if(displayable)
             displayable->setProperty(propertyIndex(), scriptValue);
         else {
             SkASSERT(storageOffset < arrayStorage->count());
             switch (scriptValue.fType) {
                 case SkType_Boolean:
                 case SkType_Float:
                 case SkType_Int:
                     memcpy(&storage->fScalar, &scriptValue.fOperand.fScalar, sizeof(SkScalar));
                     break;
                 case SkType_Array:
                     memcpy(&storage->fScalar, scriptValue.fOperand.fArray->begin(), scriptValue.fOperand.fArray->count() * sizeof(SkScalar));
                     break;
                 case SkType_String:
                     storage->fString->set(*scriptValue.fOperand.fString);
                     break;
                 default:
                     SkASSERT(0);    // type isn't handled yet
             }
         }
     } else if (fType == SkType_MemberFunction) {
         SkASSERT(scriptValue.fType == SkType_Array);
         if (displayable)
-            displayable->executeFunction(displayable, this, scriptValue.fOperand.fArray, NULL);
+            displayable->executeFunction(displayable, this, scriptValue.fOperand.fArray, nullptr);
         else {
             int count = scriptValue.fOperand.fArray->count();
     //      SkASSERT(maxStorage == 0 || count == maxStorage);
             if (arrayStorage->count() == 2)
                 arrayStorage->setCount(2 * count);
             else {
                 storageOffset *= count;
                 SkASSERT(count + storageOffset <= arrayStorage->count());
             }
             memcpy(&(*arrayStorage)[storageOffset], scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand));
@@ skipping 19 matching lines @@
             destArray->setCount(storageOffset + count);
             memcpy(destArray->begin() + storageOffset, scriptValue.fOperand.fArray->begin(), sizeof(SkOperand) * count);
         }
     } else if (type == SkType_String) {
         SkString* string = untypedStorage ? (SkString*) untypedStorage : (*arrayStorage)[storageOffset].fString;
         string->set(*scriptValue.fOperand.fString);
     } else if (type == SkType_ARGB && outType == SkType_Float) {
         SkTypedArray* array = scriptValue.fOperand.fArray;
         SkASSERT(scriptValue.fType == SkType_Int || scriptValue.fType == SkType_ARGB ||
             scriptValue.fType == SkType_Array);
-        SkASSERT(scriptValue.fType != SkType_Array || (array != NULL &&
+        SkASSERT(scriptValue.fType != SkType_Array || (array != nullptr &&
             array->getType() == SkType_Int));
         int numberOfColors = scriptValue.fType == SkType_Array ? array->count() : 1;
         int numberOfComponents = numberOfColors * 4;
     //  SkASSERT(maxStorage == 0 || maxStorage == numberOfComponents);
         if (maxStorage == 0)
             arrayStorage->setCount(numberOfComponents);
         for (int index = 0; index < numberOfColors; index++) {
             SkColor color = scriptValue.fType == SkType_Array ?
                 (SkColor) array->begin()[index].fS32 : (SkColor) scriptValue.fOperand.fS32;
             storage[0].fScalar = SkIntToScalar(SkColorGetA(color));
             storage[1].fScalar = SkIntToScalar(SkColorGetR(color));
             storage[2].fScalar = SkIntToScalar(SkColorGetG(color));
             storage[3].fScalar = SkIntToScalar(SkColorGetB(color));
             storage += 4;
         }
-    } else if (SkDisplayType::IsStruct(NULL /* !!! maker*/, type)) {
+    } else if (SkDisplayType::IsStruct(nullptr /* !!! maker*/, type)) {
         if (scriptValue.fType != SkType_Array)
             return true;    // error
         SkASSERT(sizeof(SkScalar) == sizeof(SkOperand)); // !!! no 64 bit pointer support yet
         int count = scriptValue.fOperand.fArray->count();
         if (count > 0) {
             SkASSERT(fCount == count);
             memcpy(storage, scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand));
         }
     } else if (scriptValue.fType == SkType_Array) {
         SkASSERT(scriptValue.fOperand.fArray->getType() == type);
@@ skipping 23 matching lines @@
 //}
 
 #if SK_USE_CONDENSED_INFO == 0
 
 // Find Nth memberInfo
 const SkMemberInfo* SkMemberInfo::Find(const SkMemberInfo info[], int count, int* index) {
     SkASSERT(*index >= 0);
     if (info->fType == SkType_BaseClassInfo) {
         const SkMemberInfo* inherited = (SkMemberInfo*) info->fName;
         const SkMemberInfo* result = SkMemberInfo::Find(inherited, info->fCount, index);
-        if (result != NULL)
+        if (result != nullptr)
             return result;
         if (--count == 0)
-            return NULL;
+            return nullptr;
         info++;
     }
     SkASSERT(info->fName);
     SkASSERT(info->fType != SkType_BaseClassInfo);
     if (*index >= count) {
         *index -= count;
-        return NULL;
+        return nullptr;
     }
     return &info[*index];
 }
 
 // Find named memberinfo
 const SkMemberInfo* SkMemberInfo::Find(const SkMemberInfo info[], int count, const char** matchPtr) {
     const char* match = *matchPtr;
     if (info->fType == SkType_BaseClassInfo) {
         const SkMemberInfo* inherited = (SkMemberInfo*) info->fName;
         const SkMemberInfo* result = SkMemberInfo::Find(inherited, info->fCount, matchPtr);
-        if (result != NULL)
+        if (result != nullptr)
             return result;
         if (--count == 0)
-            return NULL;
+            return nullptr;
         info++;
     }
     SkASSERT(info->fName);
     SkASSERT(info->fType != SkType_BaseClassInfo);
     int index = SkStrSearch(&info->fName, count, match, sizeof(*info));
     if (index < 0 || index >= count)
-        return NULL;
+        return nullptr;
     return &info[index];
 }
 
 const SkMemberInfo* SkMemberInfo::getInherited() const {
     return (SkMemberInfo*) fName;
 }
 
 #endif // SK_USE_CONDENSED_INFO == 0
 
 #if 0
@@ skipping 19 matching lines @@
     //  case SkType_PointArray:
         case SkType_ScalarArray:
             SkParse::FindScalars(value, (SkScalar*) valuePtr, count);
             break;
         default:
             SkASSERT(0);
     }
     return true;
 }
 #endif