Use std::filesystem for paths

Signed-off-by: Artem Senichev <artemsen@gmail.com>

Author: artemsen

README.md

@@ -15,7 +15,7 @@ List of supported distributives can be found on the [Repology page](https://repo
 ## Build
 
 To build the project you will need:
-- C++ compiler with support for the C++11 standard;
+- C++ compiler with support for the C++20 standard;
 - Meson build system;
 - SDL3 library.
 

meson.build

@@ -5,7 +5,7 @@ project(
     'cpp',
     default_options: [
         'warning_level=3',
-        'cpp_std=c++11',
+        'cpp_std=c++20',
         'buildtype=release',
     ],
     license: 'MIT',

src/game.cpp

@@ -159,7 +159,7 @@ void Game::save(State& state) const
     state.level_height = level.height;
     state.level_wrap = level.wrap;
     state.level_pipes = level.save();
-    state.skin = skin.name;
+    state.skin = skin.name();
     state.sound = sound.enable;
 }
 
@@ -335,8 +335,8 @@ void Game::draw_settings()
     render.draw_text(skin_label, font_sz,
                      layout.skinprev->x + layout.skinprev->w,
                      layout.skinprev->y);
-    width = render.text_width(skin.name.c_str(), font_sz);
-    render.draw_text(skin.name.c_str(), font_sz,
+    width = render.text_width(skin.name().c_str(), font_sz);
+    render.draw_text(skin.name().c_str(), font_sz,
                      layout.window.w / 2 - width / 2,
                      layout.skinprev->y + layout.skinprev->h * 1.2);
     render.draw(Render::ButtonPrev, layout.skinprev);

src/skin.cpp

@@ -21,17 +21,20 @@
 static SDL_Surface* load_png(const char* path)
 {
     int width, height, channels;
-    uint8_t* data = stbi_load(path, &width, &height, &channels, 4);
+    using png_data = std::unique_ptr<uint8_t, decltype(&stbi_image_free)>;
+    png_data data(stbi_load(path, &width, &height, &channels, 4),
+                  stbi_image_free);
 
-    if (!data || width % 512 != 0 || height % 448 != 0 || channels != 4) {
-        stbi_image_free(data);
+    if (!data.get() || width % 512 != 0 || height % 448 != 0 || channels != 4) {
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Invalid skin format: %s", path);
         return nullptr;
     }
 
     SDL_Surface* tmp = SDL_CreateSurfaceFrom(
-        width, height, SDL_PIXELFORMAT_RGBA32, data, width * 4 /*RGBA*/);
+        width, height, SDL_PIXELFORMAT_RGBA32, data.get(), width * 4 /*RGBA*/);
     if (!tmp) {
-        stbi_image_free(data);
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Error creating skin surface: %s",
+                     SDL_GetError());
         return nullptr;
     }
 
@@ -42,7 +45,6 @@ static SDL_Surface* load_png(const char* path)
     }
 
     SDL_DestroySurface(tmp);
-    stbi_image_free(data);
     return surface;
 }
 
@@ -52,25 +54,26 @@ SDL_Surface* Skin::initialize(const std::string& name)
 
     if (!search(APP_DATADIR)) {
         // try portable variant
-        const char* app_dir = SDL_GetBasePath();
-        if (app_dir) {
-            std::string path = app_dir;
-            path += "data";
-            search(path);
-        }
+        std::filesystem::path path(SDL_GetBasePath());
+        path /= "data";
+        search(path);
     }
 
     // search for specified skin
-    for (size_t i = 0; i < available.size(); ++i) {
-        const std::string& path = available[i];
-        if (name == get_name(path)) {
+    for (size_t i = 0; i < skins.size(); ++i) {
+        if (name == skins[i].stem().string()) {
             image = load(i);
             break;
         }
     }
-    // fallback: load first available
-    for (size_t i = 0; !image && i < available.size(); ++i) {
-        image = load(i);
+    if (!image) {
+        // fallback: load first available
+        for (size_t i = 0; i < skins.size(); ++i) {
+            image = load(i);
+            if (image) {
+                break;
+            }
+        }
     }
 
     return image;
@@ -80,11 +83,11 @@ SDL_Surface* Skin::prev()
 {
     SDL_Surface* image = nullptr;
 
-    for (ssize_t i = current - 1; !image && i >= 0; --i) {
+    for (ssize_t i = skin_index - 1; !image && i >= 0; --i) {
         image = load(i);
     }
-    for (ssize_t i = available.size() - 1;
-         !image && i > static_cast<ssize_t>(current); --i) {
+    for (ssize_t i = skins.size() - 1;
+         !image && i > static_cast<ssize_t>(skin_index); --i) {
         image = load(i);
     }
 
@@ -95,10 +98,10 @@ SDL_Surface* Skin::next()
 {
     SDL_Surface* image = nullptr;
 
-    for (size_t i = current + 1; !image && i < available.size(); ++i) {
+    for (size_t i = skin_index + 1; !image && i < skins.size(); ++i) {
         image = load(i);
     }
-    for (size_t i = 0; !image && i < current; ++i) {
+    for (size_t i = 0; !image && i < skin_index; ++i) {
         image = load(i);
     }
 
@@ -107,30 +110,28 @@ SDL_Surface* Skin::next()
 
 SDL_Surface* Skin::load(size_t index)
 {
-    const std::string& path = available[index];
-    SDL_Surface* image = load_png(path.c_str());
+    const std::filesystem::path& path = skins[index];
+    SDL_Surface* image = load_png(path.string().c_str());
     if (image) {
-        name = get_name(path);
-        current = index;
+        skin_name = path.stem().string();
+        skin_index = index;
     }
     return image;
 }
 
-bool Skin::search(const std::string& path)
+bool Skin::search(const std::filesystem::path& dir)
 {
     int count;
-    char** files = SDL_GlobDirectory(path.c_str(), "*.png", 0, &count);
+    char** files = SDL_GlobDirectory(dir.string().c_str(), "*.png", 0, &count);
     for (int i = 0; i < count; ++i) {
-        const std::string skin_path = path + files[i];
-        available.push_back(skin_path);
+        std::filesystem::path path = dir / files[i];
+        skins.push_back(path);
     }
     SDL_free(files);
     return count > 0;
 }
 
-std::string Skin::get_name(const std::string& path) const
+const std::string& Skin::name() const
 {
-    const size_t dir_end = path.find_last_of("\\/") + 1;
-    const size_t ext_start = path.rfind('.');
-    return path.substr(dir_end, ext_start - dir_end);
+    return skin_name;
 }

src/skin.hpp

@@ -6,6 +6,7 @@
 
 #include <SDL3/SDL.h>
 
+#include <filesystem>
 #include <string>
 #include <vector>
 
@@ -31,15 +32,19 @@ class Skin {
      */
     SDL_Surface* next();
 
-    std::string name; ///< Skin name
+    /**
+     * Get current skin name.
+     * @return skin name
+     */
+    const std::string& name() const;
 
 private:
     /**
      * Search skin files in the specified directory.
      * @param dir path to directory with skin files (png)
      * @return true if at least one skin was found
      */
-    bool search(const std::string& dir);
+    bool search(const std::filesystem::path& dir);
 
     /**
      * Load skin.
@@ -48,13 +53,7 @@ class Skin {
      */
     SDL_Surface* load(size_t index);
 
-    /**
-     * Get skin name from file path.
-     * @param path path to the skin file
-     * @return skin name (file name without dir and extension)
-     */
-    std::string get_name(const std::string& path) const;
-
-    std::vector<std::string> available; ///< List of available skins
-    size_t current;                     ///< Index of the current skin
+    std::vector<std::filesystem::path> skins; ///< List of available skins
+    size_t skin_index;                        ///< Index of the current skin
+    std::string skin_name;                    ///< Name of the current skin
 };

src/sound.cpp

@@ -8,7 +8,7 @@
 
 #include <SDL3/SDL.h>
 
-#include <string>
+#include <cstring>
 
 // The only supported audio format
 constexpr const SDL_AudioSpec sound_spec = { SDL_AUDIO_S16, 2, 44100 };
@@ -41,8 +41,8 @@ bool Sound::initialize()
     // load wave files
     if (!load(APP_DATADIR)) {
         // try portable variant
-        std::string path(SDL_GetBasePath());
-        path += "data";
+        std::filesystem::path path(SDL_GetBasePath());
+        path /= "data";
         if (!load(path.c_str())) {
             return false;
         }
@@ -59,32 +59,32 @@ void Sound::play(Sound::Type type)
     }
 }
 
-bool Sound::load(const char* dir)
+bool Sound::load(const std::filesystem::path& dir)
 {
-    memset(waves, 0, sizeof(waves));
-
     for (size_t i = 0; i < sizeof(waves) / sizeof(waves[0]); ++i) {
         SDL_AudioSpec spec;
-        std::string file = dir;
+        std::filesystem::path file = dir;
         switch (i) {
             case Clatz:
-                file += "clatz.wav";
+                file /= "clatz.wav";
                 break;
             case Complete:
-                file += "complete.wav";
+                file /= "complete.wav";
                 break;
         }
-        if (!SDL_LoadWAV(file.c_str(), &spec, &waves[i].data, &waves[i].size)) {
+        const std::string wav_path = file.string();
+        if (!SDL_LoadWAV(wav_path.c_str(), &spec, &waves[i].data,
+                         &waves[i].size)) {
             SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "Error loading wav %s: %s",
-                         file.c_str(), SDL_GetError());
+                         wav_path.c_str(), SDL_GetError());
             break;
         }
         if (spec.format != sound_spec.format ||
             spec.channels != sound_spec.channels ||
             spec.freq != sound_spec.freq) {
             SDL_LogError(SDL_LOG_CATEGORY_AUDIO,
                          "Error loading wav %s: unsupported format",
-                         file.c_str());
+                         wav_path.c_str());
             break;
         }
     }
@@ -93,7 +93,8 @@ bool Sound::load(const char* dir)
         SDL_free(waves[Clatz].data);
         SDL_free(waves[Complete].data);
         memset(waves, 0, sizeof(waves));
+        return false;
     }
 
-    return waves[Clatz].data && waves[Complete].data;
+    return true;
 }

src/sound.hpp

@@ -6,6 +6,8 @@
 
 #include <SDL3/SDL.h>
 
+#include <filesystem>
+
 /** Sound subsystem. */
 class Sound {
 public:
@@ -37,13 +39,13 @@ class Sound {
      * @param dir path to directory with sound files (wav)
      * @return false if load failed
      */
-    bool load(const char* dir);
+    bool load(const std::filesystem::path& dir);
 
     struct Wave {
         Uint8* data; ///< Plain wave data
         Uint32 size; ///< Size of wave data
     };
-    Wave waves[2]; ///< Wav data instances
+    Wave waves[2] = {}; ///< Wav data instances
 
     SDL_AudioStream* stream; ///< Output audio stream
 };

src/state.cpp

@@ -7,6 +7,7 @@
 #include <SDL3/SDL.h>
 
 #include <cstring>
+#include <filesystem>
 #include <vector>
 
 #include "level.hpp"
@@ -35,10 +36,10 @@ class IniFile {
     {
         char* dir = SDL_GetPrefPath(nullptr, app_name);
         if (dir) {
-            std::string path = dir;
-            path += state_file;
+            std::filesystem::path path(dir);
+            path /= state_file;
             SDL_free(dir);
-            io = SDL_IOFromFile(path.c_str(), readonly ? "rb" : "wb");
+            io = SDL_IOFromFile(path.string().c_str(), readonly ? "rb" : "wb");
         }
     }