Style Change: NULL->nullptr

src/xml/SkDOM.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 "SkDOM.h"
 #include "SkStream.h"
 #include "SkXMLWriter.h"
 
 /////////////////////////////////////////////////////////////////////////
 
 #include "SkXMLParser.h"
 bool SkXMLParser::parse(const SkDOM& dom, const SkDOMNode* node)
 {
     const char* elemName = dom.getName(node);
 
     if (this->startElement(elemName))
         return false;
 
     SkDOM::AttrIter iter(dom, node);
     const char*     name, *value;
 
-    while ((name = iter.next(&value)) != NULL)
+    while ((name = iter.next(&value)) != nullptr)
         if (this->addAttribute(name, value))
             return false;
 
-    if ((node = dom.getFirstChild(node)) != NULL)
+    if ((node = dom.getFirstChild(node)) != nullptr)
         do {
             if (!this->parse(dom, node))
                 return false;
-        } while ((node = dom.getNextSibling(node)) != NULL);
+        } while ((node = dom.getNextSibling(node)) != nullptr);
 
     return !this->endElement(elemName);
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 struct SkDOMAttr {
     const char* fName;
     const char* fValue;
 };
@@ skipping 13 matching lines @@
     SkDOMAttr* attrs()
     {
         return (SkDOMAttr*)(this + 1);
     }
 };
 
 /////////////////////////////////////////////////////////////////////////
 
 #define kMinChunkSize   512
 
-SkDOM::SkDOM() : fAlloc(kMinChunkSize), fRoot(NULL)
+SkDOM::SkDOM() : fAlloc(kMinChunkSize), fRoot(nullptr)
 {
 }
 
 SkDOM::~SkDOM()
 {
 }
 
 const SkDOM::Node* SkDOM::getRootNode() const
 {
     return fRoot;
 }
 
 const SkDOM::Node* SkDOM::getFirstChild(const Node* node, const char name[]) const
 {
     SkASSERT(node);
     const Node* child = node->fFirstChild;
 
     if (name)
     {
-        for (; child != NULL; child = child->fNextSibling)
+        for (; child != nullptr; child = child->fNextSibling)
             if (!strcmp(name, child->fName))
                 break;
     }
     return child;
 }
 
 const SkDOM::Node* SkDOM::getNextSibling(const Node* node, const char name[]) const
 {
     SkASSERT(node);
     const Node* sibling = node->fNextSibling;
     if (name)
     {
-        for (; sibling != NULL; sibling = sibling->fNextSibling)
+        for (; sibling != nullptr; sibling = sibling->fNextSibling)
             if (!strcmp(name, sibling->fName))
                 break;
     }
     return sibling;
 }
 
 SkDOM::Type SkDOM::getType(const Node* node) const
 {
     SkASSERT(node);
     return (Type)node->fType;
@@ skipping 10 matching lines @@
     SkASSERT(node);
     const Attr* attr = node->attrs();
     const Attr* stop = attr + node->fAttrCount;
 
     while (attr < stop)
     {
         if (!strcmp(attr->fName, name))
             return attr->fValue;
         attr += 1;
     }
-    return NULL;
+    return nullptr;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 
 const SkDOM::Attr* SkDOM::getFirstAttr(const Node* node) const
 {
-    return node->fAttrCount ? node->attrs() : NULL;
+    return node->fAttrCount ? node->attrs() : nullptr;
 }
 
 const SkDOM::Attr* SkDOM::getNextAttr(const Node* node, const Attr* attr) const
 {
     SkASSERT(node);
-    if (attr == NULL)
-        return NULL;
-    return (attr - node->attrs() + 1) < node->fAttrCount ? attr + 1 : NULL;
+    if (attr == nullptr)
+        return nullptr;
+    return (attr - node->attrs() + 1) < node->fAttrCount ? attr + 1 : nullptr;
 }
 
 const char* SkDOM::getAttrName(const Node* node, const Attr* attr) const
 {
     SkASSERT(node);
     SkASSERT(attr);
     return attr->fName;
 }
 
 const char* SkDOM::getAttrValue(const Node* node, const Attr* attr) const
 {
     SkASSERT(node);
     SkASSERT(attr);
     return attr->fValue;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 
 SkDOM::AttrIter::AttrIter(const SkDOM&, const SkDOM::Node* node)
 {
     SkASSERT(node);
     fAttr = node->attrs();
     fStop = fAttr + node->fAttrCount;
 }
 
 const char* SkDOM::AttrIter::next(const char** value)
 {
-    const char* name = NULL;
+    const char* name = nullptr;
 
     if (fAttr < fStop)
     {
         name = fAttr->fName;
         if (value)
             *value = fAttr->fValue;
         fAttr += 1;
     }
     return name;
 }
@@ skipping 10 matching lines @@
     char*   dst = (char*)chunk->alloc(len + 1, SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dst, src, len + 1);
     return dst;
 }
 
 class SkDOMParser : public SkXMLParser {
 public:
     SkDOMParser(SkChunkAlloc* chunk) : SkXMLParser(&fParserError), fAlloc(chunk)
     {
         fAlloc->reset();
-        fRoot = NULL;
+        fRoot = nullptr;
         fLevel = 0;
         fNeedToFlush = true;
     }
     SkDOM::Node* getRoot() const { return fRoot; }
     SkXMLParserError fParserError;
 
 protected:
     void flushAttributes()
     {
         SkASSERT(fLevel > 0);
 
         int attrCount = fAttrs.count();
 
         SkDOM::Node* node = (SkDOM::Node*)fAlloc->alloc(sizeof(SkDOM::Node) + attrCount * sizeof(SkDOM::Attr),
                                                         SkChunkAlloc::kThrow_AllocFailType);
 
         node->fName = fElemName;
-        node->fFirstChild = NULL;
+        node->fFirstChild = nullptr;
         node->fAttrCount = SkToU16(attrCount);
         node->fType = fElemType;
 
-        if (fRoot == NULL)
+        if (fRoot == nullptr)
         {
-            node->fNextSibling = NULL;
+            node->fNextSibling = nullptr;
             fRoot = node;
         }
         else    // this adds siblings in reverse order. gets corrected in onEndElement()
         {
             SkDOM::Node* parent = fParentStack.top();
             SkASSERT(fRoot && parent);
             node->fNextSibling = parent->fFirstChild;
             parent->fFirstChild = node;
         }
         *fParentStack.push() = node;
@@ skipping 19 matching lines @@
         --fLevel;
         if (fNeedToFlush)
             this->flushAttributes();
         fNeedToFlush = false;
 
         SkDOM::Node* parent;
 
         fParentStack.pop(&parent);
 
         SkDOM::Node* child = parent->fFirstChild;
-        SkDOM::Node* prev = NULL;
+        SkDOM::Node* prev = nullptr;
         while (child)
         {
             SkDOM::Node* next = child->fNextSibling;
             child->fNextSibling = prev;
             prev = child;
             child = next;
         }
         parent->fFirstChild = prev;
         return false;
     }
@@ skipping 28 matching lines @@
     SkDOM::Type             fElemType;
     int                     fLevel;
 };
 
 const SkDOM::Node* SkDOM::build(const char doc[], size_t len)
 {
     SkDOMParser parser(&fAlloc);
     if (!parser.parse(doc, len))
     {
         SkDEBUGCODE(SkDebugf("xml parse error, line %d\n", parser.fParserError.getLineNumber());)
-        fRoot = NULL;
+        fRoot = nullptr;
         fAlloc.reset();
-        return NULL;
+        return nullptr;
     }
     fRoot = parser.getRoot();
     return fRoot;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
 static void walk_dom(const SkDOM& dom, const SkDOM::Node* node, SkXMLParser* parser)
 {
     const char* elem = dom.getName(node);
     if (dom.getType(node) == SkDOM::kText_Type) {
         SkASSERT(dom.countChildren(node) == 0);
         parser->text(elem, SkToInt(strlen(elem)));
         return;
     }
 
     parser->startElement(elem);
 
     SkDOM::AttrIter iter(dom, node);
     const char*     name;
     const char*     value;
-    while ((name = iter.next(&value)) != NULL)
+    while ((name = iter.next(&value)) != nullptr)
         parser->addAttribute(name, value);
 
-    node = dom.getFirstChild(node, NULL);
+    node = dom.getFirstChild(node, nullptr);
     while (node)
     {
         walk_dom(dom, node, parser);
-        node = dom.getNextSibling(node, NULL);
+        node = dom.getNextSibling(node, nullptr);
     }
 
     parser->endElement(elem);
 }
 
 const SkDOM::Node* SkDOM::copy(const SkDOM& dom, const SkDOM::Node* node)
 {
     SkDOMParser parser(&fAlloc);
 
     walk_dom(dom, node, &parser);
@@ skipping 99 matching lines @@
     bool        value;
     return vstr && SkParse::FindBool(vstr, &value) && value == target;
 }
 
 //////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 
 void SkDOM::dump(const Node* node, int level) const
 {
-    if (node == NULL)
+    if (node == nullptr)
         node = this->getRootNode();
 
     SkDebugWStream debugStream;
     SkXMLStreamWriter xmlWriter(&debugStream);
     xmlWriter.writeDOM(*this, node, false);
 }
 
 void SkDOM::UnitTest()
 {
 #ifdef SK_SUPPORT_UNITTEST
     static const char gDoc[] =
         "<root a='1' b='2'>"
             "<elem1 c='3' />"
             "<elem2 d='4' />"
             "<elem3 e='5'>"
                 "<subelem1/>"
                 "<subelem2 f='6' g='7'/>"
             "</elem3>"
             "<elem4 h='8'/>"
         "</root>"
         ;
 
     SkDOM   dom;
 
-    SkASSERT(dom.getRootNode() == NULL);
+    SkASSERT(dom.getRootNode() == nullptr);
 
     const Node* root = dom.build(gDoc, sizeof(gDoc) - 1);
     SkASSERT(root && dom.getRootNode() == root);
 
     const char* v = dom.findAttr(root, "a");
     SkASSERT(v && !strcmp(v, "1"));
     v = dom.findAttr(root, "b");
     SkASSERT(v && !strcmp(v, "2"));
     v = dom.findAttr(root, "c");
-    SkASSERT(v == NULL);
+    SkASSERT(v == nullptr);
 
     SkASSERT(dom.getFirstChild(root, "elem1"));
     SkASSERT(!dom.getFirstChild(root, "subelem1"));
 
     dom.dump();
 #endif
 }
 
 #endif