Convert NULL to nullptr

util/mach/symbolic_constants_mach.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/symbolic_constants_mach.h"
 
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "base/strings/stringprintf.h"
 #include "util/mach/exception_behaviors.h"
 #include "util/mach/mach_extensions.h"
 #include "util/stdlib/string_number_conversion.h"
 
 namespace {
 
 const char* kExceptionNames[] = {
-    NULL,
+    nullptr,
 
     // sed -Ene 's/^#define[[:space:]]EXC_([[:graph:]]+)[[:space:]]+[[:digit:]]{1,2}([[:space:]]|$).*/    "\1",/p'
     //     /usr/include/mach/exception_types.h
     "BAD_ACCESS",
     "BAD_INSTRUCTION",
     "ARITHMETIC",
     "EMULATION",
     "SOFTWARE",
     "BREAKPOINT",
     "SYSCALL",
     "MACH_SYSCALL",
     "RPC_ALERT",
     "CRASH",
     "RESOURCE",
     "GUARD",
 };
 static_assert(arraysize(kExceptionNames) == EXC_TYPES_COUNT,
               "kExceptionNames length");
 
 const char kExcPrefix[] = "EXC_";
 const char kExcMaskPrefix[] = "EXC_MASK_";
 
 const char* kBehaviorNames[] = {
-    NULL,
+    nullptr,
 
     // sed -Ene 's/^# define[[:space:]]EXCEPTION_([[:graph:]]+)[[:space:]]+[[:digit:]]{1,2}([[:space:]]|$).*/    "\1",/p'
     //     /usr/include/mach/exception_types.h
     "DEFAULT",
     "STATE",
     "STATE_IDENTITY",
 };
 
 const char kBehaviorPrefix[] = "EXCEPTION_";
 const char kMachExceptionCodesFull[] = "MACH_EXCEPTION_CODES";
@@ skipping 40 matching lines @@
     //     usr/include/mach/arm/thread_status.h
     // (iOS 7 SDK)
     // and then fix up by making the list sparse as appropriate.
     "ARM_THREAD_STATE",
     "ARM_VFP_STATE",
     "ARM_EXCEPTION_STATE",
     "ARM_DEBUG_STATE",
     "THREAD_STATE_NONE",
     "ARM_THREAD_STATE64",
     "ARM_EXCEPTION_STATE64",
-    NULL,
+    nullptr,
     "ARM_THREAD_STATE32",
-    NULL,
-    NULL,
-    NULL,
-    NULL,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
     "ARM_DEBUG_STATE32",
     "ARM_DEBUG_STATE64",
     "ARM_NEON_STATE",
     "ARM_NEON_STATE64",
 #endif
 };
 
 // Certain generic flavors have high constants not contiguous with the flavors
 // above. List them separately alongside their constants.
 const struct {
@@ skipping 58 matching lines @@
 
 }  // namespace
 
 namespace crashpad {
 
 std::string ExceptionToString(exception_type_t exception,
                               SymbolicConstantToStringOptions options) {
   const char* exception_name =
       static_cast<size_t>(exception) < arraysize(kExceptionNames)
           ? kExceptionNames[exception]
-          : NULL;
+          : nullptr;
   if (!exception_name) {
     if (options & kUnknownIsNumeric) {
       return base::StringPrintf("%d", exception);
     }
     return std::string();
   }
 
   if (options & kUseShortName) {
     return std::string(exception_name);
   }
@@ skipping 148 matching lines @@
   return false;
 }
 
 std::string ExceptionBehaviorToString(exception_behavior_t behavior,
                                       SymbolicConstantToStringOptions options) {
   const exception_behavior_t basic_behavior = ExceptionBehaviorBasic(behavior);
 
   const char* behavior_name =
       static_cast<size_t>(basic_behavior) < arraysize(kBehaviorNames)
           ? kBehaviorNames[basic_behavior]
-          : NULL;
+          : nullptr;
   if (!behavior_name) {
     if (options & kUnknownIsNumeric) {
       return base::StringPrintf("%#x", behavior);
     }
     return std::string();
   }
 
   std::string behavior_string;
   if (options & kUseShortName) {
     behavior_string.assign(behavior_name);
@@ skipping 81 matching lines @@
   }
 
   return false;
 }
 
 std::string ThreadStateFlavorToString(thread_state_flavor_t flavor,
                                       SymbolicConstantToStringOptions options) {
   const char* flavor_name =
       static_cast<size_t>(flavor) < arraysize(kFlavorNames)
           ? kFlavorNames[flavor]
-          : NULL;
+          : nullptr;
 
   if (!flavor_name) {
     for (size_t generic_flavor_index = 0;
          generic_flavor_index < arraysize(kGenericFlavorNames);
          ++generic_flavor_index) {
       if (flavor == kGenericFlavorNames[generic_flavor_index].flavor) {
         flavor_name = kGenericFlavorNames[generic_flavor_index].name;
         break;
       }
     }
@@ skipping 57 matching lines @@
   }
 
   if (options & kAllowNumber) {
     return StringToNumber(string, reinterpret_cast<unsigned int*>(flavor));
   }
 
   return false;
 }
 
 }  // namespace crashpad