Style Change: NULL->nullptr

src/animator/SkAnimatorScript2.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkAnimatorScript2.h"
 #include "SkAnimateBase.h"
 #include "SkAnimateMaker.h"
@@ skipping 187 matching lines @@
     bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
         SkDisplayable* displayable = (SkDisplayable*) object;
         SkString name(member, len);
         SkDisplayable* named = displayable->contains(name);
         if (named) {
             ref->fType = SkOperand2::kObject;
             ref->fOperand.fObject = named;
             return true;
         }
         const SkMemberInfo* info = displayable->getMember(name.c_str());
-        if (info == NULL)
+        if (info == nullptr)
             return false;    // !!! add additional error info?
         ref->fType = SkAnimatorScript2::ToOpType(info->getType());
         ref->fOperand.fObject = (void*) info;
         return true;
     }
 
     bool invoke(size_t ref, void* object, SkOperand2* value) {
         const SkMemberInfo* info = (const SkMemberInfo* ) ref;
         SkDisplayable* displayable = (SkDisplayable*) object;
         if (info->fType == SkType_MemberProperty) {
             if (displayable->getProperty2(info->propertyIndex(), value) == false) {
                 return false;
             }
         }
         return fEngine->evalMemberCommon(info, displayable, value);
     }
 
     SkAnimatorScript2* fEngine;
 };
 
 
 class SkAnimatorScript_MemberFunction : public SkScriptCallBackMemberFunction {
 public:
     SkAnimatorScript_MemberFunction(SkAnimatorScript2* engine) : fEngine(engine) {}
 
     bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
         SkDisplayable* displayable = (SkDisplayable*) object;
         SkString name(member, len);
         const SkMemberInfo* info = displayable->getMember(name.c_str());
-        if (info == NULL || info->fType != SkType_MemberFunction)
+        if (info == nullptr || info->fType != SkType_MemberFunction)
             return false;    // !!! add additional error info?
         ref->fType = SkAnimatorScript2::ToOpType(info->getType());
         ref->fOperand.fObject = (void*) info;
         return true;
     }
 
     virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
         types->setCount(3);
         SkOperand2::OpType* type = types->begin();
         type[0] = type[1] = type[2] = SkOperand2::kS32;
     }
 
     bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value)
     {
         const SkMemberInfo* info = (const SkMemberInfo* ) ref;
         SkDisplayable* displayable = (SkDisplayable*) object;
         displayable->executeFunction2(displayable, info->functionIndex(), params, info->getType(),
             value);
         return fEngine->evalMemberCommon(info, displayable, value);
     }
 
     SkAnimatorScript2* fEngine;
 };
 
 
 class SkAnimatorScript_NamedColor : public SkScriptCallBackProperty {
 public:
     virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
-        return SkParse::FindNamedColor(name, len, (SkColor*) &value->fS32) != NULL;
+        return SkParse::FindNamedColor(name, len, (SkColor*) &value->fS32) != nullptr;
     }
 };
 
 
 class SkAnimatorScript_RGB : public SkScriptCallBackFunction {
 public:
     virtual bool getIndex(const char* name, int len, size_t* result) {
         if (SK_LITERAL_STR_EQUAL("rgb", name, len) != 0)
             return false;
         *result = 0;
@@ skipping 189 matching lines @@
             return SkType_Array;
         case SkOperand2::kObject:
             return SkType_Displayable;
         default:
             SkASSERT(0);
             return SkType_Unknown;
     }
 }
 
 SkOperand2::OpType SkAnimatorScript2::ToOpType(SkDisplayTypes type) {
-    if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type))
+    if (SkDisplayType::IsDisplayable(nullptr /* fMaker */, type))
         return SkOperand2::kObject;
-    if (SkDisplayType::IsEnum(NULL /* fMaker */, type))
+    if (SkDisplayType::IsEnum(nullptr /* fMaker */, type))
         return SkOperand2::kS32;
     switch (type) {
         case SkType_ARGB:
         case SkType_MSec:
         case SkType_Int:
             return SkOperand2::kS32;
         case SkType_Float:
         case SkType_Point:
         case SkType_3D_Point:
             return SkOperand2::kScalar;
         case SkType_Base64:
         case SkType_DynamicString:
         case SkType_String:
             return SkOperand2::kString;
         case SkType_Array:
             return SkOperand2::kArray;
         case SkType_Unknown:
             return SkOperand2::kNoType;
         default:
             SkASSERT(0);
             return SkOperand2::kNoType;
     }
 }
 
 bool SkAnimatorScript2::MapEnums(const char* ptr, const char* match, size_t len, int* value) {
     int index = 0;
     bool more = true;
     do {
         const char* last = strchr(ptr, '|');
-        if (last == NULL) {
+        if (last == nullptr) {
             last = &ptr[strlen(ptr)];
             more = false;
         }
         size_t length = last - ptr;
         if (len == length && strncmp(ptr, match, length) == 0) {
             *value = index;
             return true;
         }
         index++;
         ptr = last + 1;
@@ skipping 64 matching lines @@
 void SkAnimatorScript2::UnitTest() {
 #if defined(SK_SUPPORT_UNITTEST)
     SkAnimator animator;
     SkASSERT(animator.decodeMemory(scriptTestSetup, sizeof(scriptTestSetup)-1));
     SkEvent evt;
     evt.setString("id", "evt");
     evt.setS32("x", 3);
     animator.doUserEvent(evt);
     // set up animator with memory script above, then run value tests
     for (int index = 0; index < SkScriptNAnswer_testCount; index++) {
-        SkAnimatorScript2 engine(*animator.fMaker, NULL, scriptTests[index].fType);
+        SkAnimatorScript2 engine(*animator.fMaker, nullptr, scriptTests[index].fType);
         SkScriptValue2 value;
         const char* script = scriptTests[index].fScript;
         bool success = engine.evaluateScript(&script, &value);
         if (success == false) {
             SkASSERT(scriptTests[index].fType == SkType_Unknown);
             continue;
         }
         SkASSERT(value.fType == ToOpType(scriptTests[index].fType));
         SkScalar error;
         switch (value.fType) {
             case SkOperand2::kS32:
                 SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
                 break;
             case SkOperand2::kScalar:
                 error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
                 SkASSERT(error < SK_Scalar1 / 10000);
                 break;
             case SkOperand2::kString:
                 SkASSERT(value.fOperand.fString->equals(scriptTests[index].fStringAnswer));
                 break;
             default:
                 SkASSERT(0);
         }
     }
 #endif
 }
 
 #endif