Style Change: NULL->nullptr

src/animator/SkAnimatorScript.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 "SkAnimatorScript.h"
@@ skipping 27 matching lines @@
     { SkType_TextBoxAlign, "start|center|end" },
     { SkType_TextBoxMode, "oneLine|lineBreak" },
     { SkType_TileMode, "clamp|repeat|mirror" },
     { SkType_Xfermode, "clear|src|dst|srcOver|dstOver|srcIn|dstIn|srcOut|dstOut|"
         "srcATop|dstATop|xor|darken|lighten" },
 };
 
 static int gEnumMapCount = SK_ARRAY_COUNT(gEnumMaps);
 
 SkAnimatorScript::SkAnimatorScript(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type)
-    : SkScriptEngine(SkScriptEngine::ToOpType(type)), fMaker(maker), fParent(NULL), fWorking(working)
+    : SkScriptEngine(SkScriptEngine::ToOpType(type)), fMaker(maker), fParent(nullptr), fWorking(working)
 {
     memberCallBack(EvalMember, (void*) this);
     memberFunctionCallBack(EvalMemberFunction, (void*) this);
     boxCallBack(Box, (void*) this);
     unboxCallBack(Unbox, (void*) &maker);
     propertyCallBack(EvalID, (void*) this); // must be first (entries are prepended, will be last), since it never fails
     propertyCallBack(Infinity, (void*) this);
     propertyCallBack(NaN, (void*) this);
     functionCallBack(Eval, (void*) this);
     functionCallBack(IsFinite, (void*) this);
@@ skipping 99 matching lines @@
 
 bool SkAnimatorScript::EvalID(const char* token, size_t len, void* user, SkScriptValue* value) {
     SkAnimatorScript* engine = (SkAnimatorScript*) user;
     SkTDict<SkDisplayable*>* ids = &engine->fMaker.fIDs;
     SkDisplayable* displayable;
     bool success = ids->find(token, len, &displayable);
     if (success == false) {
         displayable = engine->fWorking;
         if (SK_LITERAL_STR_EQUAL("parent", token, len)) {
             SkDisplayable* parent = displayable->getParent();
-            if (parent == NULL)
+            if (parent == nullptr)
                 parent = engine->fParent;
             if (parent) {
                 value->fOperand.fDisplayable = parent;
                 value->fType = SkType_Displayable;
                 return true;
             }
         }
         if (displayable && EvalMember(token, len, displayable, engine, value))
             return true;
-        value->fOperand.fString = NULL;
+        value->fOperand.fString = nullptr;
         value->fType = SkType_String;
     } else {
         SkDisplayable* working = engine->fWorking;
         value->fOperand.fDisplayable = displayable;
         value->fType = SkType_Displayable;
         if (displayable->canContainDependents() && working && working->isAnimate()) {
             SkAnimateBase* animator = (SkAnimateBase*) working;
             if (animator->isDynamic()) {
                 SkDisplayDepend* depend = (SkDisplayDepend* ) displayable;
                 depend->addDependent(working);
             }
         }
     }
     return true;
 }
 
 bool SkAnimatorScript::EvalNamedColor(const char* token, size_t len, void* callback, SkScriptValue* value) {
         value->fType = SkType_Int;
-    if (SkParse::FindNamedColor(token, len, (SkColor*) &value->fOperand.fS32) != NULL)
+    if (SkParse::FindNamedColor(token, len, (SkColor*) &value->fOperand.fS32) != nullptr)
         return true;
     return false;
 }
 
 bool SkAnimatorScript::EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* eng, SkScriptValue* value) {
     if (SK_LITERAL_STR_EQUAL("rgb", function, len) == false)
         return false;
     if (params.count() != 3)
         return false;
@@ skipping 66 matching lines @@
     SkScriptEngine* engine = (SkScriptEngine*) eng;
     SkDisplayable* displayable = (SkDisplayable*) object;
     SkString name(member, len);
     SkDisplayable* named = displayable->contains(name);
     if (named) {
         value->fOperand.fDisplayable = named;
         value->fType = SkType_Displayable;
         return true;
     }
     const SkMemberInfo* info = displayable->getMember(name.c_str());
-    if (info == NULL)
+    if (info == nullptr)
         return false;
     if (info->fType == SkType_MemberProperty) {
         if (displayable->getProperty(info->propertyIndex(), value) == false) {
             SkASSERT(0);
             return false;
         }
     }
     return EvalMemberCommon(engine, info, displayable, value);
 }
 
 bool SkAnimatorScript::EvalMemberFunction(const char* member, size_t len, void* object,
         SkTDArray<SkScriptValue>& params, void* eng, SkScriptValue* value) {
     SkScriptEngine* engine = (SkScriptEngine*) eng;
     SkDisplayable* displayable = (SkDisplayable*) object;
     SkString name(member, len);
     const SkMemberInfo* info = displayable->getMember(name.c_str());
-    SkASSERT(info != NULL); /* !!! error handling unimplemented */
+    SkASSERT(info != nullptr); /* !!! error handling unimplemented */
     if (info->fType != SkType_MemberFunction) {
         SkASSERT(0);
         return false;
     }
     displayable->executeFunction(displayable, info->functionIndex(), params, info->getType(),
         value);
     return EvalMemberCommon(engine, info, displayable, value);
 }
 
 bool SkAnimatorScript::EvaluateDisplayable(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, SkDisplayable** result) {
@@ skipping 82 matching lines @@
     value->fType = SkType_Int;
     value->fOperand.fS32 = scriptValue->fType == SkType_Float ? SkScalarIsNaN(scriptValue->fOperand.fScalar) : 0;
     return true;
 }
 
 bool SkAnimatorScript::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 43 matching lines @@
             } break;
         case SkType_Float: {
             SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable;
             scriptValue->fOperand.fScalar = boxedValue->value;
             } break;
         case SkType_String: {
             SkDisplayString* boxedValue = (SkDisplayString*) displayable;
             scriptValue->fOperand.fString = new SkString(boxedValue->value);
             } break;
         default: {
-            const char* id = NULL;
+            const char* id = nullptr;
             SkDEBUGCODE(bool success = ) maker->findKey(displayable, &id);
             SkASSERT(success);
             scriptValue->fOperand.fString = new SkString(id);
             type = SkType_String;
         }
     }
     scriptValue->fType = type;
     return true;
 }
 
@@ skipping 76 matching lines @@
 void SkAnimatorScript::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 (unsigned index = 0; index < SkScriptNAnswer_testCount; index++) {
-        SkAnimatorScript engine(*animator.fMaker, NULL, scriptTests[index].fType);
+        SkAnimatorScript engine(*animator.fMaker, nullptr, scriptTests[index].fType);
         SkScriptValue value;
         const char* script = scriptTests[index].fScript;
         bool success = engine.evaluateScript(&script, &value);
         if (success == false) {
             SkDebugf("script failed: %s\n", scriptTests[index].fScript);
             SkASSERT(scriptTests[index].fType == SkType_Unknown);
             continue;
         }
         SkASSERT(value.fType == scriptTests[index].fType);
         SkScalar error;
         switch (value.fType) {
             case SkType_Int:
                 SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
                 break;
             case SkType_Float:
                 error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
                 SkASSERT(error < SK_Scalar1 / 10000);
                 break;
             case SkType_String:
                 SkASSERT(strcmp(value.fOperand.fString->c_str(), scriptTests[index].fStringAnswer) == 0);
                 break;
             default:
                 SkASSERT(0);
         }
     }
 #endif
 }
 
 #endif