Static analysis fix: replace 0 and NULL with nullptr

include/yaml-cpp/binary.h

@@ -39,7 +39,7 @@ class YAML_CPP_API Binary {
       rhs.clear();
       rhs.resize(m_unownedSize);
       std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());
-      m_unownedData = 0;
+      m_unownedData = nullptr;
       m_unownedSize = 0;
     } else {
       m_data.swap(rhs);

include/yaml-cpp/exceptions.h

@@ -117,7 +117,7 @@ inline const std::string KEY_NOT_FOUND_WITH_KEY(
 
 template <typename T>
 inline const std::string BAD_SUBSCRIPT_WITH_KEY(
-    const T&, typename disable_if<is_numeric<T>>::type* = 0) {
+    const T&, typename disable_if<is_numeric<T>>::type* = nullptr) {
   return BAD_SUBSCRIPT;
 }
 
@@ -129,7 +129,7 @@ inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) {
 
 template <typename T>
 inline const std::string BAD_SUBSCRIPT_WITH_KEY(
-    const T& key, typename enable_if<is_numeric<T>>::type* = 0) {
+    const T& key, typename enable_if<is_numeric<T>>::type* = nullptr) {
   std::stringstream stream;
   stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
   return stream.str();

include/yaml-cpp/node/detail/impl.h

@@ -17,7 +17,7 @@ template <typename Key, typename Enable = void>
 struct get_idx {
   static node* get(const std::vector<node*>& /* sequence */,
                    const Key& /* key */, shared_memory_holder /* pMemory */) {
-    return 0;
+    return nullptr;
   }
 };
 
@@ -27,7 +27,7 @@ struct get_idx<Key,
                                        !std::is_same<Key, bool>::value>::type> {
   static node* get(const std::vector<node*>& sequence, const Key& key,
                    shared_memory_holder /* pMemory */) {
-    return key < sequence.size() ? sequence[key] : 0;
+    return key < sequence.size() ? sequence[key] : nullptr;
   }
 
   static node* get(std::vector<node*>& sequence, const Key& key,
@@ -46,13 +46,13 @@ struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> {
                    shared_memory_holder pMemory) {
     return key >= 0 ? get_idx<std::size_t>::get(
                           sequence, static_cast<std::size_t>(key), pMemory)
-                    : 0;
+                    : nullptr;
   }
   static node* get(std::vector<node*>& sequence, const Key& key,
                    shared_memory_holder pMemory) {
     return key >= 0 ? get_idx<std::size_t>::get(
                           sequence, static_cast<std::size_t>(key), pMemory)
-                    : 0;
+                    : nullptr;
   }
 };
 
@@ -109,11 +109,11 @@ inline node* node_data::get(const Key& key,
       break;
     case NodeType::Undefined:
     case NodeType::Null:
-      return NULL;
+      return nullptr;
     case NodeType::Sequence:
       if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
         return pNode;
-      return NULL;
+      return nullptr;
     case NodeType::Scalar:
       throw BadSubscript(key);
   }
@@ -124,7 +124,7 @@ inline node* node_data::get(const Key& key,
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 template <typename Key>

include/yaml-cpp/node/detail/node_iterator.h

@@ -26,9 +26,9 @@ template <typename V>
 struct node_iterator_value : public std::pair<V*, V*> {
   typedef std::pair<V*, V*> kv;
 
-  node_iterator_value() : kv(), pNode(0) {}
+  node_iterator_value() : kv(), pNode(nullptr) {}
   explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
-  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {}
+  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(nullptr) {}
 
   V& operator*() const { return *pNode; }
   V& operator->() const { return *pNode; }

include/yaml-cpp/node/impl.h

@@ -52,7 +52,7 @@ inline Node::Node(Zombie)
     : m_isValid(false), m_invalidKey{}, m_pMemory{}, m_pNode(nullptr) {}
 
 inline Node::Node(Zombie, const std::string& key)
-    : m_isValid(false), m_invalidKey(key), m_pMemory{}, m_pNode(NULL) {}
+    : m_isValid(false), m_invalidKey(key), m_pMemory{}, m_pNode(nullptr) {}
 
 inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
     : m_isValid(true), m_invalidKey{}, m_pMemory(pMemory), m_pNode(&node) {}

include/yaml-cpp/ostream_wrapper.h

@@ -30,7 +30,7 @@ class YAML_CPP_API ostream_wrapper {
 
   const char* str() const {
     if (m_pStream) {
-      return 0;
+      return nullptr;
     } else {
       m_buffer[m_pos] = '\0';
       return &m_buffer[0];