ffGetPropValue

src/common/detectGTK.c

@@ -77,32 +77,17 @@ static void detectGTKFromConfigFile(const char* filename, FFGTKResult* result)
     while(getline(&line, &len, file) != -1)
     {
         if(result->theme.length == 0)
-        {
-            sscanf(line, "gtk-theme-name=%[^\n]", result->theme.chars);
-            sscanf(line, "gtk-theme-name=\"%[^\"]+", result->theme.chars);
-        }
-
+            ffGetPropValue(line, "gtk-theme-name=", &result->theme);
         if(result->icons.length == 0)
-        {
-            sscanf(line, "gtk-icon-theme-name=%[^\n]", result->icons.chars);
-            sscanf(line, "gtk-icon-theme-name=\"%[^\"]+", result->icons.chars);
-        }
-
+            ffGetPropValue(line, "gtk-icon-theme-name=", &result->icons);
         if(result->font.length == 0)
-        {
-            sscanf(line, "gtk-font-name=%[^\n]", result->font.chars);
-            sscanf(line, "gtk-font-name=\"%[^\"]+", result->font.chars);
-        }
+            ffGetPropValue(line, "gtk-font-name=", &result->font);
     }
 
     if(line != NULL)
         free(line);
 
     fclose(file);
-
-    ffStrbufRecalculateLength(&result->theme);
-    ffStrbufRecalculateLength(&result->icons);
-    ffStrbufRecalculateLength(&result->font);
 }
 
 static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFGTKResult* result)

src/common/detectPlasma.c

@@ -27,7 +27,7 @@ static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* resul
         if(line[0] == '[')
         {
             char categoryName[32];
-            sscanf(line, "[%[^]]", categoryName);
+            sscanf(line, "[%32[^]]", categoryName);
 
             if(strcasecmp(categoryName, "General") == 0)
                 category = PLASMA_CATEGORY_GENERAL;
@@ -42,30 +42,16 @@ static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* resul
         }
 
         if(category == PLASMA_CATEGORY_KDE)
-        {
-            sscanf(line, "widgetStyle=%[^\n]", result->widgetStyle.chars);
-            sscanf(line, "widgetStyle=\"%[^\"]+", result->widgetStyle.chars);
-        }
+            ffGetPropValue(line, "widgetStyle=", &result->widgetStyle);
+        else if(category == PLASMA_CATEGORY_ICONS)
+            ffGetPropValue(line, "Theme=", &result->icons);
         else if(category == PLASMA_CATEGORY_GENERAL)
         {
-            sscanf(line, "ColorScheme=%[^\n]", result->colorScheme.chars);
-            sscanf(line, "ColorScheme=\"%[^\"]+", result->colorScheme.chars);
-
-            sscanf(line, "font=%[^\n]", result->font.chars);
-            sscanf(line, "font=\"%[^\"]+", result->font.chars);
-        }
-        else if(category == PLASMA_CATEGORY_ICONS)
-        {
-            sscanf(line, "Theme=%[^\n]", result->icons.chars);
-            sscanf(line, "Theme=\"%[^\"]+", result->icons.chars);
+            ffGetPropValue(line, "ColorScheme=", &result->colorScheme);
+            ffGetPropValue(line, "font=", &result->font);
         }
     }
 
-    ffStrbufRecalculateLength(&result->widgetStyle);
-    ffStrbufRecalculateLength(&result->colorScheme);
-    ffStrbufRecalculateLength(&result->icons);
-    ffStrbufRecalculateLength(&result->font);
-
     if(line != NULL)
         free(line);
 

src/common/detectWMDE.c

@@ -204,36 +204,28 @@ static void getKDE(FFWMDEResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "plasmashell");
     ffStrbufSetS(&result->dePrettyName, "KDE Plasma");
-
-    ffParsePropFile("/usr/share/xsessions/plasma.desktop", " X-KDE-PluginInfo-Version=%[^\n]", result->deVersion.chars);
-    ffStrbufRecalculateLength(&result->deVersion);
+    ffParsePropFile("/usr/share/xsessions/plasma.desktop", "X-KDE-PluginInfo-Version=", &result->deVersion);
 }
 
 static void getGnome(FFWMDEResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "gnome-shell");
     ffStrbufSetS(&result->dePrettyName, "GNOME");
-
-    ffParsePropFile("/usr/share/gnome-shell/org.gnome.Extensions", " version: '%[^']", result->deVersion.chars);
-    ffStrbufRecalculateLength(&result->deVersion);
+    ffParsePropFile("/usr/share/gnome-shell/org.gnome.Extensions", "version: ", &result->deVersion);
 }
 
 static void getCinnamon(FFWMDEResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "cinnamon");
     ffStrbufSetS(&result->dePrettyName, "Cinnamon");
-
-    ffParsePropFile("/usr/share/applications/cinnamon.desktop", " X-GNOME-Bugzilla-Version=%[^\n]", result->deVersion.chars);
-    ffStrbufRecalculateLength(&result->deVersion);
+    ffParsePropFile("/usr/share/applications/cinnamon.desktop", "X-GNOME-Bugzilla-Version=", &result->deVersion);
 }
 
 static void getXFCE4(FFinstance* instance, FFWMDEResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "xfce4-session");
     ffStrbufSetS(&result->dePrettyName, "Xfce4");
-
-    ffParsePropFile("/usr/share/gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version %[^\n]", result->deVersion.chars);
-    ffStrbufRecalculateLength(&result->deVersion);
+    ffParsePropFile("/usr/share/gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version ", &result->deVersion);
 
     if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
     {

src/common/format.c

@@ -113,7 +113,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         FFstrbuf placeholderValue;
         ffStrbufInit(&placeholderValue);
 
-        while(formatstr->chars[i] != '}' && i < formatstr->length)
+        while(i < formatstr->length && formatstr->chars[i] != '}')
             ffStrbufAppendC(&placeholderValue, formatstr->chars[i++]);
 
         // test for error, if so print it

src/common/io.c

@@ -290,10 +290,8 @@ void ffCacheClose(FFcache* cache)
         fclose(cache->split);
 }
 
-bool ffParsePropFile(const char* fileName, const char* regex, char* buffer)
+bool ffParsePropFile(const char* fileName, const char* start, FFstrbuf* buffer)
 {
-    buffer[0] = '\0'; //If an error occures, this is the indicator
-
     char* line = NULL;
     size_t len = 0;
 
@@ -303,7 +301,7 @@ bool ffParsePropFile(const char* fileName, const char* regex, char* buffer)
 
     while (getline(&line, &len, file) != -1)
     {
-        if (sscanf(line, regex, buffer) > 0)
+        if(ffGetPropValue(line, start, buffer))
             break;
     }
 
@@ -314,7 +312,7 @@ bool ffParsePropFile(const char* fileName, const char* regex, char* buffer)
     return true;
 }
 
-bool ffParsePropFileHome(FFinstance* instance, const char* relativeFile, const char* regex, char* buffer)
+bool ffParsePropFileHome(FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
     FFstrbuf absolutePath;
     ffStrbufInitA(&absolutePath, 64);
@@ -322,15 +320,17 @@ bool ffParsePropFileHome(FFinstance* instance, const char* relativeFile, const c
     ffStrbufAppendC(&absolutePath, '/');
     ffStrbufAppendS(&absolutePath, relativeFile);
 
-    bool result = ffParsePropFile(absolutePath.chars, regex, buffer);
+    bool result = ffParsePropFile(absolutePath.chars, start, buffer);
 
     ffStrbufDestroy(&absolutePath);
 
     return result;
 }
 
-bool ffParsePropFileConfig(FFinstance* instance, const char* relativeFile, const char* regex, char* buffer)
+bool ffParsePropFileConfig(FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
+
+    uint32_t bufferLengthStart = buffer->length;
     bool foundAFile = false;
 
     for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
@@ -343,12 +343,12 @@ bool ffParsePropFileConfig(FFinstance* instance, const char* relativeFile, const
 
         ffStrbufAppendS(baseDir, relativeFile);
 
-        if(ffParsePropFile(baseDir->chars, regex, buffer))
+        if(ffParsePropFile(baseDir->chars, start, buffer))
             foundAFile = true;
 
         ffStrbufSubstrBefore(baseDir, baseDirLength);
 
-        if(*buffer != '\0')
+        if(bufferLengthStart < buffer->length)
             return foundAFile;
     }
 

src/common/parsing.c

@@ -84,7 +84,7 @@ void ffGetFont(const char* font, FFstrbuf* name, double* size)
 {
     ffStrbufEnsureCapacity(name, 32);
 
-    int scanned = sscanf(font, "%[^,], %lf", name->chars, size);
+    int scanned = sscanf(font, "%31[^,], %lf", name->chars, size);
 
     ffStrbufRecalculateLength(name);
 
@@ -106,3 +106,43 @@ void ffGetFontPretty(FFstrbuf* buffer, const FFstrbuf* name, double size)
         ffStrbufAppendS(buffer, "pt)");
     }
 }
+
+bool ffGetPropValue(const char* line, const char* start, FFstrbuf* buffer)
+{
+    uint32_t lineIndex = 0;
+    uint32_t startIndex = 0;
+
+    //Skip any amount of whitespace at the begin of line
+    while(line[lineIndex] == ' ' || line[lineIndex] == '\t')
+        ++lineIndex;
+
+    while(start[startIndex] != '\0')
+    {
+        // Any amount of whitespace in the format string matches any amount of whitespace in the line
+        if(start[startIndex] == ' ' || start[startIndex] == '\t')
+        {
+            while(start[startIndex] == ' ' || start[startIndex] == '\t')
+                ++startIndex;
+
+            while(line[lineIndex] == ' ' || line[lineIndex] == '\t')
+                ++lineIndex;
+        }
+
+        if(line[lineIndex] == '\0' || line[lineIndex] != start[startIndex])
+            return false;
+
+        ++lineIndex;
+        ++startIndex;
+    }
+
+    //Allow quotet values
+    const char* quotes = NULL;
+    if(line[lineIndex] == '"' || line[lineIndex] == '\'')
+        quotes = &line[lineIndex++];
+
+    //Copy the value to the buffer
+    while(line[lineIndex] != '\n' && line[lineIndex] != '\0' && (quotes == NULL || *quotes != line[lineIndex]))
+        ffStrbufAppendC(buffer, line[lineIndex++]);
+
+    return true;
+}

src/fastfetch.c

@@ -719,7 +719,7 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
             fprintf(stderr, "Error: usage: %s <width>\n", key);
             exit(404);
         }
-        if(sscanf(value, "%hd", &instance->config.logo_spacing) != 1)
+        if(sscanf(value, "%hu", &instance->config.logo_spacing) != 1)
         {
             fprintf(stderr, "Error: couldn't parse %s to uint16_t\n", value);
             exit(405);

src/fastfetch.h

@@ -245,9 +245,9 @@ bool ffWriteFDContent(int fd, const FFstrbuf* content);
 void ffWriteFileContent(const char* fileName, const FFstrbuf* buffer);
 
 // They return true if the file was found, independently if regex was found
-bool ffParsePropFile(const char* file, const char* regex, char* buffer);
-bool ffParsePropFileHome(FFinstance* instance, const char* relativeFile, const char* regex, char* buffer);
-bool ffParsePropFileConfig(FFinstance* instance, const char* relativeFile, const char* regex, char* buffer);
+bool ffParsePropFile(const char* file, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileHome(FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileConfig(FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
 
 //common/processing.c
 void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
@@ -271,6 +271,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
 void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4);
 void ffGetFont(const char* font, FFstrbuf* name, double* size);
 void ffGetFontPretty(FFstrbuf* buffer, const FFstrbuf* name, double size);
+bool ffGetPropValue(const char* line, const char* start, FFstrbuf* buffer);
 
 //common/settings.c
 FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type);

src/modules/cpu.c

@@ -44,8 +44,8 @@ void ffPrintCPU(FFinstance* instance)
 
     while(getline(&line, &len, cpuinfo) != -1)
     {
-        sscanf(line, "model name%*s %[^\n]", name);
-        sscanf(line, "vendor_id%*s %[^\n]", vendor);
+        sscanf(line, "model name%*s %256[^\n]", name);
+        sscanf(line, "vendor_id%*s %256[^\n]", vendor);
         sscanf(line, "cpu cores%*s %i", &physicalCores);
 
         //Stop after the first CPU

src/modules/locale.c

@@ -1,47 +1,46 @@
 #include "fastfetch.h"
 
-#include <string.h>
-
 #define FF_LOCALE_MODULE_NAME "Locale"
 #define FF_LOCALE_NUM_FORMAT_ARGS 1
 
+static void getLocaleFromEnv(FFstrbuf* locale)
+{
+    ffStrbufAppendS(locale, getenv("LANG"));
+    if(locale->length > 0)
+        return;
+
+    ffStrbufAppendS(locale, getenv("LC_ALL"));
+    if(locale->length > 0)
+        return;
+
+    ffStrbufAppendS(locale, getenv("LC_CTYPE"));
+    if(locale->length > 0)
+        return;
+
+    ffStrbufAppendS(locale, getenv("LC_MESSAGES"));
+}
+
 void ffPrintLocale(FFinstance* instance)
 {
 	if(ffPrintFromCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.localeKey, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS))
         return;
 
-	char localeCode[256];
+	FFstrbuf locale;
+    ffStrbufInit(&locale);
 
-	FILE *fp;
-	fp = fopen("/etc/locale.conf", "r");
+    ffParsePropFile("/etc/locale.conf", "LANG=", &locale);
 
-	if (fp == NULL) {
-		if (getenv("LANG") != NULL)
-			strcpy(localeCode, getenv("LANG"));
-		else if (getenv("LC_ALL") != NULL)
-			strcpy(localeCode, getenv("LC_ALL"));
-		else if (getenv("LC_CTYPE") != NULL)
-			strcpy(localeCode, getenv("LC_CTYPE"));
-		else if (getenv("LC_CTYPE") != NULL)
-			strcpy(localeCode, getenv("LC_CTYPE"));
-		else if (getenv("LC_MESSAGES") != NULL)
-			strcpy(localeCode, getenv("LC_MESSAGES"));
-	} else {
-		ffParsePropFile("/etc/locale.conf", "LANG=%[^\n]", localeCode);
-		fclose(fp);
-	}
+	if (locale.length == 0)
+        getLocaleFromEnv(&locale);
 
-    if(localeCode[0] == '\0')
+    if(locale.length == 0)
     {
         ffPrintError(instance, FF_LOCALE_MODULE_NAME, 0, &instance->config.localeKey, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS, "No locale found");
         return;
     }
 
-	FF_STRBUF_CREATE(locale);
-    ffStrbufSetS(&locale, localeCode);
-
     ffPrintAndSaveToCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.localeKey, &locale, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
-        {FF_FORMAT_ARG_TYPE_STRING, localeCode}
+        {FF_FORMAT_ARG_TYPE_STRBUF, &locale}
     });
 
 	ffStrbufDestroy(&locale);

src/modules/os.c

@@ -30,19 +30,19 @@ const FFOSResult* ffDetectOS(FFinstance* instance)
         return &result;
     }
 
-    ffStrbufInitA(&result.systemName, 256);
-    ffStrbufInitA(&result.name, 256);
-    ffStrbufInitA(&result.prettyName, 256);
-    ffStrbufInitA(&result.id, 256);
-    ffStrbufInitA(&result.idLike, 256);
-    ffStrbufInitA(&result.variant, 256);
-    ffStrbufInitA(&result.variantID, 256);
-    ffStrbufInitA(&result.version, 256);
-    ffStrbufInitA(&result.versionID, 256);
-    ffStrbufInitA(&result.codename, 256);
-    ffStrbufInitA(&result.buildID, 256);
-    ffStrbufInitA(&result.architecture, 256);
-    ffStrbufInitA(&result.error, 256);
+    ffStrbufInit(&result.systemName);
+    ffStrbufInit(&result.name);
+    ffStrbufInit(&result.prettyName);
+    ffStrbufInit(&result.id);
+    ffStrbufInit(&result.idLike);
+    ffStrbufInit(&result.variant);
+    ffStrbufInit(&result.variantID);
+    ffStrbufInit(&result.version);
+    ffStrbufInit(&result.versionID);
+    ffStrbufInit(&result.codename);
+    ffStrbufInit(&result.buildID);
+    ffStrbufInit(&result.architecture);
+    ffStrbufInit(&result.error);
 
     ffStrbufSetS(&result.systemName, instance->state.utsname.sysname);
     ffStrbufSetS(&result.architecture, instance->state.utsname.machine);
@@ -54,42 +54,18 @@ const FFOSResult* ffDetectOS(FFinstance* instance)
     // https://www.freedesktop.org/software/systemd/man/os-release.html
     while (getline(&line, &len, osRelease) != -1)
     {
-        sscanf(line, "NAME=%[^\n]", result.name.chars);
-        sscanf(line, "NAME=\"%[^\"]+", result.name.chars);
-        sscanf(line, "PRETTY_NAME=%[^\n]", result.prettyName.chars);
-        sscanf(line, "PRETTY_NAME=\"%[^\"]+", result.prettyName.chars);
-        sscanf(line, "ID=%[^\n]", result.id.chars);
-        sscanf(line, "ID=\"%[^\"]+", result.id.chars);
-        sscanf(line, "ID_LIKE=%[^\n]", result.idLike.chars);
-        sscanf(line, "ID_LIKE=\"%[^\"]+", result.idLike.chars);
-        sscanf(line, "VARIANT=%[^\n]", result.variant.chars);
-        sscanf(line, "VARIANT=\"%[^\"]+", result.variant.chars);
-        sscanf(line, "VARIANT_ID=%[^\n]", result.variantID.chars);
-        sscanf(line, "VARIANT_ID=\"%[^\"]+", result.variantID.chars);
-        sscanf(line, "VERSION=%[^\n]", result.version.chars);
-        sscanf(line, "VERSION=\"%[^\"]+", result.version.chars);
-        sscanf(line, "VERSION_ID=%[^\n]", result.versionID.chars);
-        sscanf(line, "VERSION_ID=\"%[^\"]+", result.versionID.chars);
-        sscanf(line, "VERSION_CODENAME=%[^\n]", result.codename.chars);
-        sscanf(line, "VERSION_CODENAME=\"%[^\"]+", result.codename.chars);
-        sscanf(line, "BUILD_ID=%[^\n]", result.buildID.chars);
-        sscanf(line, "BUILD_ID=\"%[^\"]+", result.buildID.chars);
+        ffGetPropValue(line, "NAME=", &result.name);
+        ffGetPropValue(line, "PRETTY_NAME=", &result.prettyName);
+        ffGetPropValue(line, "ID=", &result.id);
+        ffGetPropValue(line, "ID_LIKE=", &result.idLike);
+        ffGetPropValue(line, "VARIANT=", &result.variant);
+        ffGetPropValue(line, "VARIANT_ID=", &result.variantID);
+        ffGetPropValue(line, "VERSION=", &result.version);
+        ffGetPropValue(line, "VERSION_ID=", &result.versionID);
+        ffGetPropValue(line, "VERSION_CODENAME=", &result.codename);
+        ffGetPropValue(line, "BUILD_ID=", &result.buildID);
     }
 
-    ffStrbufRecalculateLength(&result.systemName);
-    ffStrbufRecalculateLength(&result.name);
-    ffStrbufRecalculateLength(&result.prettyName);
-    ffStrbufRecalculateLength(&result.id);
-    ffStrbufRecalculateLength(&result.idLike);
-    ffStrbufRecalculateLength(&result.variant);
-    ffStrbufRecalculateLength(&result.variantID);
-    ffStrbufRecalculateLength(&result.version);
-    ffStrbufRecalculateLength(&result.versionID);
-    ffStrbufRecalculateLength(&result.codename);
-    ffStrbufRecalculateLength(&result.buildID);
-    ffStrbufRecalculateLength(&result.architecture);
-    ffStrbufRecalculateLength(&result.error);
-
     if(line != NULL)
         free(line);
 

src/modules/packages.c

@@ -87,6 +87,9 @@ void ffPrintPackages(FFinstance* instance)
         FF_PRINT_PACKAGE(flatpak)
         FF_PRINT_PACKAGE(snap)
 
+        //Fix linter warning of unused value of all
+        (void) all;
+
         #undef FF_PRINT_PACKAGE
 
         putchar('\n');

src/modules/terminal.c

@@ -33,9 +33,10 @@ static void getTerminalName(FFinstance* instance, const char* pid, FFTerminalRes
 
     char name[256];
     char ppid[256];
-    if(fscanf(stat, "%*s (%[^)])%*s%s", name, ppid) != 2)
+    if(fscanf(stat, "%*s (%255[^)])%*s%255s", name, ppid) != 2)
     {
         ffStrbufSetS(&result->error, "fscanf(stat, \"%*s (%[^)])%*s%s\", name, ppid) != 2");
+        fclose(stat);
         return;
     }
 

src/modules/terminalfont.c

@@ -1,5 +1,4 @@
 #include "fastfetch.h"
-#include <string.h>
 
 #define FF_TERMFONT_MODULE_NAME "Terminal Font"
 #define FF_TERMFONT_NUM_FORMAT_ARGS 4
@@ -31,41 +30,50 @@ static void printTerminalFont(FFinstance* instance, const char* font)
     ffStrbufDestroy(&pretty);
 }
 
-static void printTerminalFontFromConfigFile(FFinstance* instance, const char* configFile, const char* regex)
+static void printTerminalFontFromConfigFile(FFinstance* instance, const char* configFile, const char* start)
 {
-    char font[128];
-    ffParsePropFileConfig(instance, configFile, regex, font);
-    if(font[0] == '\0')
-    {
-        ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find terminal font in \"$XDG_CONFIG_HOME/%s\"", regex, configFile);
-        return;
-    }
+    FFstrbuf font;
+    ffStrbufInit(&font);
+    ffParsePropFileConfig(instance, configFile, start, &font);
 
-    printTerminalFont(instance, font);
+    if(font.length == 0)
+        ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find terminal font in \"$XDG_CONFIG_HOME/%s\"", configFile);
+    else
+        printTerminalFont(instance, font.chars);
+
+    ffStrbufDestroy(&font);
 }
 
 static void printKonsole(FFinstance* instance)
 {
-    char profile[128];
-    ffParsePropFileConfig(instance, "konsolerc", "DefaultProfile=%[^\n]", profile);
-    if(profile[0] == '\0')
+    FFstrbuf profile;
+    ffStrbufInit(&profile);
+    ffParsePropFileConfig(instance, "konsolerc", "DefaultProfile=", &profile);
+
+    if(profile.length == 0)
     {
-        ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find \"DefaultProfile=%[^\n]\" in \".config/konsolerc\"");
+        ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find \"DefaultProfile=%[^\\n]\" in \".config/konsolerc\"");
+        ffStrbufDestroy(&profile);
         return;
     }
 
-    char profilePath[256];
-    sprintf(profilePath, ".local/share/konsole/%s", profile);
+    FFstrbuf profilePath;
+    ffStrbufInitA(&profilePath, 64);
+    ffStrbufAppendS(&profilePath, ".local/share/konsole/");
+    ffStrbufAppend(&profilePath, &profile);
 
-    char font[128];
-    ffParsePropFileHome(instance, profilePath, "Font=%[^\n]", font);
-    if(font[0] == '\0')
-    {
-        ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find \"Font=%%[^\\n]\" in \"%s\"", profilePath);
-        return;
-    }
+    FFstrbuf font;
+    ffStrbufInit(&font);
+    ffParsePropFileHome(instance, profilePath.chars, "Font=", &font);
 
-    printTerminalFont(instance, font);
+    if(font.length == 0)
+        ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find \"Font=%%[^\\n]\" in \"%s\"", profilePath.chars);
+    else
+        printTerminalFont(instance, font.chars);
+
+    ffStrbufDestroy(&font);
+    ffStrbufDestroy(&profilePath);
+    ffStrbufDestroy(&profile);
 }
 
 static void printTilixTerminal(FFinstance* instance)
@@ -97,42 +105,41 @@ static void printTilixTerminal(FFinstance* instance)
     else if(!res.boolValueSet || res.boolValue) // system font
         fontName = ffSettingsGetDConf(instance, "/org/gnome/desktop/interface/monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
 
-    if(!fontName)
-    {
+    if(fontName == NULL)
         ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find \"Terminal font\" in Tilix settings");
-        ffStrbufDestroy(&key);
-        return;
-    }
+    else
+        printTerminalFont(instance, fontName);
 
-    printTerminalFont(instance, fontName);
     ffStrbufDestroy(&key);
 }
 
 static void printXCFETerminal(FFinstance* instance)
 {
-    char useSysFont[6];
+    FFstrbuf useSysFont;
+    ffStrbufInit(&useSysFont);
 
-    if(!ffParsePropFileConfig(instance, "xfce4/terminal/terminalrc", "FontUseSystem=%[^\n]", useSysFont))
+    if(!ffParsePropFileConfig(instance, "xfce4/terminal/terminalrc", "FontUseSystem=", &useSysFont))
     {
         ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't open \"$XDG_CONFIG_HOME/xfce4/terminal/terminalrc\"");
+        ffStrbufDestroy(&useSysFont);
         return;
     }
 
-    if((useSysFont[0] == '\0') || strcasecmp(useSysFont, "FALSE") == 0)
+    if(useSysFont.length == 0 || ffStrbufIgnCaseCompS(&useSysFont, "FALSE") == 0)
     {
-        printTerminalFontFromConfigFile(instance, "xfce4/terminal/terminalrc", "FontName=%[^\n]");
+        printTerminalFontFromConfigFile(instance, "xfce4/terminal/terminalrc", "FontName=");
+        ffStrbufDestroy(&useSysFont);
         return;
     }
 
+    ffStrbufDestroy(&useSysFont);
+
     const char* fontName = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/MonospaceFontName", FF_VARIANT_TYPE_STRING).strValue;
 
     if(fontName == NULL)
-    {
         ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Couldn't find \"xsettings::/Gtk/MonospaceFontName\" in XFConf");
-        return;
-    }
-
-    printTerminalFont(instance, fontName);
+    else
+        printTerminalFont(instance, fontName);
 }
 
 static void printTTY(FFinstance* instance)
@@ -140,8 +147,7 @@ static void printTTY(FFinstance* instance)
     FFstrbuf font;
     ffStrbufInit(&font);
 
-    ffParsePropFile("/etc/vconsole.conf", "Font=%[^\n]", font.chars);
-    ffStrbufRecalculateLength(&font);
+    ffParsePropFile("/etc/vconsole.conf", "Font=", &font);
 
     if(font.length == 0)
     {
@@ -172,7 +178,7 @@ void ffPrintTerminalFont(FFinstance* instance)
     else if(ffStrbufIgnCaseCompS(&result->exeName, "xfce4-terminal") == 0)
         printXCFETerminal(instance);
     else if(ffStrbufIgnCaseCompS(&result->exeName, "lxterminal") == 0)
-        printTerminalFontFromConfigFile(instance, "lxterminal/lxterminal.conf", "fontname=%[^\n]");
+        printTerminalFontFromConfigFile(instance, "lxterminal/lxterminal.conf", "fontname=");
     else if(ffStrbufIgnCaseCompS(&result->exeName, "tilix") == 0)
         printTilixTerminal(instance);
     else if(ffStrbufStartsWithIgnCaseS(&result->exeName, "/dev/tty"))

src/modules/wmtheme.c

@@ -21,16 +21,20 @@ static void printWMTheme(FFinstance* instance, const char* theme)
 
 static void printWMThemeFromConfigFile(FFinstance* instance, const char* configFile, const char* themeRegex, const char* defaultValue)
 {
-    char theme[256];
+    FFstrbuf theme;
+    ffStrbufInit(&theme);
 
-    if(!ffParsePropFileConfig(instance, configFile, themeRegex, theme))
+    if(!ffParsePropFileConfig(instance, configFile, themeRegex, &theme))
     {
         ffPrintError(instance, FF_WMTHEME_MODULE_NAME, 0, &instance->config.wmThemeKey, &instance->config.wmThemeFormat, FF_WMTHEME_NUM_FORMAT_ARGS, "Config file %s doesn't exist", configFile);
+        ffStrbufDestroy(&theme);
         return;
     }
 
-    if(*theme == '\0')
+    if(theme.length == 0)
     {
+        ffStrbufDestroy(&theme);
+
         if(defaultValue == NULL)
         {
             ffPrintError(instance, FF_WMTHEME_MODULE_NAME, 0, &instance->config.wmThemeKey, &instance->config.wmThemeFormat, FF_WMTHEME_NUM_FORMAT_ARGS, "Couldn't find theme in %s", configFile);
@@ -41,7 +45,8 @@ static void printWMThemeFromConfigFile(FFinstance* instance, const char* configF
         return;
     }
 
-    printWMTheme(instance, theme);
+    printWMTheme(instance, theme.chars);
+    ffStrbufDestroy(&theme);
 }
 
 static void printMutter(FFinstance* instance)
@@ -178,7 +183,7 @@ void ffPrintWMTheme(FFinstance* instance)
     }
 
     if(ffStrbufIgnCaseCompS(&result->wmPrettyName, "KWin") == 0 || ffStrbufIgnCaseCompS(&result->wmPrettyName, "KDE") == 0 || ffStrbufIgnCaseCompS(&result->wmPrettyName, "Plasma") == 0)
-        printWMThemeFromConfigFile(instance, "kwinrc", " theme=%s", "Breeze");
+        printWMThemeFromConfigFile(instance, "kwinrc", "theme=", "Breeze");
     else if(ffStrbufIgnCaseCompS(&result->wmPrettyName, "Xfwm4") == 0 || ffStrbufIgnCaseCompS(&result->wmPrettyName, "Xfwm") == 0)
         printXFWM4(instance);
     else if(ffStrbufIgnCaseCompS(&result->wmPrettyName, "Mutter") == 0 || ffStrbufIgnCaseCompS(&result->wmPrettyName, "Gnome") == 0 || ffStrbufIgnCaseCompS(&result->wmPrettyName, "Ubuntu") == 0)

src/util/FFstrbuf.c

@@ -276,7 +276,7 @@ int ffStrbufIgnCaseCompS(const FFstrbuf* strbuf, const char* comp)
 void ffStrbufTrimLeft(FFstrbuf* strbuf, char c)
 {
     uint32_t index = 0;
-    while(strbuf->chars[index] == c && index < strbuf->length)
+    while(index < strbuf->length && strbuf->chars[index] == c)
         ++index;
 
     if(index == 0)