Style Change: NULL->nullptr

src/animator/SkScriptTokenizer.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 "SkScript2.h"
 #include "SkData.h"
 #include "SkFloatingPoint.h"
@@ skipping 797 matching lines @@
     bool success = functionParams(scriptPtr, &params);
     if (success == false)
         goto done;
     {
         for (SkScriptCallBack** callBack = fCallBackArray.begin(); callBack < fCallBackArray.end(); callBack++) {
             if ((*callBack)->getType() != SkScriptCallBack::kFunction)
                 continue;
             SkScriptValue2 callbackResult;
             success = (*callBack)->getReference(functionName, functionNameLen, &callbackResult);
             if (success) {
-                callbackResult.fType = (*callBack)->getReturnType(callbackResult.fOperand.fReference, NULL);
+                callbackResult.fType = (*callBack)->getReturnType(callbackResult.fOperand.fReference, nullptr);
                 callbackResult.fIsConstant = SkScriptValue2::kVariable;
                 fValueStack.push(callbackResult);
                 goto done;
             }
         }
     }
     return false;
 done:
         fOpStack.pop();
     return success;
@@ skipping 41 matching lines @@
 }
 
 bool SkScriptEngine2::handleProperty() {
     bool success = true;
     for (SkScriptCallBack** callBack = fCallBackArray.begin(); callBack < fCallBackArray.end(); callBack++) {
         if ((*callBack)->getType() != SkScriptCallBack::kProperty)
             continue;
         SkScriptValue2 callbackResult;
         success = (*callBack)->getReference(fToken, fTokenLength, &callbackResult);
         if (success) {
-            if (callbackResult.fType == SkOperand2::kString && callbackResult.fOperand.fString == NULL) {
+            if (callbackResult.fType == SkOperand2::kString && callbackResult.fOperand.fString == nullptr) {
                 callbackResult.fOperand.fString = new SkString(fToken, fTokenLength);
                 track(callbackResult.fOperand.fString);
             }
             callbackResult.fIsConstant = SkScriptValue2::kVariable;
             fValueStack.push(callbackResult);
             goto done;
         }
     }
 done:
         fTokenLength = 0;
@@ skipping 305 matching lines @@
     if (type == toType)
         return true;
     SkOperand2& operand = value->fOperand;
     bool success = true;
     switch (toType) {
         case SkOperand2::kS32:
             if (type == SkOperand2::kScalar)
                 operand.fS32 = SkScalarFloorToInt(operand.fScalar);
             else {
                 SkASSERT(type == SkOperand2::kString);
-                success = SkParse::FindS32(operand.fString->c_str(), &operand.fS32) != NULL;
+                success = SkParse::FindS32(operand.fString->c_str(), &operand.fS32) != nullptr;
             }
                 break;
         case SkOperand2::kScalar:
             if (type == SkOperand2::kS32)
                 operand.fScalar = IntToScalar(operand.fS32);
             else {
                 SkASSERT(type == SkOperand2::kString);
-                success = SkParse::FindScalar(operand.fString->c_str(), &operand.fScalar) != NULL;
+                success = SkParse::FindScalar(operand.fString->c_str(), &operand.fScalar) != nullptr;
             }
                 break;
         case SkOperand2::kString: {
             SkString* strPtr = new SkString();
             SkASSERT(engine);
             engine->track(strPtr);
             if (type == SkOperand2::kS32)
                 strPtr->appendS32(operand.fS32);
             else {
                 SkASSERT(type == SkOperand2::kScalar);
@@ skipping 41 matching lines @@
         default:
             SkASSERT(0);
             return false;
     }
     return true; // no error
 }
 
 #ifdef SK_DEBUG
 #if defined(SK_SUPPORT_UNITTEST)
 
-#define testInt(expression) { #expression, SkOperand2::kS32, expression, 0, NULL }
-#define testScalar(expression) { #expression, SkOperand2::kScalar, 0, (float) (expression), NULL }
-#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkOperand2::kScalar, 0, fmodf((float) exp1, (float) exp2), NULL }
-#define testTrue(expression) { #expression, SkOperand2::kS32, 1, 0, NULL }
-#define testFalse(expression) { #expression, SkOperand2::kS32, 0, 0, NULL }
+#define testInt(expression) { #expression, SkOperand2::kS32, expression, 0, nullptr }
+#define testScalar(expression) { #expression, SkOperand2::kScalar, 0, (float) (expression), nullptr }
+#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkOperand2::kScalar, 0, fmodf((float) exp1, (float) exp2), nullptr }
+#define testTrue(expression) { #expression, SkOperand2::kS32, 1, 0, nullptr }
+#define testFalse(expression) { #expression, SkOperand2::kS32, 0, 0, nullptr }
 
 static const SkScriptNAnswer2 scriptTests[]  = {
     testInt(1||(0&&3)),
     testScalar(- -5.5- -1.5),
     testScalar(1.0+5),
     testInt((6+7)*8),
     testInt(3*(4+5)),
     testScalar(1.0+2.0),
     testScalar(3.0-1.0),
     testScalar(6-1.0),
@@ skipping 10 matching lines @@
     testTrue(-9.*1==-4-5),
     testFalse(-9!=-9.0),
     testFalse(-9.!=-4.0-5),
     testFalse(-9.*1!=-4-5),
     testInt(0x123),
     testInt(0XABC),
     testInt(0xdeadBEEF),
     {    "'123'+\"456\"", SkOperand2::kString, 0, 0, "123456" },
     {    "123+\"456\"", SkOperand2::kString, 0, 0, "123456" },
     {    "'123'+456", SkOperand2::kString, 0, 0, "123456" },
-    {    "'123'|\"456\"", SkOperand2::kS32, 123|456, 0, NULL },
-    {    "123|\"456\"", SkOperand2::kS32, 123|456, 0, NULL },
-    {    "'123'|456", SkOperand2::kS32, 123|456, 0, NULL },
-    {    "'2'<11", SkOperand2::kS32, 1, 0, NULL },
-    {    "2<'11'", SkOperand2::kS32, 1, 0, NULL },
-    {    "'2'<'11'", SkOperand2::kS32, 0, 0, NULL },
+    {    "'123'|\"456\"", SkOperand2::kS32, 123|456, 0, nullptr },
+    {    "123|\"456\"", SkOperand2::kS32, 123|456, 0, nullptr },
+    {    "'123'|456", SkOperand2::kS32, 123|456, 0, nullptr },
+    {    "'2'<11", SkOperand2::kS32, 1, 0, nullptr },
+    {    "2<'11'", SkOperand2::kS32, 1, 0, nullptr },
+    {    "'2'<'11'", SkOperand2::kS32, 0, 0, nullptr },
     testInt(123),
     testInt(-345),
     testInt(+678),
     testInt(1+2+3),
     testInt(3*4+5),
     testInt(6+7*8),
     testInt(-1-2-8/4),
     testInt(-9%4),
     testInt(9%-4),
     testInt(-9%-4),
@@ skipping 131 matching lines @@
     // logic
     testInt(1?2:3),
     testInt(0?2:3),
     testInt((1&&2)||3),
     testInt((1&&0)||3),
     testInt((1&&0)||0),
     testInt(1||(0&&3)),
     testInt(0||(0&&3)),
     testInt(0||(1&&3)),
     testInt(0&&1?2:3)
-    , {    "123.5", SkOperand2::kScalar, 0, SkIntToScalar(123) + SK_Scalar1/2, NULL }
+    , {    "123.5", SkOperand2::kScalar, 0, SkIntToScalar(123) + SK_Scalar1/2, nullptr }
 };
 
 #define SkScriptNAnswer_testCount    SK_ARRAY_COUNT(scriptTests)
 #endif  // SK_SUPPORT_UNITTEST
 
 void SkScriptEngine2::UnitTest() {
 #if defined(SK_SUPPORT_UNITTEST)
     ValidateDecompileTable();
     for (size_t index = 0; index < SkScriptNAnswer_testCount; index++) {
         SkScriptEngine2 engine(scriptTests[index].fType);
@@ skipping 18 matching lines @@
             case SkOperand2::kString:
                 SkASSERT(value.fOperand.fString->equals(scriptTests[index].fStringAnswer));
                 break;
             default:
                 SkASSERT(0);
         }
     }
 #endif  // SK_SUPPORT_UNITTEST
 }
 #endif  // SK_DEBUG