Font variations.

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"
 #include "SkTDArray.h"
 #include "SkTSearch.h"
 #include "SkTypeface.h"
 
 #include <expat.h>
 #include <dirent.h>
-#include <stdio.h>
 
-#include <limits>
 #include <stdlib.h>
 
 #define LMP_SYSTEM_FONTS_FILE "/system/etc/fonts.xml"
 #define OLD_SYSTEM_FONTS_FILE "/system/etc/system_fonts.xml"
 #define FALLBACK_FONTS_FILE "/system/etc/fallback_fonts.xml"
 #define VENDOR_FONTS_FILE "/vendor/etc/fallback_fonts.xml"
 
 #define LOCALE_FALLBACK_FONTS_SYSTEM_DIR "/system/etc"
 #define LOCALE_FALLBACK_FONTS_VENDOR_DIR "/vendor/etc"
 #define LOCALE_FALLBACK_FONTS_PREFIX "fallback_fonts-"
@@ skipping 74 matching lines @@
     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.
 };
 
-/** 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;
-    const T dMax = std::numeric_limits<T>::max() - (nMax * 10);
-    T n = 0;
-    for (; *s; ++s) {
-        // Check if digit
-        if (*s < '0' || '9' < *s) {
-            return false;
-        }
-        int d = *s - '0';
-        // Check for overflow
-        if (n > nMax || (n == nMax && d > dMax)) {
-            return false;
-        }
-        n = (n * 10) + d;
-    }
-    *value = n;
-    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( \
@@ skipping 17 matching lines @@
         while (is_whitespace(*end)) { --end; }
         ++end;  // make end exclusive
     }
     size_t len = end - start;
     memmove(str, start, len);
     s->resize(len);
 }
 
 namespace lmpParser {
 
+static const TagHandler axisHandler = {
+    /*start*/[](FamilyData* self, const char* tag, const char** attributes) {
+        FontFileInfo& file = *self->fCurrentFontInfo;
+        FontFileInfo::Axis& axis = file.fAxes.push_back();
+        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("tag", name, nameLen)) {
+                size_t valueLen = strlen(value);
+                if (valueLen == 4) {
+                    SkFourByteTag tag = SkSetFourByteTag(value[0], value[1], value[2], value[3]);
+                    for (int j = 0; j < file.fAxes.count() - 1; ++j) {
+                        if (file.fAxes[j].fTag == tag) {
+                            SK_FONTCONFIGPARSER_WARNING("'%c%c%c%c' axis specified more than once",
+                                                        (tag >> 24) & 0xFF,
+                                                        (tag >> 16) & 0xFF,
+                                                        (tag >>  8) & 0xFF,
+                                                        (tag      ) & 0xFF);
+                        }
+                    }
+                    axis.fTag = SkSetFourByteTag(value[0], value[1], value[2], value[3]);
+                } 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,
+};
+
 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;
         for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
             const char* name = attributes[i];
@@ skipping 13 matching lines @@
             } else if (MEMEQ("index", name, nameLen)) {
                 if (!parse_non_negative_integer(value, &file.fIndex)) {
                     SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid index", value);
                 }
             }
         }
     },
     /*end*/[](FamilyData* self, const char* tag) {
         trim_string(&self->fCurrentFontInfo->fFileName);
     },
-    /*tag*/NULL,
+    /*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;
+    },
     /*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]
         // 'lang' (string) [default ""]
@@ skipping 552 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);
 }