Style Change: NULL->nullptr

src/ports/SkFontMgr_android_parser.cpp

 /*
  * Copyright 2011 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 "SkFontMgr_android_parser.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
@@ skipping 33 matching lines @@
  *
  * If the 'familyset' 'version' attribute is 21 or higher the LMP parser is used, otherwise the JB.
  */
 
 struct FamilyData;
 
 struct TagHandler {
     /** Called at the start tag.
      *  Called immediately after the parent tag retuns this handler from a call to 'tag'.
      *  Allows setting up for handling the tag content and processing attributes.
-     *  If NULL, will not be called.
+     *  If nullptr, will not be called.
      */
     void (*start)(FamilyData* data, const char* tag, const char** attributes);
 
     /** Called at the end tag.
      *  Allows post-processing of any accumulated information.
      *  This will be the last call made in relation to the current tag.
-     *  If NULL, will not be called.
+     *  If nullptr, will not be called.
      */
     void (*end)(FamilyData* data, const char* tag);
 
     /** Called when a nested tag is encountered.
      *  This is responsible for determining how to handle the tag.
-     *  If the tag is not recognized, return NULL to skip the tag.
-     *  If NULL, all nested tags will be skipped.
+     *  If the tag is not recognized, return nullptr to skip the tag.
+     *  If nullptr, all nested tags will be skipped.
      */
     const TagHandler* (*tag)(FamilyData* data, const char* tag, const char** attributes);
 
     /** The character handler for this tag.
      *  This is only active for character data contained directly in this tag (not sub-tags).
      *  The first parameter will be castable to a FamilyData*.
-     *  If NULL, any character data in this tag will be ignored.
+     *  If nullptr, any character data in this tag will be ignored.
      */
     XML_CharacterDataHandler chars;
 };
 
 /** Represents the current parsing state. */
 struct FamilyData {
     FamilyData(XML_Parser parser, SkTDArray<FontFamily*>& families,
                const SkString& basePath, bool isFallback, const char* filename,
                const TagHandler* topLevelHandler)
         : fParser(parser)
         , fFamilies(families)
-        , fCurrentFamily(NULL)
-        , fCurrentFontInfo(NULL)
+        , fCurrentFamily(nullptr)
+        , fCurrentFontInfo(nullptr)
         , fVersion(0)
         , fBasePath(basePath)
         , fIsFallback(isFallback)
         , fFilename(filename)
         , fDepth(1)
         , fSkip(0)
         , fHandler(&topLevelHandler, 1)
     { };
 
     XML_Parser fParser;                       // The expat parser doing the work, owned by caller
     SkTDArray<FontFamily*>& fFamilies;        // The array to append families, owned by caller
     SkAutoTDelete<FontFamily> fCurrentFamily; // The family being created, owned by this
     FontFileInfo* fCurrentFontInfo;           // The fontInfo being created, owned by fCurrentFamily
     int fVersion;                             // The version of the file parsed.
     const SkString& fBasePath;                // The current base path.
     const bool fIsFallback;                   // Indicates the file being parsed is a fallback file
     const char* fFilename;                    // The name of the file currently being parsed.
 
     int fDepth;                               // The current element depth of the parse.
     int fSkip;                                // The depth to stop skipping, 0 if not skipping.
     SkTDArray<const TagHandler*> fHandler;    // The stack of current tag handlers.
 };
 
 static bool memeq(const char* s1, const char* s2, size_t n1, size_t n2) {
     return n1 == n2 && 0 == memcmp(s1, s2, n1);
 }
 #define MEMEQ(c, s, n) memeq(c, s, sizeof(c) - 1, n)
 
-#define ATTS_NON_NULL(a, i) (a[i] != NULL && a[i+1] != NULL)
+#define ATTS_NON_NULL(a, i) (a[i] != nullptr && a[i+1] != nullptr)
 
 #define SK_FONTMGR_ANDROID_PARSER_PREFIX "[SkFontMgr Android Parser] "
 
 #define SK_FONTCONFIGPARSER_WARNING(message, ...) SkDebugf( \
     SK_FONTMGR_ANDROID_PARSER_PREFIX "%s:%d:%d: warning: " message "\n", \
     self->fFilename, \
     XML_GetCurrentLineNumber(self->fParser), \
     XML_GetCurrentColumnNumber(self->fParser), \
     ##__VA_ARGS__);
 
@@ skipping 43 matching lines @@
                 } else {
                     SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid axis tag", value);
                 }
             } else if (MEMEQ("stylevalue", name, nameLen)) {
                 if (!parse_fixed<16>(value, &axis.fValue)) {
                     SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid axis stylevalue", value);
                 }
             }
         }
     },
-    /*end*/NULL,
-    /*tag*/NULL,
-    /*chars*/NULL,
+    /*end*/nullptr,
+    /*tag*/nullptr,
+    /*chars*/nullptr,
 };
 
 static const TagHandler fontHandler = {
     /*start*/[](FamilyData* self, const char* tag, const char** attributes) {
         // 'weight' (non-negative integer) [default 0]
         // 'style' ("normal", "italic") [default "auto"]
         // 'index' (non-negative integer) [default 0]
         // The character data should be a filename.
         FontFileInfo& file = self->fCurrentFamily->fFonts.push_back();
         self->fCurrentFontInfo = &file;
@@ skipping 20 matching lines @@
         }
     },
     /*end*/[](FamilyData* self, const char* tag) {
         trim_string(&self->fCurrentFontInfo->fFileName);
     },
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("axis", tag, len)) {
             return &axisHandler;
         }
-        return NULL;
+        return nullptr;
     },
     /*chars*/[](void* data, const char* s, int len) {
         FamilyData* self = static_cast<FamilyData*>(data);
         self->fCurrentFontInfo->fFileName.append(s, len);
     }
 };
 
 static const TagHandler familyHandler = {
     /*start*/[](FamilyData* self, const char* tag, const char** attributes) {
         // 'name' (string) [optional]
@@ skipping 23 matching lines @@
         }
     },
     /*end*/[](FamilyData* self, const char* tag) {
         *self->fFamilies.append() = self->fCurrentFamily.detach();
     },
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("font", tag, len)) {
             return &fontHandler;
         }
-        return NULL;
+        return nullptr;
     },
-    /*chars*/NULL,
+    /*chars*/nullptr,
 };
 
 static FontFamily* find_family(FamilyData* self, const SkString& familyName) {
     for (int i = 0; i < self->fFamilies.count(); i++) {
         FontFamily* candidate = self->fFamilies[i];
         for (int j = 0; j < candidate->fNames.count(); j++) {
             if (candidate->fNames[j] == familyName) {
                 return candidate;
             }
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 static const TagHandler aliasHandler = {
     /*start*/[](FamilyData* self, const char* tag, const char** attributes) {
         // 'name' (string) introduces a new family name.
         // 'to' (string) specifies which (previous) family to alias
         // 'weight' (non-negative integer) [optional]
         // If it *does not* have a weight, 'name' is an alias for the entire 'to' family.
         // If it *does* have a weight, 'name' is a new family consisting of
         // the font(s) with 'weight' from the 'to' family.
@@ skipping 31 matching lines @@
             for (int i = 0; i < targetFamily->fFonts.count(); i++) {
                 if (targetFamily->fFonts[i].fWeight == weight) {
                     family->fFonts.push_back(targetFamily->fFonts[i]);
                 }
             }
             *self->fFamilies.append() = family;
         } else {
             targetFamily->fNames.push_back().set(aliasName);
         }
     },
-    /*end*/NULL,
-    /*tag*/NULL,
-    /*chars*/NULL,
+    /*end*/nullptr,
+    /*tag*/nullptr,
+    /*chars*/nullptr,
 };
 
 static const TagHandler familySetHandler = {
     /*start*/[](FamilyData* self, const char* tag, const char** attributes) { },
-    /*end*/NULL,
+    /*end*/nullptr,
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("family", tag, len)) {
             return &familyHandler;
         } else if (MEMEQ("alias", tag, len)) {
             return &aliasHandler;
         }
-        return NULL;
+        return nullptr;
     },
-    /*chars*/NULL,
+    /*chars*/nullptr,
 };
 
 } // lmpParser
 
 namespace jbParser {
 
 static const TagHandler fileHandler = {
     /*start*/[](FamilyData* self, const char* tag, const char** attributes) {
         // 'variant' ("elegant", "compact") [default "default"]
         // 'lang' (string) [default ""]
@@ skipping 31 matching lines @@
 
                 } else if (MEMEQ("index", name, nameLen)) {
                     if (!parse_non_negative_integer(value, &newFileInfo.fIndex)) {
                         SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid index", value);
                     }
                 }
             }
         }
         self->fCurrentFontInfo = &newFileInfo;
     },
-    /*end*/NULL,
-    /*tag*/NULL,
+    /*end*/nullptr,
+    /*tag*/nullptr,
     /*chars*/[](void* data, const char* s, int len) {
         FamilyData* self = static_cast<FamilyData*>(data);
         self->fCurrentFontInfo->fFileName.append(s, len);
     }
 };
 
 static const TagHandler fileSetHandler = {
-    /*start*/NULL,
-    /*end*/NULL,
+    /*start*/nullptr,
+    /*end*/nullptr,
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("file", tag, len)) {
             return &fileHandler;
         }
-        return NULL;
+        return nullptr;
     },
-    /*chars*/NULL,
+    /*chars*/nullptr,
 };
 
 static const TagHandler nameHandler = {
     /*start*/[](FamilyData* self, const char* tag, const char** attributes) {
         // The character data should be a name for the font.
         self->fCurrentFamily->fNames.push_back();
     },
-    /*end*/NULL,
-    /*tag*/NULL,
+    /*end*/nullptr,
+    /*tag*/nullptr,
     /*chars*/[](void* data, const char* s, int len) {
         FamilyData* self = static_cast<FamilyData*>(data);
         SkAutoAsciiToLC tolc(s, len);
         self->fCurrentFamily->fNames.back().append(tolc.lc(), len);
     }
 };
 
 static const TagHandler nameSetHandler = {
-    /*start*/NULL,
-    /*end*/NULL,
+    /*start*/nullptr,
+    /*end*/nullptr,
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("name", tag, len)) {
             return &nameHandler;
         }
-        return NULL;
+        return nullptr;
     },
-    /*chars*/NULL,
+    /*chars*/nullptr,
 };
 
 static const TagHandler familyHandler = {
     /*start*/[](FamilyData* self, const char* tag, const char** attributes) {
         self->fCurrentFamily.reset(new FontFamily(self->fBasePath, self->fIsFallback));
         // 'order' (non-negative integer) [default -1]
         for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
             const char* value = attributes[i+1];
             parse_non_negative_integer(value, &self->fCurrentFamily->fOrder);
         }
     },
     /*end*/[](FamilyData* self, const char* tag) {
         *self->fFamilies.append() = self->fCurrentFamily.detach();
     },
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("nameset", tag, len)) {
             return &nameSetHandler;
         } else if (MEMEQ("fileset", tag, len)) {
             return &fileSetHandler;
         }
-        return NULL;
+        return nullptr;
     },
-    /*chars*/NULL,
+    /*chars*/nullptr,
 };
 
 static const TagHandler familySetHandler = {
-    /*start*/NULL,
-    /*end*/NULL,
+    /*start*/nullptr,
+    /*end*/nullptr,
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("family", tag, len)) {
             return &familyHandler;
         }
-        return NULL;
+        return nullptr;
     },
-    /*chars*/NULL,
+    /*chars*/nullptr,
 };
 
 } // namespace jbParser
 
 static const TagHandler topLevelHandler = {
-    /*start*/NULL,
-    /*end*/NULL,
+    /*start*/nullptr,
+    /*end*/nullptr,
     /*tag*/[](FamilyData* self, const char* tag, const char** attributes) -> const TagHandler* {
         size_t len = strlen(tag);
         if (MEMEQ("familyset", tag, len)) {
             // 'version' (non-negative integer) [default 0]
             for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
                 const char* name = attributes[i];
                 size_t nameLen = strlen(name);
                 if (MEMEQ("version", name, nameLen)) {
                     const char* value = attributes[i+1];
                     if (parse_non_negative_integer(value, &self->fVersion)) {
                         if (self->fVersion >= 21) {
                             return &lmpParser::familySetHandler;
                         }
                     }
                 }
             }
             return &jbParser::familySetHandler;
         }
-        return NULL;
+        return nullptr;
     },
-    /*chars*/NULL,
+    /*chars*/nullptr,
 };
 
 static void XMLCALL start_element_handler(void *data, const char *tag, const char **attributes) {
     FamilyData* self = static_cast<FamilyData*>(data);
 
     if (!self->fSkip) {
         const TagHandler* parent = self->fHandler.top();
-        const TagHandler* child = parent->tag ? parent->tag(self, tag, attributes) : NULL;
+        const TagHandler* child = parent->tag ? parent->tag(self, tag, attributes) : nullptr;
         if (child) {
             if (child->start) {
                 child->start(self, tag, attributes);
             }
             self->fHandler.push(child);
             XML_SetCharacterDataHandler(self->fParser, child->chars);
         } else {
             SK_FONTCONFIGPARSER_WARNING("'%s' tag not recognized, skipping", tag);
-            XML_SetCharacterDataHandler(self->fParser, NULL);
+            XML_SetCharacterDataHandler(self->fParser, nullptr);
             self->fSkip = self->fDepth;
         }
     }
 
     ++self->fDepth;
 }
 
 static void XMLCALL end_element_handler(void* data, const char* tag) {
     FamilyData* self = static_cast<FamilyData*>(data);
     --self->fDepth;
@@ skipping 49 matching lines @@
     SkFILEStream file(filename);
 
     // Some of the files we attempt to parse (in particular, /vendor/etc/fallback_fonts.xml)
     // are optional - failure here is okay because one of these optional files may not exist.
     if (!file.isValid()) {
         SkDebugf(SK_FONTMGR_ANDROID_PARSER_PREFIX "'%s' could not be opened\n", filename);
         return -1;
     }
 
     SkAutoTCallVProc<remove_ptr<XML_Parser>::type, XML_ParserFree> parser(
-        XML_ParserCreate_MM(NULL, &sk_XML_alloc, NULL));
+        XML_ParserCreate_MM(nullptr, &sk_XML_alloc, nullptr));
     if (!parser) {
         SkDebugf(SK_FONTMGR_ANDROID_PARSER_PREFIX "could not create XML parser\n");
         return -1;
     }
 
     FamilyData self(parser, families, basePath, isFallback, filename, &topLevelHandler);
     XML_SetUserData(parser, &self);
 
     // Disable entity processing, to inhibit internal entity expansion. See expat CVE-2013-0340
     XML_SetEntityDeclHandler(parser, xml_entity_decl_handler);
@@ skipping 51 matching lines @@
 static void append_fallback_font_families_for_locale(SkTDArray<FontFamily*>& fallbackFonts,
                                                      const char* dir,
                                                      const SkString& basePath)
 {
 #if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
     // The framework is beyond Android 4.2 and can therefore skip this function
     return;
 #endif
 
     SkAutoTCallIProc<DIR, closedir> fontDirectory(opendir(dir));
-    if (NULL == fontDirectory) {
+    if (nullptr == fontDirectory) {
         return;
     }
 
     for (struct dirent* dirEntry; (dirEntry = readdir(fontDirectory));) {
         // The size of the prefix and suffix.
         static const size_t fixedLen = sizeof(LOCALE_FALLBACK_FONTS_PREFIX) - 1
                                      + sizeof(LOCALE_FALLBACK_FONTS_SUFFIX) - 1;
 
         // The size of the prefix, suffix, and a minimum valid language code
         static const size_t minSize = fixedLen + 2;
@@ skipping 99 matching lines @@
                                                  basePath);
     }
 }
 
 SkLanguage SkLanguage::getParent() const {
     SkASSERT(!fTag.isEmpty());
     const char* tag = fTag.c_str();
 
     // strip off the rightmost "-.*"
     const char* parentTagEnd = strrchr(tag, '-');
-    if (parentTagEnd == NULL) {
+    if (parentTagEnd == nullptr) {
         return SkLanguage();
     }
     size_t parentTagLen = parentTagEnd - tag;
     return SkLanguage(tag, parentTagLen);
 }