Regularize informative messages in Android font parser.

src/ports/SkFontConfigParser_android.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 "SkFontConfigParser_android.h"
 #include "SkFontMgr_android.h"
 #include "SkStream.h"
@@ skipping 41 matching lines @@
     kNameSet_CurrentTag,
     kFileSet_CurrentTag
 };
 
 /**
  * The FamilyData structure is passed around by the parser so that each handler
  * can read these variables that are relevant to the current parsing.
  */
 struct FamilyData {
     FamilyData(XML_Parser parser, SkTDArray<FontFamily*>& families,
-               const SkString& basePath, bool isFallback)
+               const SkString& basePath, bool isFallback, const char* filename)
         : fParser(parser)
         , fFamilies(families)
         , fCurrentFamily(NULL)
         , fCurrentFontInfo(NULL)
         , fCurrentTag(kNo_CurrentTag)
         , fVersion(0)
         , fBasePath(basePath)
         , fIsFallback(isFallback)
+        , fFilename(filename)
     { };
 
     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
     CurrentTag fCurrentTag;                   // The kind of tag currently being parsed.
     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.
 };
 
 /** Parses a null terminated string into an integer type, checking for overflow.
  *  http://www.w3.org/TR/html-markup/datatypes.html#common.data.integer.non-negative-def
  *
  *  If the string cannot be parsed into 'value', returns false and does not change 'value'.
  */
 template <typename T> static bool parse_non_negative_integer(const char* s, T* value) {
     SK_COMPILE_ASSERT(std::numeric_limits<T>::is_integer, T_must_be_integer);
     const T nMax = std::numeric_limits<T>::max() / 10;
@@ skipping 15 matching lines @@
     return true;
 }
 
 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 SK_FONTCONFIGPARSER_PREFIX "[SkFontConfigParser] "
+
+#define SK_FONTCONFIGPARSER_WARNING(message, ...) SkDebugf( \
+    SK_FONTCONFIGPARSER_PREFIX "%s:%d:%d: warning: " message "\n", \
+    self->fFilename, \
+    XML_GetCurrentLineNumber(self->fParser), \
+    XML_GetCurrentColumnNumber(self->fParser), \
+    ##__VA_ARGS__);
+
 namespace lmpParser {
 
 static void family_element_handler(FontFamily* family, const char** attributes) {
-    // A non-fallback <family> tag must have a canonical name attribute.
-    // A fallback <family> tag has no name, and may have lang and variant
-    // attributes.
+    // A <family> element without a 'name' (string) attribute is a fallback font.
+    // The element may have 'lang' (string) and 'variant' ("elegant", "compact") attributes.
+    // The element should contain <font> elements.
     family->fIsFallbackFont = true;
     for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
         const char* name = attributes[i];
         const char* value = attributes[i+1];
         size_t nameLen = strlen(name);
         size_t valueLen = strlen(value);
         if (MEMEQ("name", name, nameLen)) {
             SkAutoAsciiToLC tolc(value);
             family->fNames.push_back().set(tolc.lc());
             family->fIsFallbackFont = false;
         } else if (MEMEQ("lang", name, nameLen)) {
             family->fLanguage = SkLanguage(value, valueLen);
         } else if (MEMEQ("variant", name, nameLen)) {
-            // Value should be either elegant or compact.
             if (MEMEQ("elegant", value, valueLen)) {
                 family->fVariant = kElegant_FontVariant;
             } else if (MEMEQ("compact", value, valueLen)) {
                 family->fVariant = kCompact_FontVariant;
             }
         }
     }
 }
 
 static void XMLCALL font_file_name_handler(void* data, const char* s, int len) {
     FamilyData* self = static_cast<FamilyData*>(data);
     self->fCurrentFontInfo->fFileName.append(s, len);
 }
 
 static void font_element_handler(FamilyData* self, FontFileInfo* file, const char** attributes) {
-    // A <font> should have weight (integer) and style (normal, italic) attributes.
-    // NOTE: we ignore the style.
+    // A <font> element should be contained in a <family> element.
+    // The element may have 'weight' (non-negative integer), 'style' ("normal", "italic"),
+    // and 'index' (non-negative integer) attributes.
     // The element should contain a filename.
     for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
         const char* name = attributes[i];
         const char* value = attributes[i+1];
         size_t nameLen = strlen(name);
         if (MEMEQ("weight", name, nameLen)) {
             if (!parse_non_negative_integer(value, &file->fWeight)) {
-                SkDebugf("---- Font weight %s (INVALID)", value);
+                SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid weight", value);
             }
         } else if (MEMEQ("style", name, nameLen)) {
             size_t valueLen = strlen(value);
             if (MEMEQ("normal", value, valueLen)) {
                 file->fStyle = FontFileInfo::Style::kNormal;
             } else if (MEMEQ("italic", value, valueLen)) {
                 file->fStyle = FontFileInfo::Style::kItalic;
             }
         } else if (MEMEQ("index", name, nameLen)) {
             if (!parse_non_negative_integer(value, &file->fIndex)) {
-                SkDebugf("---- Font index %s (INVALID)", value);
+                SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid index", value);
             }
         }
     }
     XML_SetCharacterDataHandler(self->fParser, font_file_name_handler);
 }
 
 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;
 }
 
 static void alias_element_handler(FamilyData* self, const char** attributes) {
-    // An <alias> must have name and to attributes.
-    //   It may have weight (integer).
-    // If it *does not* have a weight, it is a variant name for a <family>.
-    // If it *does* have a weight, it names the <font>(s) of a specific weight
-    //   from a <family>.
+    // A <alias> element must have 'name' (string) and 'to' (string) attributes.
+    // The element may also have a 'weight' (non-negative integer) attribute.
+    // The 'name' introduces a new family name.
+    // The 'to' specifies which (previous) <family> to alias.
+    // 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>.
 
     SkString aliasName;
     SkString to;
     int weight = 0;
     for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
         const char* name = attributes[i];
         const char* value = attributes[i+1];
         size_t nameLen = strlen(name);
         if (MEMEQ("name", name, nameLen)) {
             SkAutoAsciiToLC tolc(value);
             aliasName.set(tolc.lc());
         } else if (MEMEQ("to", name, nameLen)) {
             to.set(value);
         } else if (MEMEQ("weight", name, nameLen)) {
             if (!parse_non_negative_integer(value, &weight)) {
-                SkDebugf("---- Font weight %s (INVALID)", value);
+                SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid weight", value);
             }
         }
     }
 
     // Assumes that the named family is already declared
     FontFamily* targetFamily = find_family(self, to);
     if (!targetFamily) {
-        SkDebugf("---- Font alias target %s (NOT FOUND)", to.c_str());
+        SK_FONTCONFIGPARSER_WARNING("'%s' alias target not found", to.c_str());
         return;
     }
 
     if (weight) {
         FontFamily* family = new FontFamily(targetFamily->fBasePath, self->fIsFallback);
         family->fNames.push_back().set(aliasName);
 
         for (int i = 0; i < targetFamily->fFonts.count(); i++) {
             if (targetFamily->fFonts[i].fWeight == weight) {
                 family->fFonts.push_back(targetFamily->fFonts[i]);
@@ skipping 62 matching lines @@
 
 /**
  * Handler for font files. This processes the attributes for language and
  * variants then lets textHandler handle the actual file name
  */
 static void font_file_element_handler(FamilyData* self, const char** attributes) {
     FontFamily& currentFamily = *self->fCurrentFamily.get();
     FontFileInfo& newFileInfo = currentFamily.fFonts.push_back();
     if (attributes) {
         for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
-            const char* attributeName = attributes[i];
-            const char* attributeValue = attributes[i+1];
-            size_t nameLength = strlen(attributeName);
-            size_t valueLength = strlen(attributeValue);
-            if (MEMEQ("variant", attributeName, nameLength)) {
+            const char* name = attributes[i];
+            const char* value = attributes[i+1];
+            size_t nameLen = strlen(name);
+            size_t valueLen = strlen(value);
+            if (MEMEQ("variant", name, nameLen)) {
                 const FontVariant prevVariant = currentFamily.fVariant;
-                if (MEMEQ("elegant", attributeValue, valueLength)) {
+                if (MEMEQ("elegant", value, valueLen)) {
                     currentFamily.fVariant = kElegant_FontVariant;
-                } else if (MEMEQ("compact", attributeValue, valueLength)) {
+                } else if (MEMEQ("compact", value, valueLen)) {
                     currentFamily.fVariant = kCompact_FontVariant;
                 }
                 if (currentFamily.fFonts.count() > 1 && currentFamily.fVariant != prevVariant) {
-                    SkDebugf("Every font file within a family must have identical variants");
+                    SK_FONTCONFIGPARSER_WARNING("'%s' unexpected variant found\n"
+                        "Note: Every font file within a family must have identical variants.",
+                        value);
                 }
 
-            } else if (MEMEQ("lang", attributeName, nameLength)) {
+            } else if (MEMEQ("lang", name, nameLen)) {
                 SkLanguage prevLang = currentFamily.fLanguage;
-                currentFamily.fLanguage = SkLanguage(attributeValue, valueLength);
+                currentFamily.fLanguage = SkLanguage(value, valueLen);
                 if (currentFamily.fFonts.count() > 1 && currentFamily.fLanguage != prevLang) {
-                    SkDebugf("Every font file within a family must have identical languages");
+                    SK_FONTCONFIGPARSER_WARNING("'%s' unexpected language found\n"
+                        "Note: Every font file within a family must have identical languages.",
+                        value);
                 }
 
-            } else if (MEMEQ("index", attributeName, nameLength)) {
-                if (!parse_non_negative_integer(attributeValue, &newFileInfo.fIndex)) {
-                    SkDebugf("---- SystemFonts index=%s (INVALID)", attributeValue);
+            } 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;
     XML_SetCharacterDataHandler(self->fParser, text_handler);
 }
 
 /**
  * Handler for the start of a tag. The only tags we expect are familyset, family,
  * nameset, fileset, name, and file.
  */
 static void XMLCALL start_element_handler(void* data, const char* tag, const char** attributes) {
     FamilyData* self = static_cast<FamilyData*>(data);
     size_t len = strlen(tag);
     if (MEMEQ("familyset", tag, len)) {
-        // The familyset tag has an optional "version" attribute with an integer value >= 0
+        // The <familyset> element has an optional 'version' (non-negative integer) attribute.
         for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
             size_t nameLen = strlen(attributes[i]);
             if (!MEMEQ("version", attributes[i], nameLen)) continue;
             const char* valueString = attributes[i+1];
             int version;
             if (parse_non_negative_integer(valueString, &version) && (version >= 21)) {
                 XML_SetElementHandler(self->fParser,
                                       lmpParser::start_element_handler,
                                       lmpParser::end_element_handler);
                 self->fVersion = version;
             }
         }
     } else if (MEMEQ("family", tag, len)) {
         self->fCurrentFamily.reset(new FontFamily(self->fBasePath, self->fIsFallback));
-        // The Family tag has an optional "order" attribute with an integer value >= 0
-        // If this attribute does not exist, the default value is -1
+        // The <family> element has an optional 'order' (non-negative integer) attribute.
+        // If this attribute does not exist, the default value is -1.
         for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
             const char* valueString = attributes[i+1];
             int value;
             if (parse_non_negative_integer(valueString, &value)) {
                 self->fCurrentFamily->fOrder = value;
             }
         }
     } else if (MEMEQ("nameset", tag, len)) {
         self->fCurrentTag = kNameSet_CurrentTag;
     } else if (MEMEQ("fileset", tag, len)) {
@@ skipping 35 matching lines @@
                                             const XML_Char *entityName,
                                             int is_parameter_entity,
                                             const XML_Char *value,
                                             int value_length,
                                             const XML_Char *base,
                                             const XML_Char *systemId,
                                             const XML_Char *publicId,
                                             const XML_Char *notationName)
 {
     FamilyData* self = static_cast<FamilyData*>(data);
-    SkDebugf("Entity declaration %s found, stopping processing.", entityName);
+    SK_FONTCONFIGPARSER_WARNING("'%s' entity declaration found, stopping processing", entityName);
     XML_StopParser(self->fParser, XML_FALSE);
 }
 
 static const XML_Memory_Handling_Suite sk_XML_alloc = {
     sk_malloc_throw,
     sk_realloc_throw,
     sk_free
 };
 
 template<typename T> struct remove_ptr {typedef T type;};
 template<typename T> struct remove_ptr<T*> {typedef T type;};
 
 /**
  * This function parses the given filename and stores the results in the given
  * families array. Returns the version of the file, negative if the file does not exist.
  */
 static int parse_config_file(const char* filename, SkTDArray<FontFamily*>& families,
                              const SkString& basePath, bool isFallback)
 {
     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("File %s could not be opened.\n", filename);
+        SkDebugf(SK_FONTCONFIGPARSER_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));
     if (!parser) {
-        SkDebugf("Could not create XML parser.\n");
+        SkDebugf(SK_FONTCONFIGPARSER_PREFIX "could not create XML parser\n");
         return -1;
     }
 
-    FamilyData self(parser, families, basePath, isFallback);
+    FamilyData self(parser, families, basePath, isFallback, filename);
     XML_SetUserData(parser, &self);
 
     // Disable entity processing, to inhibit internal entity expansion. See expat CVE-2013-0340
     XML_SetEntityDeclHandler(parser, xml_entity_decl_handler);
 
     // Start parsing oldschool; switch these in flight if we detect a newer version of the file.
     XML_SetElementHandler(parser, jbParser::start_element_handler, jbParser::end_element_handler);
 
     // One would assume it would be faster to have a buffer on the stack and call XML_Parse.
     // But XML_Parse will call XML_GetBuffer anyway and memmove the passed buffer into it.
     // (Unless XML_CONTEXT_BYTES is undefined, but all users define it.)
     // In debug, buffer a small odd number of bytes to detect slicing in XML_CharacterDataHandler.
     static const int bufferSize = 512 SkDEBUGCODE( - 507);
     bool done = false;
     while (!done) {
         void* buffer = XML_GetBuffer(parser, bufferSize);
         if (!buffer) {
-            SkDebugf("Could not buffer enough to continue.\n");
+            SkDebugf(SK_FONTCONFIGPARSER_PREFIX "could not buffer enough to continue\n");
             return -1;
         }
         size_t len = file.read(buffer, bufferSize);
         done = file.isAtEnd();
         XML_Status status = XML_ParseBuffer(parser, len, done);
         if (XML_STATUS_ERROR == status) {
             XML_Error error = XML_GetErrorCode(parser);
             int line = XML_GetCurrentLineNumber(parser);
             int column = XML_GetCurrentColumnNumber(parser);
-            int index = XML_GetCurrentByteIndex(parser);
             const XML_LChar* errorString = XML_ErrorString(error);
-            SkDebugf("Line: %d Column: %d (Offset: %d) Error %d: %s.\n",
-                          line,    column,      index,    error, errorString);
+            SkDebugf(SK_FONTCONFIGPARSER_PREFIX "%s:%d:%d error %d: %s.\n",
+                     filename, line, column, error, errorString);
             return -1;
         }
     }
     return self.fVersion;
 }
 
 /** Returns the version of the system font file actually found, negative if none. */
 static int append_system_font_families(SkTDArray<FontFamily*>& fontFamilies,
                                        const SkString& basePath)
 {
@@ skipping 141 matching lines @@
     const char* tag = fTag.c_str();
 
     // strip off the rightmost "-.*"
     const char* parentTagEnd = strrchr(tag, '-');
     if (parentTagEnd == NULL) {
         return SkLanguage();
     }
     size_t parentTagLen = parentTagEnd - tag;
     return SkLanguage(tag, parentTagLen);
 }