gosu 1.4.6 → 2.0.0.pre6

data/src/TransformStack.hpp

@@ -14,7 +14,7 @@ namespace Gosu
         Transforms absolute;
         // Points to one absolute transform.
         Transforms::const_iterator current_iterator;
-        
+
         void make_current(const Transform& transform)
         {
             current_iterator = std::find(absolute.begin(), absolute.end(), transform);
@@ -22,12 +22,12 @@ namespace Gosu
                 current_iterator = absolute.insert(absolute.end(), transform);
             }
         }
-        
+
     public:
         TransformStack()
         {
             reset();
-            individual.front() = absolute.front() = scale(1);
+            individual.front() = absolute.front() = Transform::scale(1);
         }
 
         void reset()
@@ -39,18 +39,18 @@ namespace Gosu
             absolute.resize(1);
             current_iterator = absolute.begin();
         }
-        
+
         TransformStack(const TransformStack& other)
         {
             *this = other;
         }
-        
+
         // Custom assignment to ensure valid current_iterator
         TransformStack& operator=(const TransformStack& other)
         {
             individual = other.individual;
             absolute = other.absolute;
-            
+
             // Reset our current_iterator to point to the respective element
             // in our own 'absolute' transforms by iterating both lists up to
             // the other lists' current iterator
@@ -60,39 +60,39 @@ namespace Gosu
                 ++current_iterator;
                 ++other_iterator;
             }
-            
+
             return *this;
         }
-        
+
         void set_base_transform(const Transform& base_transform)
         {
             assert (individual.size() == 1);
             assert (absolute.size() == 1);
-            
+
             individual.front() = absolute.front() = base_transform;
         }
-        
+
         const Transform& current()
         {
             return *current_iterator;
         }
-        
+
         void push(const Transform& transform)
         {
             individual.push_back(transform);
-            Transform result = concat(transform, current());
+            Transform result = transform * current();
             make_current(result);
         }
-        
+
         void pop()
         {
             assert (individual.size() > 1);
-            
+
             individual.pop_back();
-            Transform result = scale(1);
+            Transform result = Transform::scale(1);
             for (Transforms::reverse_iterator it = individual.rbegin(),
                     end = individual.rend(); it != end; ++it)
-                result = concat(result, *it);
+                result = result *  *it;
             make_current(result);
         }
     };

data/src/TrueTypeFont.cpp

@@ -1,9 +1,10 @@
 #include "TrueTypeFont.hpp"
-#include <Gosu/IO.hpp>
+#include <Gosu/Buffer.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
 #include <algorithm>
 #include <map>
+#include <mutex>
 #include <stdexcept>
 
 #define STB_TRUETYPE_IMPLEMENTATION
@@ -11,23 +12,25 @@
 
 struct Gosu::TrueTypeFont::Impl : private Gosu::Noncopyable
 {
-    stbtt_fontinfo info{};
+    stbtt_fontinfo info {};
     std::shared_ptr<TrueTypeFont> fallback;
 
     // The height of the ascent in internal font metrics (an arbitrary integer scale). The ascent is
     // the part of the font above the baseline (which TrueType considers to be at y = 0).
-    int ascent{};
+    int ascent = 0;
 
     // Scaling factor from internal font metrics (an arbitrary integer scale) to a font with
     // height = 1px.
     double base_scale;
 
-    Impl(const unsigned char* ttf_data, std::shared_ptr<TrueTypeFont> fallback)
-    : fallback{move(fallback)}
+    Impl(const std::uint8_t* ttf_data, std::shared_ptr<TrueTypeFont> fallback)
+        : fallback(std::move(fallback))
     {
         auto offset = stbtt_GetFontOffsetForIndex(ttf_data, 0);
         int success = stbtt_InitFont(&info, ttf_data, offset);
-        if (!success) throw std::runtime_error{"Invalid TrueType font data"};
+        if (!success) {
+            throw std::runtime_error("Invalid TrueType font data");
+        }
 
         // Calculate metrics.
         int descent, line_gap;
@@ -40,7 +43,9 @@ struct Gosu::TrueTypeFont::Impl : private Gosu::Noncopyable
     double draw_text(const std::u32string& text, bool is_end, double height, Bitmap* bitmap,
                      double x, double y, Color c)
     {
-        if (text.empty()) return 0;
+        if (text.empty()) {
+            return 0;
+        }
 
         // The 'x' parameter is used as the running cursor variable in this method.
 
@@ -51,7 +56,9 @@ struct Gosu::TrueTypeFont::Impl : private Gosu::Noncopyable
         for (std::size_t index = 0; index < text.size(); ++index) {
             auto codepoint = text[index];
             // Silently skip control characters, including the \r in Windows-style line breaks.
-            if (codepoint < ' ') continue;
+            if (codepoint < ' ') {
+                continue;
+            }
 
             int glyph = stbtt_FindGlyphIndex(&info, static_cast<int>(codepoint));
             // Handle missing characters in this font...
@@ -98,10 +105,11 @@ struct Gosu::TrueTypeFont::Impl : private Gosu::Noncopyable
             float fscale = static_cast<float>(scale);
             int last_xoff, last_width;
             // TODO: Don't allocate a buffer just to get metrics!
-            std::shared_ptr<unsigned char> unused_data{
-                    stbtt_GetGlyphBitmapSubpixel(&info, fscale, fscale, shift_x, 0, last_glyph,
-                                                 &last_width, nullptr, &last_xoff, nullptr),
-                    std::free};
+            std::shared_ptr<std::uint8_t> unused_data {
+                stbtt_GetGlyphBitmapSubpixel(&info, fscale, fscale, shift_x, 0, last_glyph,
+                                             &last_width, nullptr, &last_xoff, nullptr),
+                std::free
+            };
             // Move the cursor to the right if pixels have been touched by draw_glyph that are
             // to the right of the current cursor.
             // If the last character extends to the right of the cursor, then this prevents the
@@ -144,16 +152,16 @@ struct Gosu::TrueTypeFont::Impl : private Gosu::Noncopyable
         int w, h, xoff, yoff;
         // As an optimization, this method/class could try to re-use a buffer for rasterization
         // instead of having stb_truetype allocate a fresh one for each draw_glyph call.
-        std::shared_ptr<unsigned char> pixels{stbtt_GetGlyphBitmapSubpixel(&info, fscale, fscale,
-                                                                           shift_x, shift_y, glyph,
-                                                                           &w, &h, &xoff, &yoff),
-                                              std::free};
+        std::shared_ptr<std::uint8_t> pixels(stbtt_GetGlyphBitmapSubpixel(&info, fscale, fscale, //
+                                                                          shift_x, shift_y, glyph,
+                                                                          &w, &h, &xoff, &yoff),
+                                             std::free);
 
         int target_y = static_cast<int>(y + ascent * scale + yoff);
         blend_into_bitmap(bitmap, pixels.get(), x + xoff, target_y, w, h, c);
     }
 
-    static void blend_into_bitmap(Bitmap& bitmap, const unsigned char* pixels, //
+    static void blend_into_bitmap(Bitmap& bitmap, const std::uint8_t* pixels, //
                                   int x, int y, int w, int h, Color c)
     {
         int stride = w;
@@ -188,9 +196,9 @@ struct Gosu::TrueTypeFont::Impl : private Gosu::Noncopyable
     }
 };
 
-Gosu::TrueTypeFont::TrueTypeFont(const unsigned char* ttf_data,
+Gosu::TrueTypeFont::TrueTypeFont(const std::uint8_t* ttf_data,
                                  std::shared_ptr<TrueTypeFont> fallback)
-: m_impl{new Impl(ttf_data, std::move(fallback))}
+    : m_impl(new Impl(ttf_data, std::move(fallback)))
 {
 }
 
@@ -200,31 +208,33 @@ double Gosu::TrueTypeFont::draw_text(const std::u32string& text, double height,
     return m_impl->draw_text(text, true, height, bitmap, x, y, c);
 }
 
-bool Gosu::TrueTypeFont::matches(const unsigned char* ttf_data, const std::string& font_name,
+bool Gosu::TrueTypeFont::matches(const std::uint8_t* ttf_data, const std::string& font_name,
                                  unsigned font_flags)
 {
     // Gosu::FontFlags uses the same values as the STBTT_ macros, except for this one.
     int flags = (font_flags == 0 ? STBTT_MACSTYLE_NONE : static_cast<int>(font_flags));
 
-    return stbtt_FindMatchingFont(ttf_data, font_name.c_str(), flags) >= 0 ||
-           stbtt_FindMatchingFont(ttf_data, font_name.c_str(), STBTT_MACSTYLE_DONTCARE) >= 0;
+    return stbtt_FindMatchingFont(ttf_data, font_name.c_str(), flags) >= 0
+        || stbtt_FindMatchingFont(ttf_data, font_name.c_str(), STBTT_MACSTYLE_DONTCARE) >= 0;
 }
 
-static Gosu::TrueTypeFont& font_with_stack(std::vector<const unsigned char*> ttf_stack)
+static Gosu::TrueTypeFont& font_with_stack(std::vector<const std::uint8_t*> ttf_stack)
 {
-    // TODO: Make this cache thread-safe.
-    static std::map<const unsigned char*, std::shared_ptr<Gosu::TrueTypeFont>> cache_by_data;
+    static std::map<const std::uint8_t*, std::shared_ptr<Gosu::TrueTypeFont>> cache_by_data;
+    static std::recursive_mutex mutex;
+    std::scoped_lock lock(mutex);
 
-    // Filter out any fonts that could not be found, as well as duplicates.
-    auto end = unique(ttf_stack.begin(), ttf_stack.end());
-    end = remove(ttf_stack.begin(), end, nullptr);
-    ttf_stack.erase(end, ttf_stack.end());
+    // Filter out any fonts that could not be found, as well as (adjacent) duplicates.
+    ttf_stack.erase(std::remove(ttf_stack.begin(), ttf_stack.end(), nullptr), ttf_stack.end());
+    ttf_stack.erase(std::unique(ttf_stack.begin(), ttf_stack.end()), ttf_stack.end());
 
     // This cannot happen because ttf_stack contains ttf_fallback_data(), which never returns null.
-    if (ttf_stack.empty()) throw std::logic_error{"Empty font stack"};
+    if (ttf_stack.empty()) {
+        throw std::logic_error("Empty font stack");
+    }
 
     std::shared_ptr<Gosu::TrueTypeFont> head_of_stack = nullptr;
-    for (const unsigned char* ttf_data : ttf_stack) {
+    for (const std::uint8_t* ttf_data : ttf_stack) {
         auto& font_ptr = cache_by_data[ttf_data];
         if (!font_ptr) {
             font_ptr = std::make_shared<Gosu::TrueTypeFont>(ttf_data, head_of_stack);
@@ -236,17 +246,20 @@ static Gosu::TrueTypeFont& font_with_stack(std::vector<const unsigned char*> ttf
 
 Gosu::TrueTypeFont& Gosu::font_by_name(const std::string& font_name, unsigned font_flags)
 {
-    // TODO: Make this cache thread-safe.
     static std::map<std::pair<std::string, unsigned>, TrueTypeFont*> cache_by_name_and_flags;
+    static std::recursive_mutex mutex;
+    std::scoped_lock lock(mutex);
 
     auto& font_ptr = cache_by_name_and_flags[make_pair(font_name, font_flags)];
     if (!font_ptr) {
         // Build a stack of TTF data in order of preference, where the fallback font is at the
         // front, and the desired font with all the right font flags (most preferable) at the back.
-        std::vector<const unsigned char*> ttf_stack;
+        std::vector<const std::uint8_t*> ttf_stack;
         ttf_stack.push_back(ttf_fallback_data());
         ttf_stack.push_back(ttf_data_by_name(default_font_name(), 0));
-        if (font_flags != 0) ttf_stack.push_back(ttf_data_by_name(default_font_name(), font_flags));
+        if (font_flags != 0) {
+            ttf_stack.push_back(ttf_data_by_name(default_font_name(), font_flags));
+        }
 
         if (font_name.find_first_of("./\\") != std::string::npos) {
             // A filename? Load it and add it to the stack.
@@ -255,30 +268,25 @@ Gosu::TrueTypeFont& Gosu::font_by_name(const std::string& font_name, unsigned fo
         else if (font_name != default_font_name()) {
             // A font name? Add it to the stack, both with font_flags and without.
             ttf_stack.push_back(ttf_data_by_name(font_name, 0));
-            if (font_flags != 0) ttf_stack.push_back(ttf_data_by_name(font_name, font_flags));
+            if (font_flags != 0) {
+                ttf_stack.push_back(ttf_data_by_name(font_name, font_flags));
+            }
         }
 
-        font_ptr = &font_with_stack(move(ttf_stack));
+        font_ptr = &font_with_stack(std::move(ttf_stack));
     }
 
     return *font_ptr;
 }
 
-const unsigned char* Gosu::ttf_data_from_file(const std::string& filename)
+const std::uint8_t* Gosu::ttf_data_from_file(const std::string& filename)
 {
-    // TODO: Make this cache thread-safe.
-    static std::map<std::string, std::shared_ptr<Buffer>> ttf_file_cache;
-
-    auto& buffer_ptr = ttf_file_cache[filename];
-    if (!buffer_ptr) {
-        buffer_ptr = std::make_shared<Buffer>();
-        try {
-            load_file(*buffer_ptr, filename);
-        } catch (...) {
-            // Prevent partially loaded files from getting stuck in the cache.
-            buffer_ptr = nullptr;
-            throw;
-        }
+    static std::map<std::string, Buffer> ttf_file_cache;
+    static std::recursive_mutex mutex;
+    std::scoped_lock lock(mutex);
+
+    if (!ttf_file_cache.contains(filename)) {
+        ttf_file_cache.emplace(filename, load_file(filename));
     }
-    return static_cast<const unsigned char*>(buffer_ptr->data());
+    return ttf_file_cache.at(filename).data();
 }

data/src/TrueTypeFont.hpp

@@ -1,11 +1,10 @@
 #pragma once
 
 #include <Gosu/Bitmap.hpp>
-#include <Gosu/IO.hpp>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace Gosu
 {
@@ -16,7 +15,7 @@ namespace Gosu
 
     public:
         /// The caller must ensure that the ttf_data pointer will outlive this object.
-        TrueTypeFont(const unsigned char* ttf_data, std::shared_ptr<TrueTypeFont> fallback);
+        TrueTypeFont(const std::uint8_t* ttf_data, std::shared_ptr<TrueTypeFont> fallback);
 
         /// Returns the right edge of a string when rendered onto a bitmap at the given position,
         /// and with the given height.
@@ -25,7 +24,7 @@ namespace Gosu
                          Bitmap* bitmap, double x, double y, Color c);
 
         /// Returns true if the supplied buffer seems to be a font of the given name.
-        static bool matches(const unsigned char* ttf_data, //
+        static bool matches(const std::uint8_t* ttf_data, //
                             const std::string& font_name, unsigned font_flags);
     };
 
@@ -49,15 +48,15 @@ namespace Gosu
     /// 3. As a last resort, Gosu could implement faux bold and faux italics. I think faux
     ///    underlines are a must anyway, since no font provides a dedicated TTF file for that.
     /// These options are not mutually exclusive.
-    const unsigned char* ttf_data_from_file(const std::string& filename);
+    const std::uint8_t* ttf_data_from_file(const std::string& filename);
 
     /// This method loads a system font with the given flags.
     /// This method has a different implementation on each platform.
     /// In case of failure, this method returns nullptr.
-    const unsigned char* ttf_data_by_name(const std::string& font_name, unsigned font_flags);
+    const std::uint8_t* ttf_data_by_name(const std::string& font_name, unsigned font_flags);
 
     /// Returns the TTF data of a font that supports as many glyphs as possible.
     /// This method has a different implementation on each platform.
     /// In case of failure, this method must not return nullptr, but raise an exception.
-    const unsigned char* ttf_fallback_data();
+    const std::uint8_t* ttf_fallback_data();
 }

data/src/TrueTypeFontApple.cpp

@@ -2,50 +2,55 @@
 #if defined(GOSU_IS_MAC)
 
 #include <Gosu/Text.hpp>
-#include "Log.hpp"
 #include "TrueTypeFont.hpp"
 #include <CoreText/CoreText.h>
 #include <Foundation/Foundation.h>
 #include <map>
 
-const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
+const std::uint8_t* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
 {
-    // TODO: Make this cache thread-safe.
-    static std::map<std::pair<std::string, unsigned>, const unsigned char*> ttf_file_cache;
+    static std::map<std::pair<std::string, unsigned>, const std::uint8_t*> ttf_file_cache;
+    static std::recursive_mutex mutex;
+    std::scoped_lock lock(mutex);
 
     auto& ttf_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
-    if (ttf_ptr) return ttf_ptr;
-
-    log("Trying to find a font named '%s', flags=%x", font_name.c_str(), font_flags);
+    if (ttf_ptr) {
+        return ttf_ptr;
+    }
 
     unsigned symbolic_traits = 0;
-    if (font_flags & Gosu::FF_BOLD) symbolic_traits |= kCTFontTraitBold;
-    if (font_flags & Gosu::FF_ITALIC) symbolic_traits |= kCTFontTraitItalic;
+    if (font_flags & Gosu::FF_BOLD) {
+        symbolic_traits |= kCTFontTraitBold;
+    }
+    if (font_flags & Gosu::FF_ITALIC) {
+        symbolic_traits |= kCTFontTraitItalic;
+    }
 
     NSDictionary* attributes = @{
-        ((__bridge id) kCTFontNameAttribute): [NSString stringWithUTF8String:font_name.c_str()],
-        ((__bridge id) kCTFontTraitsAttribute):
-                @{((__bridge id) kCTFontSymbolicTrait): @(symbolic_traits)}
+        ((__bridge id)kCTFontNameAttribute) : [NSString stringWithUTF8String:font_name.c_str()],
+        ((__bridge id)kCTFontTraitsAttribute) :
+            @ { ((__bridge id)kCTFontSymbolicTrait) : @(symbolic_traits) }
     };
     CTFontDescriptorRef descriptor =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
-            CTFontDescriptorCreateWithAttributes((__bridge CFDictionaryRef) attributes);
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
+        CTFontDescriptorCreateWithAttributes((__bridge CFDictionaryRef)attributes);
 
     if (descriptor) {
         CTFontRef font = CTFontCreateWithFontDescriptorAndOptions(descriptor, 20, nullptr, 0);
         if (font) {
+            // GCOV_EXCL_START: This does not seem to happen anymore on recent macOS versions.
             if ((CTFontGetSymbolicTraits(font) & symbolic_traits) != symbolic_traits) {
                 // For some reason the initial call to CTFontCreateWithFontDescriptorAndOptions does
                 // not respect the requested font traits. Explicitly requesting the traits again
                 // seems to help. Tested on macOS 11.2.2.
                 CTFontRef correct_font = CTFontCreateCopyWithSymbolicTraits(
-                        font, 0.0, nullptr, symbolic_traits, symbolic_traits);
+                    font, 0.0, nullptr, symbolic_traits, symbolic_traits);
                 CFRelease(font);
                 font = correct_font;
             }
+            // GCOV_EXCL_END
             NSURL* url = CFBridgingRelease(CTFontCopyAttribute(font, kCTFontURLAttribute));
             if (url && url.fileSystemRepresentation) {
-                log("Loading file '%s'", url.fileSystemRepresentation);
                 ttf_ptr = ttf_data_from_file(url.fileSystemRepresentation);
             }
             CFRelease(font);
@@ -56,13 +61,17 @@ const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsign
     return ttf_ptr;
 }
 
-const unsigned char* Gosu::ttf_fallback_data()
+const std::uint8_t* Gosu::ttf_fallback_data()
 {
     // Prefer Arial Unicode MS as a fallback because it covers a lot of Unicode.
-    static const unsigned char* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
-    if (arial_unicode) return arial_unicode;
+    static const std::uint8_t* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
+    if (arial_unicode) {
+        return arial_unicode;
+    }
 
+    // GCOV_EXCL_START: We do not want to delete system fonts in order to test this line.
     return ttf_data_from_file("/Library/Fonts/Arial.ttf");
+    // GCOV_EXCL_END
 }
 
 std::string Gosu::default_font_name()

data/src/TrueTypeFontUnix.cpp

@@ -1,23 +1,23 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_X)
 
-#include <Gosu/IO.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
-#include "Log.hpp"
 #include "TrueTypeFont.hpp"
 #include <fontconfig/fontconfig.h>
 #include <map>
+#include <mutex>
 
-const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
+const std::uint8_t* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
 {
-    // TODO: Make this cache thread-safe.
-    static std::map<std::pair<std::string, unsigned>, const unsigned char*> ttf_file_cache;
+    static std::map<std::pair<std::string, unsigned>, const std::uint8_t*> ttf_file_cache;
+    static std::recursive_mutex mutex;
+    std::scoped_lock lock(mutex);
 
     auto& ttf_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
-    if (ttf_ptr) return ttf_ptr;
-
-    log("Trying to find a font named '%s', flags=%x", font_name.c_str(), font_flags);
+    if (ttf_ptr) {
+        return ttf_ptr;
+    }
 
     static FcConfig* config = FcInitLoadConfigAndFonts();
     if (config) {
@@ -31,8 +31,6 @@ const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsign
         FcObjectSet* props = FcObjectSetBuild(FC_FILE, FC_WEIGHT, FC_SLANT, nullptr);
 
         if (FcFontSet* fonts = FcFontList(config, pattern, props)) {
-            log("Looking for the best candidate among %d matching fonts", (int) fonts->nfont);
-
             // Among all matching fonts, find the variant that is the best fit for our font_flags.
             std::string best_filename;
             int best_diff;
@@ -72,7 +70,6 @@ const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsign
                 }
             }
             if (!best_filename.empty()) {
-                log("Loading best candidate '%s'", best_filename.c_str());
                 ttf_ptr = ttf_data_from_file(best_filename.c_str());
             }
 
@@ -86,9 +83,9 @@ const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsign
     return ttf_ptr;
 }
 
-static const unsigned char* ttf_data_of_default_sans_serif_font()
+static const std::uint8_t* ttf_data_of_default_sans_serif_font()
 {
-    const unsigned char* ttf_ptr = nullptr;
+    const std::uint8_t* ttf_ptr = nullptr;
 
     // At this point, we already have an open FcConfig, and can pass nullptr to these functions.
     FcPattern* pattern = FcNameParse(reinterpret_cast<const FcChar8*>("sans-serif"));
@@ -99,7 +96,6 @@ static const unsigned char* ttf_data_of_default_sans_serif_font()
     if (match_result == FcResultMatch) {
         FcChar8* filename;
         if (FcPatternGetString(pattern, FC_FILE, 0, &filename) == FcResultMatch) {
-            Gosu::log("Found the default sans-serif font: '%s'", filename);
             ttf_ptr = Gosu::ttf_data_from_file(reinterpret_cast<char*>(filename));
         }
     }
@@ -108,24 +104,32 @@ static const unsigned char* ttf_data_of_default_sans_serif_font()
     return ttf_ptr;
 }
 
-const unsigned char* Gosu::ttf_fallback_data()
+const std::uint8_t* Gosu::ttf_fallback_data()
 {
     // Prefer Arial Unicode MS as a fallback because it covers a lot of Unicode in a single file.
     // This is also the fallback font on Windows and macOS.
-    static const unsigned char* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
-    if (arial_unicode) return arial_unicode;
+    static const std::uint8_t* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
+    if (arial_unicode) {
+        return arial_unicode;
+    }
 
     // DejaVu has at least some Unicode coverage (though no CJK).
-    static const unsigned char* deja_vu = ttf_data_by_name("DejaVu", 0);
-    if (deja_vu) return deja_vu;
+    static const std::uint8_t* deja_vu = ttf_data_by_name("DejaVu", 0);
+    if (deja_vu) {
+        return deja_vu;
+    }
 
     // Unifont has pretty good Unicode coverage, but looks extremely ugly.
-    static const unsigned char* unifont = ttf_data_by_name("Unifont", 0);
-    if (unifont) return unifont;
+    static const std::uint8_t* unifont = ttf_data_by_name("Unifont", 0);
+    if (unifont) {
+        return unifont;
+    }
 
     // If none of the fonts above work, try to use the default sans-serif font.
-    static const unsigned char* default_font = ttf_data_of_default_sans_serif_font();
-    if (default_font) return default_font;
+    static const std::uint8_t* default_font = ttf_data_of_default_sans_serif_font();
+    if (default_font) {
+        return default_font;
+    }
 
     // If nothing else works, try to load a file from this hardcoded path.
     return ttf_data_from_file("/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf");