SkFontMgr_android_parser.h File Reference

#include "include/core/SkFontArguments.h"
#include "include/core/SkFontMgr.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTDArray.h"
#include "src/core/SkTHash.h"
#include <climits>
#include <limits>

Go to the source code of this file.

Classes
class	SkLanguage
struct	FontFileInfo
struct	FontFamily

Namespaces
namespace	SkFontMgr_Android_Parser

Typedefs
typedef uint32_t	FontVariant

Enumerations
enum	FontVariants { kDefault_FontVariant = 0x01 , kCompact_FontVariant = 0x02 , kElegant_FontVariant = 0x04 , kLast_FontVariant = kElegant_FontVariant }

Functions
void	SkFontMgr_Android_Parser::GetSystemFontFamilies (SkTDArray< FontFamily * > &fontFamilies)
void	SkFontMgr_Android_Parser::GetCustomFontFamilies (SkTDArray< FontFamily * > &fontFamilies, const SkString &basePath, const char *fontsXml, const char *fallbackFontsXml, const char *langFallbackFontsDir=nullptr)
template<typename T >
bool	parse_non_negative_integer (const char *s, T *value)
template<int N, typename T >
bool	parse_fixed (const char *s, T *value)

Typedef Documentation

FontVariant

typedef uint32_t FontVariant

Definition at line 65 of file SkFontMgr_android_parser.h.

Enumeration Type Documentation

FontVariants

enum FontVariants

Enumerator
kDefault_FontVariant
kCompact_FontVariant
kElegant_FontVariant
kLast_FontVariant

Definition at line 59 of file SkFontMgr_android_parser.h.

                  {
   kDefault_FontVariant = 0x01,
   kCompact_FontVariant = 0x02,
   kElegant_FontVariant = 0x04,
   kLast_FontVariant = kElegant_FontVariant,
};

Function Documentation

parse_fixed()

template<int N, typename T >

bool parse_fixed	(	const char *	s,
		T *	value
	)

Parses a null terminated string into a signed fixed point value with bias N.

Like http://www.w3.org/TR/html-markup/datatypes.html#common.data.float-def , but may start with '.' and does not support 'e'. '-?((:digit:+(.:digit:+)?)|(.:digit:+))'

Checks for overflow. Low bit rounding is not defined (is currently truncate). Bias (N) required to allow for the sign bit and 4 bits of integer.

If the string cannot be parsed into 'value', returns false and does not change 'value'.

Definition at line 162 of file SkFontMgr_android_parser.h.

                                                                       {
    static_assert(std::numeric_limits<T>::is_integer, "T_must_be_integer");
    static_assert(std::numeric_limits<T>::is_signed, "T_must_be_signed");
    static_assert(sizeof(T) * CHAR_BIT - N >= 5, "N_must_leave_four_bits_plus_sign");
 
    bool negate = false;
    if (*s == '-') {
        ++s;
        negate = true;
    }
    if (*s == '\0') {
        return false;
    }
 
    const T nMax = (std::numeric_limits<T>::max() >> N) / 10;
    const T dMax = (std::numeric_limits<T>::max() >> N) - (nMax * 10);
    T n = 0;
    T frac = 0;
    for (; *s; ++s) {
        // Check if digit
        if (*s < '0' || '9' < *s) {
            // If it wasn't a digit, check if it is a '.' followed by something.
            if (*s != '.' || s[1] == '\0') {
                return false;
            }
            // Find the end, verify digits.
            for (++s; *s; ++s) {
                if (*s < '0' || '9' < *s) {
                    return false;
                }
            }
            // Read back toward the '.'.
            for (--s; *s != '.'; --s) {
                T d = *s - '0';
                frac = (frac + (d << N)) / 10; // This requires four bits overhead.
            }
            break;
        }
        T d = *s - '0';
        // Check for overflow
        if (n > nMax || (n == nMax && d > dMax)) {
            return false;
        }
        n = (n * 10) + d;
    }
    if (negate) {
        n = -n;
        frac = -frac;
    }
    *value = SkLeftShift(n, N) + frac;
    return true;
}

parse_non_negative_integer()

template<typename T >

bool parse_non_negative_integer	(	const char *	s,
		T *	value
	)

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'.

Definition at line 125 of file SkFontMgr_android_parser.h.

                                                                               {
    static_assert(std::numeric_limits<T>::is_integer, "T_must_be_integer");
 
    if (*s == '\0') {
        return false;
    }
 
    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;
        }
        T d = *s - '0';
        // Check for overflow
        if (n > nMax || (n == nMax && d > dMax)) {
            return false;
        }
        n = (n * 10) + d;
    }
    *value = n;
    return true;
}