Style Change: NULL->nullptr

src/animator/SkScript.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 "SkScript.h"
@@ skipping 368 matching lines @@
         fError = kCouldNotFindReferencedID; // note: never generated by standard animator plugins
         return false;
     }
     return evaluateDotParam(script, suppressed, field, fieldLength);
 }
 
 bool SkScriptEngine::evaluateDotParam(const char*& script, bool suppressed,
         const char* field, size_t fieldLength) {
     void* object;
     if (suppressed)
-        object = NULL;
+        object = nullptr;
     else {
         if (fTypeStack.top() != kObject) {
             fError = kDotOperatorExpectsObject;
             return false;
         }
         object = fOperandStack.top().fObject;
         fTypeStack.pop();
         fOperandStack.pop();
     }
     char ch; // see if it is a simple member or a function
@@ skipping 85 matching lines @@
     commonCallBack(kFunction, callBack, userStorage);
 }
 
 bool SkScriptEngine::functionParams(const char** scriptPtr, SkTDArray<SkScriptValue>& params) {
     (*scriptPtr)++; // skip open paren
     *fOpStack.push() = kParen;
     *fBraceStack.push() = kFunctionBrace;
     SkBool suppressed = fSuppressStack.top().fSuppress;
     do {
         SkScriptValue value;
-        bool success = innerScript(scriptPtr, suppressed ? NULL : &value);
+        bool success = innerScript(scriptPtr, suppressed ? nullptr : &value);
         if (success == false) {
             fError = kErrorInFunctionParameters;
             return false;
         }
         if (suppressed)
             continue;
         *params.append() = value;
     } while ((*scriptPtr)[-1] == ',');
     fBraceStack.pop();
     fOpStack.pop(); // pop paren
@@ skipping 46 matching lines @@
                 SkASSERT(success);
                 if (suppressed == false) {
                     if (tokenValue.fType == SkType_Displayable) {
                         SkASSERT(SkDisplayType::IsDisplayable(tokenInfo->getType()));
                         fDisplayable->setReference(tokenInfo, tokenValue.fOperand.fDisplayable);
                     } else {
                         if (tokenValue.fType != tokenInfo->getType()) {
                             if (convertTo(tokenInfo->getType(), &tokenValue) == false)
                                 return false;
                         }
-                        tokenInfo->writeValue(fDisplayable, NULL, 0, 0,
+                        tokenInfo->writeValue(fDisplayable, nullptr, 0, 0,
                             (void*) ((char*) fInfo->memberData(fDisplayable) + tokenInfo->fOffset + fArrayOffset),
                             tokenInfo->getType(), tokenValue);
                     }
                 }
                 lastPush = false;
                 continue;
             } else
 #endif
             if (fBraceStack.top() == kArrayBrace) {
                 SkScriptValue tokenValue;
@@ skipping 55 matching lines @@
                 continue;
             }
         }
         if (ch == '0' && (script[1] & ~0x20) == 'X') {
             if (lastPush != false) {
                 fError = kExpectedOperator;
                 return false;
             }
             script += 2;
             script = SkParse::FindHex(script, (uint32_t*)&operand.fS32);
-            if (script == NULL) {
+            if (script == nullptr) {
                 fError = kExpectedHex;
                 return false;
             }
             goto intCommon;
         }
         if (lastPush == false && ch == '.')
             goto scalarCommon;
         if (ch >= '0' && ch <= '9') {
             if (lastPush != false) {
                 fError = kExpectedOperator;
@@ skipping 55 matching lines @@
                 *fTypeStack.push() = kString;
                 fOperandStack.push(operand);
             }
             lastPush = true;
             continue;
         }
         ;
         if (ch ==  '.') {
             if (fTokenLength == 0) {
                 SkScriptValue scriptValue;
-                SkDEBUGCODE(scriptValue.fOperand.fObject = NULL);
+                SkDEBUGCODE(scriptValue.fOperand.fObject = nullptr);
                 int tokenLength = token_length(++script);
                 const char* token = script;
                 script += tokenLength;
                 if (suppressed == false) {
                     if (fTypeStack.count() == 0) {
                         fError = kExpectedTokenBeforeDotOperator;
                         return false;
                     }
                     SkOpType topType;
                     fTypeStack.pop(&topType);
@@ skipping 148 matching lines @@
 }
 #endif
 
 bool SkScriptEngine::handleArrayIndexer(const char** scriptPtr, bool suppressed) {
     SkScriptValue scriptValue;
     (*scriptPtr)++;
     *fOpStack.push() = kParen;
     *fBraceStack.push() = kArrayBrace;
     SkOpType saveType = fReturnType;
     fReturnType = kInt;
-    bool success = innerScript(scriptPtr, suppressed == false ? &scriptValue : NULL);
+    bool success = innerScript(scriptPtr, suppressed == false ? &scriptValue : nullptr);
     if (success == false)
         return false;
     fReturnType = saveType;
     if (suppressed == false) {
         if (convertTo(SkType_Int, &scriptValue) == false)
             return false;
         int index = scriptValue.fOperand.fS32;
         SkScriptValue scriptValue;
         SkOpType type;
         fTypeStack.pop(&type);
@@ skipping 136 matching lines @@
     if (suppressed)
         goto done;
     success = false; // note that with standard animator-script plugins, callback never returns false
     {
         for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
             if (callBack->fCallBackType != kProperty)
                 continue;
             success = (*callBack->fPropertyCallBack)(fToken, fTokenLength,
                 callBack->fUserStorage, &callbackResult);
             if (success) {
-                if (callbackResult.fType == SkType_String && callbackResult.fOperand.fString == NULL) {
+                if (callbackResult.fType == SkType_String && callbackResult.fOperand.fString == nullptr) {
                     callbackResult.fOperand.fString = new SkString(fToken, fTokenLength);
                     track(callbackResult.fOperand.fString);
                 }
                 fOperandStack.push(callbackResult.fOperand);
                 *fTypeStack.push() = ToOpType(callbackResult.fType);
                 goto done;
             }
         }
     }
 done:
@@ skipping 259 matching lines @@
                 }
                 if (type2 == kInt) {
                     operand2.fScalar = IntToScalar(operand2.fS32);
                      type2 = kScalar;
                 }
             }
         }
         if ((type1 & attributes->fLeftType) == 0 || type1 != type2) {
             if (type1 == kString) {
                 const char* result = SkParse::FindScalar(operand1.fString->c_str(), &operand1.fScalar);
-                if (result == NULL) {
+                if (result == nullptr) {
                     fError = kExpectedNumber;
                     return false;
                 }
                 type1 = kScalar;
             }
             if (type1 == kScalar && (attributes->fLeftType == kInt || type2 == kInt)) {
                 operand1.fS32 = SkScalarFloorToInt(operand1.fScalar);
                 type1 = kInt;
             }
         }
     }
     if ((type2 & attributes->fRightType) == 0 || type1 != type2) {
         if (type2 == kString) {
             const char* result = SkParse::FindScalar(operand2.fString->c_str(), &operand2.fScalar);
-            if (result == NULL) {
+            if (result == nullptr) {
                 fError = kExpectedNumber;
                 return false;
             }
             type2 = kScalar;
         }
         if (type2 == kScalar && (attributes->fRightType == kInt || type1 == kInt)) {
             operand2.fS32 = SkScalarFloorToInt(operand2.fScalar);
             type2 = kInt;
         }
     }
@@ skipping 134 matching lines @@
 }
 
 void SkScriptEngine::unboxCallBack(_unboxCallBack func, void* userStorage) {
     UserCallBack callBack;
     callBack.fUnboxCallBack = func;
     commonCallBack(kUnbox, callBack, userStorage);
 }
 
 bool SkScriptEngine::ConvertTo(SkScriptEngine* engine, SkDisplayTypes toType, SkScriptValue* value ) {
     SkASSERT(value);
-    if (SkDisplayType::IsEnum(NULL /* fMaker */, toType))
+    if (SkDisplayType::IsEnum(nullptr /* fMaker */, toType))
         toType = SkType_Int;
     if (toType == SkType_Point || toType == SkType_3D_Point)
         toType = SkType_Float;
     if (toType == SkType_Drawable)
         toType = SkType_Displayable;
     SkDisplayTypes type = value->fType;
     if (type == toType)
         return true;
     SkOperand& operand = value->fOperand;
     bool success = true;
     switch (toType) {
         case SkType_Int:
             if (type == SkType_Boolean)
                 break;
             if (type == SkType_Float)
                 operand.fS32 = SkScalarFloorToInt(operand.fScalar);
             else {
                 if (type != SkType_String) {
                     success = false;
                     break; // error
                 }
-                success = SkParse::FindS32(operand.fString->c_str(), &operand.fS32) != NULL;
+                success = SkParse::FindS32(operand.fString->c_str(), &operand.fS32) != nullptr;
             }
             break;
         case SkType_Float:
             if (type == SkType_Int) {
                 if (operand.fS32 == SK_NaN32)
                     operand.fScalar = SK_ScalarNaN;
                 else if (SkAbs32(operand.fS32) == SK_MaxS32)
                     operand.fScalar = SkSign32(operand.fS32) * SK_ScalarMax;
                 else
                     operand.fScalar = SkIntToScalar(operand.fS32);
             } else {
                 if (type != SkType_String) {
                     success = false;
                     break; // error
                 }
-                success = SkParse::FindScalar(operand.fString->c_str(), &operand.fScalar) != NULL;
+                success = SkParse::FindScalar(operand.fString->c_str(), &operand.fScalar) != nullptr;
             }
             break;
         case SkType_String: {
             SkString* strPtr = new SkString();
             SkASSERT(engine);
             engine->track(strPtr);
             if (type == SkType_Int) {
                 strPtr->appendS32(operand.fS32);
             } else if (type == SkType_Displayable) {
                 SkASSERT(0); // must call through instance version instead of static version
@@ skipping 49 matching lines @@
             return SkType_Displayable;
 //      case kStruct:
 //          return SkType_Structure;
         default:
             SkASSERT(0);
             return SkType_Unknown;
     }
 }
 
 SkScriptEngine::SkOpType SkScriptEngine::ToOpType(SkDisplayTypes type) {
-    if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type))
+    if (SkDisplayType::IsDisplayable(nullptr /* fMaker */, type))
         return (SkOpType) kObject;
-    if (SkDisplayType::IsEnum(NULL /* fMaker */, type))
+    if (SkDisplayType::IsEnum(nullptr /* fMaker */, type))
         return kInt;
     switch (type) {
         case SkType_ARGB:
         case SkType_MSec:
         case SkType_Int:
             return kInt;
         case SkType_Float:
         case SkType_Point:
         case SkType_3D_Point:
             return kScalar;
@@ skipping 29 matching lines @@
             return false;
     }
     return true; // no error
 }
 
 #ifdef SK_SUPPORT_UNITTEST
 
 #include "SkFloatingPoint.h"
 
 #define DEF_SCALAR_ANSWER   0
-#define DEF_STRING_ANSWER   NULL
+#define DEF_STRING_ANSWER   nullptr
 
 #define testInt(expression) { #expression, SkType_Int, expression, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER }
     #define testScalar(expression) { #expression, SkType_Float, 0, (float) expression, DEF_STRING_ANSWER }
     #define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkType_Float, 0, sk_float_mod(exp1, exp2), DEF_STRING_ANSWER }
 #define testTrue(expression) { #expression, SkType_Int, 1, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER }
 #define testFalse(expression) { #expression, SkType_Int, 0, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER }
 
 static const SkScriptNAnswer scriptTests[]  = {
     testInt(1>1/2),
     testInt((6+7)*8),
@@ skipping 220 matching lines @@
                 break;
             case SkType_String:
                 SkASSERT(strcmp(value.fOperand.fString->c_str(), scriptTests[index].fStringAnswer) == 0);
                 break;
             default:
                 SkASSERT(0);
         }
     }
 }
 #endif