fastfetch-cli/fastfetch
1
0
Fork 0
mirror of https://github.com/fastfetch-cli/fastfetch.git synced 2026-10-31 10:02:49 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Modules: major code refactor

Browse Source 
Also fix some bugs found when refactoring
This commit is contained in:
李通洲
2023-08-17 10:56:54 +08:00
parent 75323d64f8
commit c888254f70
171 changed files with 778 additions and 963 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CHANGELOG.md
+1
View File
@@ -11,6 +11,7 @@ Features:
Bugfixes:
* Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux)
* Fix some module options were not inited
# 2.0.0-beta
doc/json_schema.json
+1 -1
View File
@@ -373,7 +373,7 @@
},
"width": {
"type": "integer",
"title": "Set the width of the bar",
"title": "Set the width of the bar, in number of characters",
"minimum": 1,
"default": 10
}
src/common/init.c
+85 -79
View File
@@ -76,57 +76,60 @@ static void defaultConfig(void)
instance.config.barBorder = true;
instance.config.percentType = 1;
ffInitTitleOptions(&instance.config.title);
ffInitOSOptions(&instance.config.os);
ffInitHostOptions(&instance.config.host);
ffInitBatteryOptions(&instance.config.battery);
ffInitBiosOptions(&instance.config.bios);
ffInitBluetoothOptions(&instance.config.bluetooth);
ffInitBoardOptions(&instance.config.board);
ffInitBreakOptions(&instance.config.break_);
ffInitBrightnessOptions(&instance.config.brightness);
ffInitChassisOptions(&instance.config.chassis);
ffInitCommandOptions(&instance.config.command);
ffInitCustomOptions(&instance.config.custom);
ffInitKernelOptions(&instance.config.kernel);
ffInitUptimeOptions(&instance.config.uptime);
ffInitProcessesOptions(&instance.config.processes);
ffInitPackagesOptions(&instance.config.packages);
ffInitShellOptions(&instance.config.shell);
ffInitDisplayOptions(&instance.config.display);
ffInitDEOptions(&instance.config.de);
ffInitWMOptions(&instance.config.wm);
ffInitWMThemeOptions(&instance.config.wmTheme);
ffInitThemeOptions(&instance.config.theme);
ffInitIconsOptions(&instance.config.icons);
ffInitFontOptions(&instance.config.font);
ffInitCursorOptions(&instance.config.cursor);
ffInitTerminalOptions(&instance.config.terminal);
ffInitTerminalFontOptions(&instance.config.terminalFont);
ffInitCPUOptions(&instance.config.cpu);
ffInitCPUUsageOptions(&instance.config.cpuUsage);
ffInitGPUOptions(&instance.config.gpu);
ffInitMemoryOptions(&instance.config.memory);
ffInitSwapOptions(&instance.config.swap);
ffInitChassisOptions(&instance.config.chassis);
ffInitColorsOptions(&instance.config.colors);
ffInitCommandOptions(&instance.config.command);
ffInitCursorOptions(&instance.config.cursor);
ffInitCustomOptions(&instance.config.custom);
ffInitDEOptions(&instance.config.de);
ffInitDateTimeOptions(&instance.config.dateTime);
ffInitDiskOptions(&instance.config.disk);
ffInitBatteryOptions(&instance.config.battery);
ffInitPowerAdapterOptions(&instance.config.powerAdapter);
ffInitDisplayOptions(&instance.config.display);
ffInitFontOptions(&instance.config.font);
ffInitGPUOptions(&instance.config.gpu);
ffInitGamepadOptions(&instance.config.gamepad);
ffInitHostOptions(&instance.config.host);
ffInitIconsOptions(&instance.config.icons);
ffInitKernelOptions(&instance.config.kernel);
ffInitLMOptions(&instance.config.lm);
ffInitLocaleOptions(&instance.config.locale);
ffInitLocalIpOptions(&instance.config.localIP);
ffInitLocaleOptions(&instance.config.locale);
ffInitMediaOptions(&instance.config.media);
ffInitMemoryOptions(&instance.config.memory);
ffInitMonitorOptions(&instance.config.monitor);
ffInitOSOptions(&instance.config.os);
ffInitOpenCLOptions(&instance.config.openCL);
ffInitOpenGLOptions(&instance.config.openGL);
ffInitPackagesOptions(&instance.config.packages);
ffInitPlayerOptions(&instance.config.player);
ffInitPowerAdapterOptions(&instance.config.powerAdapter);
ffInitProcessesOptions(&instance.config.processes);
ffInitPublicIpOptions(&instance.config.publicIP);
ffInitSeparatorOptions(&instance.config.separator);
ffInitShellOptions(&instance.config.shell);
ffInitSoundOptions(&instance.config.sound);
ffInitSwapOptions(&instance.config.swap);
ffInitTerminalFontOptions(&instance.config.terminalFont);
ffInitTerminalOptions(&instance.config.terminal);
ffInitTerminalSizeOptions(&instance.config.terminalSize);
ffInitThemeOptions(&instance.config.theme);
ffInitTitleOptions(&instance.config.title);
ffInitUptimeOptions(&instance.config.uptime);
ffInitUsersOptions(&instance.config.users);
ffInitVulkanOptions(&instance.config.vulkan);
ffInitWMOptions(&instance.config.wm);
ffInitWMThemeOptions(&instance.config.wmTheme);
ffInitWallpaperOptions(&instance.config.wallpaper);
ffInitWeatherOptions(&instance.config.weather);
ffInitWifiOptions(&instance.config.wifi);
ffInitPlayerOptions(&instance.config.player);
ffInitMediaOptions(&instance.config.media);
ffInitDateTimeOptions(&instance.config.dateTime);
ffInitVulkanOptions(&instance.config.vulkan);
ffInitWallpaperOptions(&instance.config.wallpaper);
ffInitOpenGLOptions(&instance.config.openGL);
ffInitOpenCLOptions(&instance.config.openCL);
ffInitUsersOptions(&instance.config.users);
ffInitBluetoothOptions(&instance.config.bluetooth);
ffInitSoundOptions(&instance.config.sound);
ffInitSeparatorOptions(&instance.config.separator);
ffInitGamepadOptions(&instance.config.gamepad);
ffInitColorsOptions(&instance.config.colors);
ffStrbufInit(&instance.config.libPCI);
ffStrbufInit(&instance.config.libVulkan);
@@ -285,57 +288,60 @@ static void destroyConfig(void)
ffStrbufDestroy(&instance.config.osFile);
#endif
ffDestroyTitleOptions(&instance.config.title);
ffDestroyOSOptions(&instance.config.os);
ffDestroyHostOptions(&instance.config.host);
ffDestroyBatteryOptions(&instance.config.battery);
ffDestroyBiosOptions(&instance.config.bios);
ffDestroyBluetoothOptions(&instance.config.bluetooth);
ffDestroyBoardOptions(&instance.config.board);
ffDestroyBreakOptions(&instance.config.break_);
ffDestroyBrightnessOptions(&instance.config.brightness);
ffDestroyChassisOptions(&instance.config.chassis);
ffDestroyCommandOptions(&instance.config.command);
ffDestroyCustomOptions(&instance.config.custom);
ffDestroyKernelOptions(&instance.config.kernel);
ffDestroyUptimeOptions(&instance.config.uptime);
ffDestroyProcessesOptions(&instance.config.processes);
ffDestroyPackagesOptions(&instance.config.packages);
ffDestroyShellOptions(&instance.config.shell);
ffDestroyDisplayOptions(&instance.config.display);
ffDestroyDEOptions(&instance.config.de);
ffDestroyWMOptions(&instance.config.wm);
ffDestroyWMThemeOptions(&instance.config.wmTheme);
ffDestroyThemeOptions(&instance.config.theme);
ffDestroyIconsOptions(&instance.config.icons);
ffDestroyFontOptions(&instance.config.font);
ffDestroyCursorOptions(&instance.config.cursor);
ffDestroyTerminalOptions(&instance.config.terminal);
ffDestroyTerminalFontOptions(&instance.config.terminalFont);
ffDestroyCPUOptions(&instance.config.cpu);
ffDestroyCPUUsageOptions(&instance.config.cpuUsage);
ffDestroyGPUOptions(&instance.config.gpu);
ffDestroyMemoryOptions(&instance.config.memory);
ffDestroySwapOptions(&instance.config.swap);
ffDestroyChassisOptions(&instance.config.chassis);
ffDestroyColorsOptions(&instance.config.colors);
ffDestroyCommandOptions(&instance.config.command);
ffDestroyCursorOptions(&instance.config.cursor);
ffDestroyCustomOptions(&instance.config.custom);
ffDestroyDEOptions(&instance.config.de);
ffDestroyDateTimeOptions(&instance.config.dateTime);
ffDestroyDiskOptions(&instance.config.disk);
ffDestroyBatteryOptions(&instance.config.battery);
ffDestroyPowerAdapterOptions(&instance.config.powerAdapter);
ffDestroyDisplayOptions(&instance.config.display);
ffDestroyFontOptions(&instance.config.font);
ffDestroyGPUOptions(&instance.config.gpu);
ffDestroyGamepadOptions(&instance.config.gamepad);
ffDestroyHostOptions(&instance.config.host);
ffDestroyIconsOptions(&instance.config.icons);
ffDestroyKernelOptions(&instance.config.kernel);
ffDestroyLMOptions(&instance.config.lm);
ffDestroyLocaleOptions(&instance.config.locale);
ffDestroyLocalIpOptions(&instance.config.localIP);
ffDestroyLocaleOptions(&instance.config.locale);
ffDestroyMediaOptions(&instance.config.media);
ffDestroyMemoryOptions(&instance.config.memory);
ffDestroyMonitorOptions(&instance.config.monitor);
ffDestroyOSOptions(&instance.config.os);
ffDestroyOpenCLOptions(&instance.config.openCL);
ffDestroyOpenGLOptions(&instance.config.openGL);
ffDestroyPackagesOptions(&instance.config.packages);
ffDestroyPlayerOptions(&instance.config.player);
ffDestroyPowerAdapterOptions(&instance.config.powerAdapter);
ffDestroyProcessesOptions(&instance.config.processes);
ffDestroyPublicIpOptions(&instance.config.publicIP);
ffDestroySeparatorOptions(&instance.config.separator);
ffDestroyShellOptions(&instance.config.shell);
ffDestroySoundOptions(&instance.config.sound);
ffDestroySwapOptions(&instance.config.swap);
ffDestroyTerminalFontOptions(&instance.config.terminalFont);
ffDestroyTerminalOptions(&instance.config.terminal);
ffDestroyTerminalSizeOptions(&instance.config.terminalSize);
ffDestroyThemeOptions(&instance.config.theme);
ffDestroyTitleOptions(&instance.config.title);
ffDestroyUptimeOptions(&instance.config.uptime);
ffDestroyUsersOptions(&instance.config.users);
ffDestroyVulkanOptions(&instance.config.vulkan);
ffDestroyWMOptions(&instance.config.wm);
ffDestroyWMThemeOptions(&instance.config.wmTheme);
ffDestroyWallpaperOptions(&instance.config.wallpaper);
ffDestroyWeatherOptions(&instance.config.weather);
ffDestroyWifiOptions(&instance.config.wifi);
ffDestroyPlayerOptions(&instance.config.player);
ffDestroyMediaOptions(&instance.config.media);
ffDestroyDateTimeOptions(&instance.config.dateTime);
ffDestroyVulkanOptions(&instance.config.vulkan);
ffDestroyOpenGLOptions(&instance.config.openGL);
ffDestroyOpenCLOptions(&instance.config.openCL);
ffDestroyUsersOptions(&instance.config.users);
ffDestroyBluetoothOptions(&instance.config.bluetooth);
ffDestroySeparatorOptions(&instance.config.separator);
ffDestroySoundOptions(&instance.config.sound);
ffDestroyGamepadOptions(&instance.config.gamepad);
ffDestroyColorsOptions(&instance.config.colors);
ffStrbufDestroy(&instance.config.libPCI);
ffStrbufDestroy(&instance.config.libVulkan);
src/common/jsonconfig.c
+60 -57
View File
@@ -70,11 +70,13 @@ const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair p
return "Invalid enum value type; must be a string or integer";
}
static inline bool tryModule(const char* type, yyjson_val* module, const char* moduleName, void (*const f)(yyjson_val *module))
static inline bool tryModule(const char* type, yyjson_val* module, void* options)
{
if (ffStrEqualsIgnCase(type, moduleName))
FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options;
if (ffStrEqualsIgnCase(type, baseInfo->name))
{
f(module);
if (module) baseInfo->parseJsonObject(options, module);
baseInfo->printModule(options);
return true;
}
return false;
@@ -82,144 +84,145 @@ static inline bool tryModule(const char* type, yyjson_val* module, const char* m
static bool parseModuleJsonObject(const char* type, yyjson_val* module)
{
FFconfig* cfg = &instance.config;
switch (toupper(type[0]))
{
case 'B': {
return
tryModule(type, module, FF_BATTERY_MODULE_NAME, ffParseBatteryJsonObject) ||
tryModule(type, module, FF_BIOS_MODULE_NAME, ffParseBiosJsonObject) ||
tryModule(type, module, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothJsonObject) ||
tryModule(type, module, FF_BOARD_MODULE_NAME, ffParseBoardJsonObject) ||
tryModule(type, module, FF_BREAK_MODULE_NAME, ffParseBreakJsonObject) ||
tryModule(type, module, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessJsonObject) ||
tryModule(type, module, &cfg->battery) ||
tryModule(type, module, &cfg->bios) ||
tryModule(type, module, &cfg->bluetooth) ||
tryModule(type, module, &cfg->board) ||
tryModule(type, module, &cfg->break_) ||
tryModule(type, module, &cfg->brightness) ||
false;
}
case 'C': {
return
tryModule(type, module, FF_CHASSIS_MODULE_NAME, ffParseChassisJsonObject) ||
tryModule(type, module, FF_COMMAND_MODULE_NAME, ffParseCommandJsonObject) ||
tryModule(type, module, FF_COLORS_MODULE_NAME, ffParseColorsJsonObject) ||
tryModule(type, module, FF_CPU_MODULE_NAME, ffParseCPUJsonObject) ||
tryModule(type, module, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageJsonObject) ||
tryModule(type, module, FF_CURSOR_MODULE_NAME, ffParseCursorJsonObject) ||
tryModule(type, module, FF_CUSTOM_MODULE_NAME, ffParseCustomJsonObject) ||
tryModule(type, module, &cfg->chassis) ||
tryModule(type, module, &cfg->command) ||
tryModule(type, module, &cfg->colors) ||
tryModule(type, module, &cfg->cpu) ||
tryModule(type, module, &cfg->cpuUsage) ||
tryModule(type, module, &cfg->cursor) ||
tryModule(type, module, &cfg->custom) ||
false;
}
case 'D': {
return
tryModule(type, module, FF_DATETIME_MODULE_NAME, ffParseDateTimeJsonObject) ||
tryModule(type, module, FF_DE_MODULE_NAME, ffParseDEJsonObject) ||
tryModule(type, module, FF_DISPLAY_MODULE_NAME, ffParseDisplayJsonObject) ||
tryModule(type, module, FF_DISK_MODULE_NAME, ffParseDiskJsonObject) ||
tryModule(type, module, &cfg->dateTime) ||
tryModule(type, module, &cfg->de) ||
tryModule(type, module, &cfg->display) ||
tryModule(type, module, &cfg->disk) ||
false;
}
case 'F': {
return
tryModule(type, module, FF_FONT_MODULE_NAME, ffParseFontJsonObject) ||
tryModule(type, module, &cfg->font) ||
false;
}
case 'G': {
return
tryModule(type, module, FF_GAMEPAD_MODULE_NAME, ffParseGamepadJsonObject) ||
tryModule(type, module, FF_GPU_MODULE_NAME, ffParseGPUJsonObject) ||
tryModule(type, module, &cfg->gamepad) ||
tryModule(type, module, &cfg->gpu) ||
false;
}
case 'H': {
return
tryModule(type, module, FF_HOST_MODULE_NAME, ffParseHostJsonObject) ||
tryModule(type, module, &cfg->host) ||
false;
}
case 'I': {
return
tryModule(type, module, FF_ICONS_MODULE_NAME, ffParseIconsJsonObject) ||
tryModule(type, module, &cfg->icons) ||
false;
}
case 'K': {
return
tryModule(type, module, FF_KERNEL_MODULE_NAME, ffParseKernelJsonObject) ||
tryModule(type, module, &cfg->kernel) ||
false;
}
case 'L': {
return
tryModule(type, module, FF_LM_MODULE_NAME, ffParseLMJsonObject) ||
tryModule(type, module, FF_LOCALE_MODULE_NAME, ffParseLocaleJsonObject) ||
tryModule(type, module, FF_LOCALIP_MODULE_NAME, ffParseLocalIpJsonObject) ||
tryModule(type, module, &cfg->lm) ||
tryModule(type, module, &cfg->locale) ||
tryModule(type, module, &cfg->localIP) ||
false;
}
case 'M': {
return
tryModule(type, module, FF_MEDIA_MODULE_NAME, ffParseMediaJsonObject) ||
tryModule(type, module, FF_MEMORY_MODULE_NAME, ffParseMemoryJsonObject) ||
tryModule(type, module, FF_MONITOR_MODULE_NAME, ffParseMonitorJsonObject) ||
tryModule(type, module, &cfg->media) ||
tryModule(type, module, &cfg->memory) ||
tryModule(type, module, &cfg->monitor) ||
false;
}
case 'O': {
return
tryModule(type, module, FF_OPENCL_MODULE_NAME, ffParseOpenCLJsonObject) ||
tryModule(type, module, FF_OPENGL_MODULE_NAME, ffParseOpenGLJsonObject) ||
tryModule(type, module, FF_OS_MODULE_NAME, ffParseOSJsonObject) ||
tryModule(type, module, &cfg->openCL) ||
tryModule(type, module, &cfg->openGL) ||
tryModule(type, module, &cfg->os) ||
false;
}
case 'P': {
return
tryModule(type, module, FF_PACKAGES_MODULE_NAME, ffParsePackagesJsonObject) ||
tryModule(type, module, FF_PLAYER_MODULE_NAME, ffParsePlayerJsonObject) ||
tryModule(type, module, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterJsonObject) ||
tryModule(type, module, FF_PROCESSES_MODULE_NAME, ffParseProcessesJsonObject) ||
tryModule(type, module, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpJsonObject) ||
tryModule(type, module, &cfg->packages) ||
tryModule(type, module, &cfg->player) ||
tryModule(type, module, &cfg->powerAdapter) ||
tryModule(type, module, &cfg->processes) ||
tryModule(type, module, &cfg->publicIP) ||
false;
}
case 'S': {
return
tryModule(type, module, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorJsonObject) ||
tryModule(type, module, FF_SHELL_MODULE_NAME, ffParseShellJsonObject) ||
tryModule(type, module, FF_SOUND_MODULE_NAME, ffParseSoundJsonObject) ||
tryModule(type, module, FF_SWAP_MODULE_NAME, ffParseSwapJsonObject) ||
tryModule(type, module, &cfg->separator) ||
tryModule(type, module, &cfg->shell) ||
tryModule(type, module, &cfg->sound) ||
tryModule(type, module, &cfg->swap) ||
false;
}
case 'T': {
return
tryModule(type, module, FF_TERMINAL_MODULE_NAME, ffParseTerminalJsonObject) ||
tryModule(type, module, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontJsonObject) ||
tryModule(type, module, FF_TERMINALSIZE_MODULE_NAME, ffParseTerminalSizeJsonObject) ||
tryModule(type, module, FF_TITLE_MODULE_NAME, ffParseTitleJsonObject) ||
tryModule(type, module, FF_THEME_MODULE_NAME, ffParseThemeJsonObject) ||
tryModule(type, module, &cfg->terminal) ||
tryModule(type, module, &cfg->terminalFont) ||
tryModule(type, module, &cfg->terminalSize) ||
tryModule(type, module, &cfg->title) ||
tryModule(type, module, &cfg->theme) ||
false;
}
case 'U': {
return
tryModule(type, module, FF_UPTIME_MODULE_NAME, ffParseUptimeJsonObject) ||
tryModule(type, module, FF_USERS_MODULE_NAME, ffParseUsersJsonObject) ||
tryModule(type, module, &cfg->uptime) ||
tryModule(type, module, &cfg->users) ||
false;
}
case 'V': {
return
tryModule(type, module, FF_VULKAN_MODULE_NAME, ffParseVulkanJsonObject) ||
tryModule(type, module, &cfg->vulkan) ||
false;
}
case 'W': {
return
tryModule(type, module, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperJsonObject) ||
tryModule(type, module, FF_WEATHER_MODULE_NAME, ffParseWeatherJsonObject) ||
tryModule(type, module, FF_WM_MODULE_NAME, ffParseWMJsonObject) ||
tryModule(type, module, FF_WIFI_MODULE_NAME, ffParseWifiJsonObject) ||
tryModule(type, module, FF_WMTHEME_MODULE_NAME, ffParseWMThemeJsonObject) ||
tryModule(type, module, &cfg->wallpaper) ||
tryModule(type, module, &cfg->weather) ||
tryModule(type, module, &cfg->wm) ||
tryModule(type, module, &cfg->wifi) ||
tryModule(type, module, &cfg->wmTheme) ||
false;
}
src/common/option.h
+24
View File
@@ -1,6 +1,30 @@
#pragma once
#include "util/FFstrbuf.h"
#include "3rdparty/yyjson/yyjson.h"
// Must be the first field of FFModuleOptions
typedef struct FFModuleBaseInfo
{
const char* name;
void (*parseCommandOptions)(void* options, const char* key, const char* value);
void (*parseJsonObject)(void* options, yyjson_val *module);
void (*printModule)(void* options);
} FFModuleBaseInfo;
static inline void ffOptionInitModuleBaseInfo(
FFModuleBaseInfo* baseInfo,
const char* name,
void* parseCommandOptions, // void (*const parseCommandOptions)(void* options, const char* key, const char* value)
void* parseJsonObject, // void (*const parseJsonObject)(void* options, yyjson_val *module)
void* printModule // void (*const printModule)(void* options)
)
{
baseInfo->name = name;
baseInfo->parseCommandOptions = parseCommandOptions;
baseInfo->parseJsonObject = parseJsonObject;
baseInfo->printModule = printModule;
}
typedef struct FFModuleArgs
{
src/fastfetch.c
+208 -191
View File
@@ -1062,59 +1062,60 @@ static void parseOption(FFdata* data, const char* key, const char* value)
//Module args options//
///////////////////////
else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
else if(ffParseHostCommandOptions(&instance.config.host, key, value)) {}
else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
else if(ffParseBatteryCommandOptions(&instance.config.battery, key, value)) {}
else if(ffParseBiosCommandOptions(&instance.config.bios, key, value)) {}
else if(ffParseBluetoothCommandOptions(&instance.config.bluetooth, key, value)) {}
else if(ffParseBoardCommandOptions(&instance.config.board, key, value)) {}
else if(ffParseChassisCommandOptions(&instance.config.chassis, key, value)) {}
else if(ffParseCommandCommandOptions(&instance.config.command, key, value)) {}
else if(ffParseCustomCommandOptions(&instance.config.custom, key, value)) {}
else if(ffParseKernelCommandOptions(&instance.config.kernel, key, value)) {}
else if(ffParseUptimeCommandOptions(&instance.config.uptime, key, value)) {}
else if(ffParseProcessesCommandOptions(&instance.config.processes, key, value)) {}
else if(ffParsePackagesCommandOptions(&instance.config.packages, key, value)) {}
else if(ffParseShellCommandOptions(&instance.config.shell, key, value)) {}
else if(ffParseDisplayCommandOptions(&instance.config.display, key, value)) {}
else if(ffParseBreakCommandOptions(&instance.config.break_, key, value)) {}
else if(ffParseBrightnessCommandOptions(&instance.config.brightness, key, value)) {}
else if(ffParseMonitorCommandOptions(&instance.config.nativeResolution, key, value)) {}
else if(ffParseDECommandOptions(&instance.config.de, key, value)) {}
else if(ffParseWifiCommandOptions(&instance.config.wifi, key, value)) {}
else if(ffParseWMCommandOptions(&instance.config.wm, key, value)) {}
else if(ffParseWMThemeCommandOptions(&instance.config.wmTheme, key, value)) {}
else if(ffParseTitleCommandOptions(&instance.config.title, key, value)) {}
else if(ffParseThemeCommandOptions(&instance.config.theme, key, value)) {}
else if(ffParseIconsCommandOptions(&instance.config.icons, key, value)) {}
else if(ffParseWallpaperCommandOptions(&instance.config.wallpaper, key, value)) {}
else if(ffParseFontCommandOptions(&instance.config.font, key, value)) {}
else if(ffParseCPUCommandOptions(&instance.config.cpu, key, value)) {}
else if(ffParseCPUUsageCommandOptions(&instance.config.cpuUsage, key, value)) {}
else if(ffParseChassisCommandOptions(&instance.config.chassis, key, value)) {}
else if(ffParseColorsCommandOptions(&instance.config.colors, key, value)) {}
else if(ffParseCommandCommandOptions(&instance.config.command, key, value)) {}
else if(ffParseCursorCommandOptions(&instance.config.cursor, key, value)) {}
else if(ffParseCustomCommandOptions(&instance.config.custom, key, value)) {}
else if(ffParseDECommandOptions(&instance.config.de, key, value)) {}
else if(ffParseDateTimeCommandOptions(&instance.config.dateTime, key, value)) {}
else if(ffParseDiskCommandOptions(&instance.config.disk, key, value)) {}
else if(ffParseDisplayCommandOptions(&instance.config.display, key, value)) {}
else if(ffParseFontCommandOptions(&instance.config.font, key, value)) {}
else if(ffParseGPUCommandOptions(&instance.config.gpu, key, value)) {}
else if(ffParseGamepadCommandOptions(&instance.config.gamepad, key, value)) {}
else if(ffParseHostCommandOptions(&instance.config.host, key, value)) {}
else if(ffParseIconsCommandOptions(&instance.config.icons, key, value)) {}
else if(ffParseKernelCommandOptions(&instance.config.kernel, key, value)) {}
else if(ffParseLocalIpCommandOptions(&instance.config.localIP, key, value)) {}
else if(ffParseLocaleCommandOptions(&instance.config.locale, key, value)) {}
else if(ffParseMediaCommandOptions(&instance.config.media, key, value)) {}
else if(ffParseMemoryCommandOptions(&instance.config.memory, key, value)) {}
else if(ffParseMonitorCommandOptions(&instance.config.monitor, key, value)) {}
else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
else if(ffParseOpenCLCommandOptions(&instance.config.openCL, key, value)) {}
else if(ffParseOpenGLCommandOptions(&instance.config.openGL, key, value)) {}
else if(ffParsePackagesCommandOptions(&instance.config.packages, key, value)) {}
else if(ffParsePlayerCommandOptions(&instance.config.player, key, value)) {}
else if(ffParsePowerAdapterCommandOptions(&instance.config.powerAdapter, key, value)) {}
else if(ffParseProcessesCommandOptions(&instance.config.processes, key, value)) {}
else if(ffParsePublicIpCommandOptions(&instance.config.publicIP, key, value)) {}
else if(ffParseSeparatorCommandOptions(&instance.config.separator, key, value)) {}
else if(ffParseShellCommandOptions(&instance.config.shell, key, value)) {}
else if(ffParseSoundCommandOptions(&instance.config.sound, key, value)) {}
else if(ffParseSwapCommandOptions(&instance.config.swap, key, value)) {}
else if(ffParseTerminalCommandOptions(&instance.config.terminal, key, value)) {}
else if(ffParseTerminalFontCommandOptions(&instance.config.terminalFont, key, value)) {}
else if(ffParseTerminalSizeCommandOptions(&instance.config.terminalSize, key, value)) {}
else if(ffParseCPUCommandOptions(&instance.config.cpu, key, value)) {}
else if(ffParseCPUUsageCommandOptions(&instance.config.cpuUsage, key, value)) {}
else if(ffParseGPUCommandOptions(&instance.config.gpu, key, value)) {}
else if(ffParseMemoryCommandOptions(&instance.config.memory, key, value)) {}
else if(ffParseSwapCommandOptions(&instance.config.swap, key, value)) {}
else if(ffParseDiskCommandOptions(&instance.config.disk, key, value)) {}
else if(ffParseBatteryCommandOptions(&instance.config.battery, key, value)) {}
else if(ffParsePowerAdapterCommandOptions(&instance.config.powerAdapter, key, value)) {}
else if(ffParseLocaleCommandOptions(&instance.config.locale, key, value)) {}
else if(ffParseLocalIpCommandOptions(&instance.config.localIP, key, value)) {}
else if(ffParsePublicIpCommandOptions(&instance.config.publicIP, key, value)) {}
else if(ffParseWeatherCommandOptions(&instance.config.weather, key, value)) {}
else if(ffParsePlayerCommandOptions(&instance.config.player, key, value)) {}
else if(ffParseMediaCommandOptions(&instance.config.media, key, value)) {}
else if(ffParseDateTimeCommandOptions(&instance.config.dateTime, key, value)) {}
else if(ffParseVulkanCommandOptions(&instance.config.vulkan, key, value)) {}
else if(ffParseOpenGLCommandOptions(&instance.config.openGL, key, value)) {}
else if(ffParseOpenCLCommandOptions(&instance.config.openCL, key, value)) {}
else if(ffParseThemeCommandOptions(&instance.config.theme, key, value)) {}
else if(ffParseTitleCommandOptions(&instance.config.title, key, value)) {}
else if(ffParseUptimeCommandOptions(&instance.config.uptime, key, value)) {}
else if(ffParseUsersCommandOptions(&instance.config.users, key, value)) {}
else if(ffParseBluetoothCommandOptions(&instance.config.bluetooth, key, value)) {}
else if(ffParseSeparatorCommandOptions(&instance.config.separator, key, value)) {}
else if(ffParseSoundCommandOptions(&instance.config.sound, key, value)) {}
else if(ffParseGamepadCommandOptions(&instance.config.gamepad, key, value)) {}
else if(ffParseColorsCommandOptions(&instance.config.colors, key, value)) {}
else if(ffParseVulkanCommandOptions(&instance.config.vulkan, key, value)) {}
else if(ffParseWMCommandOptions(&instance.config.wm, key, value)) {}
else if(ffParseWMThemeCommandOptions(&instance.config.wmTheme, key, value)) {}
else if(ffParseWallpaperCommandOptions(&instance.config.wallpaper, key, value)) {}
else if(ffParseWeatherCommandOptions(&instance.config.weather, key, value)) {}
else if(ffParseWifiCommandOptions(&instance.config.wifi, key, value)) {}
///////////////////
//Library options//
@@ -1235,6 +1236,166 @@ static void parseArguments(FFdata* data, int argc, const char** argv)
}
}
static inline bool tryModule(const char* type, void* options)
{
FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options;
if (ffStrEqualsIgnCase(type, baseInfo->name))
{
baseInfo->printModule(options);
return true;
}
return false;
}
static bool parseModuleCommand(const char* type)
{
FFconfig* cfg = &instance.config;
switch (toupper(type[0]))
{
case 'B': {
return
tryModule(type, &cfg->battery) ||
tryModule(type, &cfg->bios) ||
tryModule(type, &cfg->bluetooth) ||
tryModule(type, &cfg->board) ||
tryModule(type, &cfg->break_) ||
tryModule(type, &cfg->brightness) ||
false;
}
case 'C': {
return
tryModule(type, &cfg->chassis) ||
tryModule(type, &cfg->command) ||
tryModule(type, &cfg->colors) ||
tryModule(type, &cfg->cpu) ||
tryModule(type, &cfg->cpuUsage) ||
tryModule(type, &cfg->cursor) ||
tryModule(type, &cfg->custom) ||
false;
}
case 'D': {
return
tryModule(type, &cfg->dateTime) ||
tryModule(type, &cfg->de) ||
tryModule(type, &cfg->display) ||
tryModule(type, &cfg->disk) ||
false;
}
case 'F': {
return
tryModule(type, &cfg->font) ||
false;
}
case 'G': {
return
tryModule(type, &cfg->gamepad) ||
tryModule(type, &cfg->gpu) ||
false;
}
case 'H': {
return
tryModule(type, &cfg->host) ||
false;
}
case 'I': {
return
tryModule(type, &cfg->icons) ||
false;
}
case 'K': {
return
tryModule(type, &cfg->kernel) ||
false;
}
case 'L': {
return
tryModule(type, &cfg->lm) ||
tryModule(type, &cfg->locale) ||
tryModule(type, &cfg->localIP) ||
false;
}
case 'M': {
return
tryModule(type, &cfg->media) ||
tryModule(type, &cfg->memory) ||
tryModule(type, &cfg->monitor) ||
false;
}
case 'O': {
return
tryModule(type, &cfg->openCL) ||
tryModule(type, &cfg->openGL) ||
tryModule(type, &cfg->os) ||
false;
}
case 'P': {
return
tryModule(type, &cfg->packages) ||
tryModule(type, &cfg->player) ||
tryModule(type, &cfg->powerAdapter) ||
tryModule(type, &cfg->processes) ||
tryModule(type, &cfg->publicIP) ||
false;
}
case 'S': {
return
tryModule(type, &cfg->separator) ||
tryModule(type, &cfg->shell) ||
tryModule(type, &cfg->sound) ||
tryModule(type, &cfg->swap) ||
false;
}
case 'T': {
return
tryModule(type, &cfg->terminal) ||
tryModule(type, &cfg->terminalFont) ||
tryModule(type, &cfg->terminalSize) ||
tryModule(type, &cfg->title) ||
tryModule(type, &cfg->theme) ||
false;
}
case 'U': {
return
tryModule(type, &cfg->uptime) ||
tryModule(type, &cfg->users) ||
false;
}
case 'V': {
return
tryModule(type, &cfg->vulkan) ||
false;
}
case 'W': {
return
tryModule(type, &cfg->wallpaper) ||
tryModule(type, &cfg->weather) ||
tryModule(type, &cfg->wm) ||
tryModule(type, &cfg->wifi) ||
tryModule(type, &cfg->wmTheme) ||
false;
}
default:
return false;
}
}
static void parseStructureCommand(const char* line, FFlist* customValues)
{
// handle `--set` and `--set-keyless`
@@ -1252,152 +1413,8 @@ static void parseStructureCommand(const char* line, FFlist* customValues)
}
}
switch (toupper(line[0]))
{
case 'B':
if(ffStrEqualsIgnCase(line, FF_BATTERY_MODULE_NAME))
return ffPrintBattery(&instance.config.battery);
if(ffStrEqualsIgnCase(line, FF_BIOS_MODULE_NAME))
return ffPrintBios(&instance.config.bios);
if(ffStrEqualsIgnCase(line, FF_BLUETOOTH_MODULE_NAME))
return ffPrintBluetooth(&instance.config.bluetooth);
if(ffStrEqualsIgnCase(line, FF_BOARD_MODULE_NAME))
return ffPrintBoard(&instance.config.board);
if(ffStrEqualsIgnCase(line, FF_BREAK_MODULE_NAME))
return ffPrintBreak();
if(ffStrEqualsIgnCase(line, FF_BRIGHTNESS_MODULE_NAME))
return ffPrintBrightness(&instance.config.brightness);
break;
case 'C':
if(ffStrEqualsIgnCase(line, FF_CHASSIS_MODULE_NAME))
return ffPrintChassis(&instance.config.chassis);
if(ffStrEqualsIgnCase(line, FF_COMMAND_MODULE_NAME))
return ffPrintCommand(&instance.config.command);
if(ffStrEqualsIgnCase(line, FF_CPU_MODULE_NAME))
return ffPrintCPU(&instance.config.cpu);
if(ffStrEqualsIgnCase(line, FF_CPUUSAGE_MODULE_NAME))
return ffPrintCPUUsage(&instance.config.cpuUsage);
if(ffStrEqualsIgnCase(line, FF_COLORS_MODULE_NAME))
return ffPrintColors(&instance.config.colors);
if(ffStrEqualsIgnCase(line, FF_CURSOR_MODULE_NAME))
return ffPrintCursor(&instance.config.cursor);
if(ffStrEqualsIgnCase(line, FF_CUSTOM_MODULE_NAME))
return ffPrintCustom(&instance.config.custom);
break;
case 'D':
if(ffStrEqualsIgnCase(line, FF_DATETIME_MODULE_NAME))
return ffPrintDateTime(&instance.config.dateTime);
if(ffStrEqualsIgnCase(line, FF_DE_MODULE_NAME))
return ffPrintDE(&instance.config.de);
if(ffStrEqualsIgnCase(line, FF_DISPLAY_MODULE_NAME))
return ffPrintDisplay(&instance.config.display);
if(ffStrEqualsIgnCase(line, FF_DISK_MODULE_NAME))
return ffPrintDisk(&instance.config.disk);
break;
case 'F':
if(ffStrEqualsIgnCase(line, FF_FONT_MODULE_NAME))
return ffPrintFont(&instance.config.font);
break;
case 'G':
if(ffStrEqualsIgnCase(line, FF_GAMEPAD_MODULE_NAME))
return ffPrintGamepad(&instance.config.gamepad);
if(ffStrEqualsIgnCase(line, FF_GPU_MODULE_NAME))
return ffPrintGPU(&instance.config.gpu);
break;
case 'H':
if(ffStrEqualsIgnCase(line, FF_HOST_MODULE_NAME))
return ffPrintHost(&instance.config.host);
break;
case 'I':
if(ffStrEqualsIgnCase(line, FF_ICONS_MODULE_NAME))
return ffPrintIcons(&instance.config.icons);
break;
case 'K':
if(ffStrEqualsIgnCase(line, FF_KERNEL_MODULE_NAME))
return ffPrintKernel(&instance.config.kernel);
break;
case 'L':
if(ffStrEqualsIgnCase(line, FF_LM_MODULE_NAME))
return ffPrintLM(&instance.config.lm);
if(ffStrEqualsIgnCase(line, FF_LOCALE_MODULE_NAME))
return ffPrintLocale(&instance.config.locale);
if(ffStrEqualsIgnCase(line, FF_LOCALIP_MODULE_NAME))
return ffPrintLocalIp(&instance.config.localIP);
break;
case 'M':
if(ffStrEqualsIgnCase(line, FF_MEDIA_MODULE_NAME))
return ffPrintMedia(&instance.config.media);
if(ffStrEqualsIgnCase(line, FF_MEMORY_MODULE_NAME))
return ffPrintMemory(&instance.config.memory);
if(ffStrEqualsIgnCase(line, FF_MONITOR_MODULE_NAME))
return ffPrintMonitor(&instance.config.nativeResolution);
break;
case 'O':
if(ffStrEqualsIgnCase(line, FF_OPENCL_MODULE_NAME))
return ffPrintOpenCL(&instance.config.openCL);
if(ffStrEqualsIgnCase(line, FF_OPENGL_MODULE_NAME))
return ffPrintOpenGL(&instance.config.openGL);
if(ffStrEqualsIgnCase(line, FF_OS_MODULE_NAME))
return ffPrintOS(&instance.config.os);
break;
case 'P':
if(ffStrEqualsIgnCase(line, FF_PACKAGES_MODULE_NAME))
return ffPrintPackages(&instance.config.packages);
if(ffStrEqualsIgnCase(line, FF_PLAYER_MODULE_NAME))
return ffPrintPlayer(&instance.config.player);
if(ffStrEqualsIgnCase(line, FF_POWERADAPTER_MODULE_NAME))
return ffPrintPowerAdapter(&instance.config.powerAdapter);
if(ffStrEqualsIgnCase(line, FF_PROCESSES_MODULE_NAME))
return ffPrintProcesses(&instance.config.processes);
if(ffStrEqualsIgnCase(line, FF_PUBLICIP_MODULE_NAME))
return ffPrintPublicIp(&instance.config.publicIP);
break;
case 'S':
if(ffStrEqualsIgnCase(line, FF_SEPARATOR_MODULE_NAME))
return ffPrintSeparator(&instance.config.separator);
if(ffStrEqualsIgnCase(line, FF_SHELL_MODULE_NAME))
return ffPrintShell(&instance.config.shell);
if(ffStrEqualsIgnCase(line, FF_SOUND_MODULE_NAME))
return ffPrintSound(&instance.config.sound);
if(ffStrEqualsIgnCase(line, FF_SWAP_MODULE_NAME))
return ffPrintSwap(&instance.config.swap);
break;
case 'T':
if(ffStrEqualsIgnCase(line, FF_TERMINAL_MODULE_NAME))
return ffPrintTerminal(&instance.config.terminal);
if(ffStrEqualsIgnCase(line, FF_TERMINALFONT_MODULE_NAME))
return ffPrintTerminalFont(&instance.config.terminalFont);
if(ffStrEqualsIgnCase(line, FF_TERMINALSIZE_MODULE_NAME))
return ffPrintTerminalSize(&instance.config.terminalSize);
if(ffStrEqualsIgnCase(line, FF_TITLE_MODULE_NAME))
return ffPrintTitle(&instance.config.title);
if(ffStrEqualsIgnCase(line, FF_THEME_MODULE_NAME))
return ffPrintTheme(&instance.config.theme);
break;
case 'U':
if(ffStrEqualsIgnCase(line, FF_UPTIME_MODULE_NAME))
return ffPrintUptime(&instance.config.uptime);
if(ffStrEqualsIgnCase(line, FF_USERS_MODULE_NAME))
return ffPrintUsers(&instance.config.users);
break;
case 'V':
if(ffStrEqualsIgnCase(line, FF_VULKAN_MODULE_NAME))
return ffPrintVulkan(&instance.config.vulkan);
break;
case 'W':
if(ffStrEqualsIgnCase(line, FF_WALLPAPER_MODULE_NAME))
return ffPrintWallpaper(&instance.config.wallpaper);
if(ffStrEqualsIgnCase(line, FF_WEATHER_MODULE_NAME))
return ffPrintWeather(&instance.config.weather);
if(ffStrEqualsIgnCase(line, FF_WIFI_MODULE_NAME))
return ffPrintWifi(&instance.config.wifi);
if(ffStrEqualsIgnCase(line, FF_WM_MODULE_NAME))
return ffPrintWM(&instance.config.wm);
if(ffStrEqualsIgnCase(line, FF_WMTHEME_MODULE_NAME))
return ffPrintWMTheme(&instance.config.wmTheme);
break;
}
ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
if(!parseModuleCommand(line))
ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
}
int main(int argc, const char** argv)
src/fastfetch.h
+2 -1
View File
@@ -117,7 +117,7 @@ typedef struct FFconfig
FFWeatherOptions weather;
FFPlayerOptions player;
FFMediaOptions media;
FFMonitorOptions nativeResolution;
FFMonitorOptions monitor;
FFDateTimeOptions dateTime;
FFVulkanOptions vulkan;
FFOpenGLOptions openGL;
@@ -127,6 +127,7 @@ typedef struct FFconfig
FFSeparatorOptions separator;
FFSoundOptions sound;
FFGamepadOptions gamepad;
FFBreakOptions break_;
FFColorsOptions colors;
FFstrbuf libPCI;
src/flashfetch.c
+1 -1
View File
@@ -62,7 +62,7 @@ int main(void)
//ffPrintBluetooth(&instance.config.bluetooth);
//ffPrintSound(&instance.config.sound);
//ffPrintGamepad(&instance.config.gamepad);
ffPrintBreak();
ffPrintBreak(&instance.config.break_);
ffPrintColors(&instance.config.colors);
ffFinish();
src/modules/battery/battery.c
+5 -10
View File
@@ -105,7 +105,7 @@ void ffPrintBattery(FFBatteryOptions* options)
void ffInitBatteryOptions(FFBatteryOptions* options)
{
options->moduleName = FF_BATTERY_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BATTERY_MODULE_NAME, ffParseBatteryCommandOptions, ffParseBatteryJsonObject, ffPrintBattery);
ffOptionInitModuleArg(&options->moduleArgs);
options->temp = false;
@@ -147,11 +147,8 @@ void ffDestroyBatteryOptions(FFBatteryOptions* options)
#endif
}
void ffParseBatteryJsonObject(yyjson_val* module)
void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module)
{
FFBatteryOptions __attribute__((__cleanup__(ffDestroyBatteryOptions))) options;
ffInitBatteryOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -162,7 +159,7 @@ void ffParseBatteryJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
#ifdef __linux__
@@ -175,13 +172,11 @@ void ffParseBatteryJsonObject(yyjson_val* module)
if (ffStrEqualsIgnCase(key, "temp"))
{
options.temp = yyjson_get_bool(val);
options->temp = yyjson_get_bool(val);
continue;
}
ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintBattery(&options);
}
src/modules/battery/battery.h
+1 -1
View File
@@ -9,4 +9,4 @@ void ffPrintBattery(FFBatteryOptions* options);
void ffInitBatteryOptions(FFBatteryOptions* options);
bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, const char* value);
void ffDestroyBatteryOptions(FFBatteryOptions* options);
void ffParseBatteryJsonObject(yyjson_val* module);
void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module);
src/modules/battery/option.h
+1 -1
View File
@@ -6,7 +6,7 @@
typedef struct FFBatteryOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
bool temp;
src/modules/bios/bios.c
+4 -9
View File
@@ -55,7 +55,7 @@ exit:
void ffInitBiosOptions(FFBiosOptions* options)
{
options->moduleName = FF_BIOS_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BIOS_MODULE_NAME, ffParseBiosCommandOptions, ffParseBiosJsonObject, ffPrintBios);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -74,11 +74,8 @@ void ffDestroyBiosOptions(FFBiosOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseBiosJsonObject(yyjson_val* module)
void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module)
{
FFBiosOptions __attribute__((__cleanup__(ffDestroyBiosOptions))) options;
ffInitBiosOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -89,12 +86,10 @@ void ffParseBiosJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_BIOS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintBios(&options);
}
src/modules/bios/bios.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintBios(FFBiosOptions* options);
void ffInitBiosOptions(FFBiosOptions* options);
bool ffParseBiosCommandOptions(FFBiosOptions* options, const char* key, const char* value);
void ffDestroyBiosOptions(FFBiosOptions* options);
void ffParseBiosJsonObject(yyjson_val* module);
void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module);
src/modules/bios/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFBiosOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFBiosOptions;
src/modules/bluetooth/bluetooth.c
+5 -10
View File
@@ -75,7 +75,7 @@ void ffPrintBluetooth(FFBluetoothOptions* options)
void ffInitBluetoothOptions(FFBluetoothOptions* options)
{
options->moduleName = FF_BLUETOOTH_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothCommandOptions, ffParseBluetoothJsonObject, ffPrintBluetooth);
ffOptionInitModuleArg(&options->moduleArgs);
options->showDisconnected = false;
}
@@ -101,11 +101,8 @@ void ffDestroyBluetoothOptions(FFBluetoothOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseBluetoothJsonObject(yyjson_val* module)
void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module)
{
FFBluetoothOptions __attribute__((__cleanup__(ffDestroyBluetoothOptions))) options;
ffInitBluetoothOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -116,18 +113,16 @@ void ffParseBluetoothJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
if (ffStrEqualsIgnCase(key, "showDisconnected"))
{
options.showDisconnected = yyjson_get_bool(val);
options->showDisconnected = yyjson_get_bool(val);
continue;
}
ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintBluetooth(&options);
}
src/modules/bluetooth/bluetooth.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintBluetooth(FFBluetoothOptions* options);
void ffInitBluetoothOptions(FFBluetoothOptions* options);
bool ffParseBluetoothCommandOptions(FFBluetoothOptions* options, const char* key, const char* value);
void ffDestroyBluetoothOptions(FFBluetoothOptions* options);
void ffParseBluetoothJsonObject(yyjson_val* module);
void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module);
src/modules/bluetooth/option.h
+1 -1
View File
@@ -6,7 +6,7 @@
typedef struct FFBluetoothOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
bool showDisconnected;
src/modules/board/board.c
+4 -9
View File
@@ -51,7 +51,7 @@ exit:
void ffInitBoardOptions(FFBoardOptions* options)
{
options->moduleName = FF_BOARD_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BOARD_MODULE_NAME, ffParseBoardCommandOptions, ffParseBoardJsonObject, ffPrintBoard);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -70,11 +70,8 @@ void ffDestroyBoardOptions(FFBoardOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseBoardJsonObject(yyjson_val* module)
void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module)
{
FFBoardOptions __attribute__((__cleanup__(ffDestroyBoardOptions))) options;
ffInitBoardOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseBoardJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_BOARD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintBoard(&options);
}
src/modules/board/board.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintBoard(FFBoardOptions* options);
void ffInitBoardOptions(FFBoardOptions* options);
bool ffParseBoardCommandOptions(FFBoardOptions* options, const char* key, const char* value);
void ffDestroyBoardOptions(FFBoardOptions* options);
void ffParseBoardJsonObject(yyjson_val* module);
void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module);
src/modules/board/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFBoardOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFBoardOptions;
src/modules/break/break.c
+18 -3
View File
@@ -1,13 +1,28 @@
#include "common/printing.h"
#include "modules/break/break.h"
void ffPrintBreak(void)
void ffPrintBreak(FF_MAYBE_UNUSED FFBreakOptions* options)
{
ffLogoPrintLine();
putchar('\n');
}
void ffParseBreakJsonObject(FF_MAYBE_UNUSED yyjson_val* module)
void ffInitBreakOptions(FF_MAYBE_UNUSED FFBreakOptions* options)
{
return ffPrintBreak();
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BREAK_MODULE_NAME, ffParseBreakCommandOptions, ffParseBreakJsonObject, ffPrintBreak);
}
bool ffParseBreakCommandOptions(FF_MAYBE_UNUSED FFBreakOptions* options, FF_MAYBE_UNUSED const char* key, FF_MAYBE_UNUSED const char* value)
{
return false;
}
void ffDestroyBreakOptions(FF_MAYBE_UNUSED FFBreakOptions* options)
{
}
void ffParseBreakJsonObject(FF_MAYBE_UNUSED FFBreakOptions* options, FF_MAYBE_UNUSED yyjson_val* module)
{
ffPrintBreak(options);
return;
}
src/modules/break/break.h
+5 -2
View File
@@ -4,5 +4,8 @@
#define FF_BREAK_MODULE_NAME "Break"
void ffPrintBreak();
void ffParseBreakJsonObject(yyjson_val* module);
void ffPrintBreak(FFBreakOptions* options);
void ffInitBreakOptions(FFBreakOptions* options);
bool ffParseBreakCommandOptions(FFBreakOptions* options, const char* key, const char* value);
void ffDestroyBreakOptions(FFBreakOptions* options);
void ffParseBreakJsonObject(FFBreakOptions* options, yyjson_val* module);
src/modules/break/option.h
+10
View File
@@ -0,0 +1,10 @@
#pragma once
// This file will be included in "fastfetch.h", do NOT put unnecessary things here
#include "common/option.h"
typedef struct FFBreakOptions
{
FFModuleBaseInfo moduleInfo;
} FFBreakOptions;
src/modules/brightness/brightness.c
+4 -9
View File
@@ -80,7 +80,7 @@ void ffPrintBrightness(FFBrightnessOptions* options)
void ffInitBrightnessOptions(FFBrightnessOptions* options)
{
options->moduleName = FF_BRIGHTNESS_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessCommandOptions, ffParseBrightnessJsonObject, ffPrintBrightness);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -99,11 +99,8 @@ void ffDestroyBrightnessOptions(FFBrightnessOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseBrightnessJsonObject(yyjson_val* module)
void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* module)
{
FFBrightnessOptions __attribute__((__cleanup__(ffDestroyBrightnessOptions))) options;
ffInitBrightnessOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -114,12 +111,10 @@ void ffParseBrightnessJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintBrightness(&options);
}
src/modules/brightness/brightness.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintBrightness(FFBrightnessOptions* options);
void ffInitBrightnessOptions(FFBrightnessOptions* options);
bool ffParseBrightnessCommandOptions(FFBrightnessOptions* options, const char* key, const char* value);
void ffDestroyBrightnessOptions(FFBrightnessOptions* options);
void ffParseBrightnessJsonObject(yyjson_val* module);
void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* module);
src/modules/brightness/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFBrightnessOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFBrightnessOptions;
src/modules/chassis/chassis.c
+4 -9
View File
@@ -52,7 +52,7 @@ exit:
void ffInitChassisOptions(FFChassisOptions* options)
{
options->moduleName = FF_CHASSIS_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CHASSIS_MODULE_NAME, ffParseChassisCommandOptions, ffParseChassisJsonObject, ffPrintChassis);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -71,11 +71,8 @@ void ffDestroyChassisOptions(FFChassisOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseChassisJsonObject(yyjson_val* module)
void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module)
{
FFChassisOptions __attribute__((__cleanup__(ffDestroyChassisOptions))) options;
ffInitChassisOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -86,12 +83,10 @@ void ffParseChassisJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintChassis(&options);
}
src/modules/chassis/chassis.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintChassis(FFChassisOptions* options);
void ffInitChassisOptions(FFChassisOptions* options);
bool ffParseChassisCommandOptions(FFChassisOptions* options, const char* key, const char* value);
void ffDestroyChassisOptions(FFChassisOptions* options);
void ffParseChassisJsonObject(yyjson_val* module);
void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module);
src/modules/chassis/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFChassisOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFChassisOptions;
src/modules/colors/colors.c
+4 -9
View File
@@ -57,7 +57,7 @@ void ffPrintColors(FFColorsOptions* options)
void ffInitColorsOptions(FFColorsOptions* options)
{
options->moduleName = FF_COLORS_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_COLORS_MODULE_NAME, ffParseColorsCommandOptions, ffParseColorsJsonObject, ffPrintColors);
options->symbol = FF_COLORS_SYMBOL_BLOCK;
options->paddingLeft = 0;
}
@@ -94,11 +94,8 @@ void ffDestroyColorsOptions(FF_MAYBE_UNUSED FFColorsOptions* options)
{
}
void ffParseColorsJsonObject(yyjson_val* module)
void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module)
{
FFColorsOptions __attribute__((__cleanup__(ffDestroyColorsOptions))) options;
ffInitColorsOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -124,19 +121,17 @@ void ffParseColorsJsonObject(yyjson_val* module)
if (error)
ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error);
else
options.symbol = (FFColorsSymbol) value;
options->symbol = (FFColorsSymbol) value;
continue;
}
if (ffStrEqualsIgnCase(key, "paddingLeft"))
{
options.paddingLeft = (uint32_t) yyjson_get_uint(val);
options->paddingLeft = (uint32_t) yyjson_get_uint(val);
continue;
}
ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key);
}
}
ffPrintColors(&options);
}
src/modules/colors/colors.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintColors(FFColorsOptions* options);
void ffInitColorsOptions(FFColorsOptions* options);
void ffDestroyColorsOptions(FFColorsOptions* options);
bool ffParseColorsCommandOptions(FFColorsOptions* options, const char* key, const char* value);
void ffParseColorsJsonObject(yyjson_val* module);
void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module);
src/modules/colors/option.h
+1 -1
View File
@@ -16,7 +16,7 @@ typedef enum FFColorsSymbol
typedef struct FFColorsOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFColorsSymbol symbol;
uint32_t paddingLeft;
} FFColorsOptions;
src/modules/command/command.c
+6 -11
View File
@@ -36,7 +36,7 @@ void ffPrintCommand(FFCommandOptions* options)
void ffInitCommandOptions(FFCommandOptions* options)
{
options->moduleName = FF_COMMAND_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_COMMAND_MODULE_NAME, ffParseCommandCommandOptions, ffParseCommandJsonObject, ffPrintCommand);
ffOptionInitModuleArg(&options->moduleArgs);
ffStrbufInitStatic(&options->shell,
@@ -79,11 +79,8 @@ void ffDestroyCommandOptions(FFCommandOptions* options)
ffStrbufDestroy(&options->text);
}
void ffParseCommandJsonObject(yyjson_val* module)
void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module)
{
FFCommandOptions __attribute__((__cleanup__(ffDestroyCommandOptions))) options;
ffInitCommandOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -94,24 +91,22 @@ void ffParseCommandJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
if (ffStrEqualsIgnCase(key, "shell"))
{
ffStrbufSetS(&options.shell, yyjson_get_str(val));
ffStrbufSetS(&options->shell, yyjson_get_str(val));
continue;
}
if (ffStrEqualsIgnCase(key, "text"))
{
ffStrbufSetS(&options.text, yyjson_get_str(val));
ffStrbufSetS(&options->text, yyjson_get_str(val));
continue;
}
ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintCommand(&options);
}
src/modules/command/command.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintCommand(FFCommandOptions* options);
void ffInitCommandOptions(FFCommandOptions* options);
bool ffParseCommandCommandOptions(FFCommandOptions* options, const char* key, const char* value);
void ffDestroyCommandOptions(FFCommandOptions* options);
void ffParseCommandJsonObject(yyjson_val* module);
void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module);
src/modules/command/option.h
+1 -1
View File
@@ -6,7 +6,7 @@
typedef struct FFCommandOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
FFstrbuf shell;
src/modules/cpu/cpu.c
+5 -10
View File
@@ -79,7 +79,7 @@ void ffPrintCPU(FFCPUOptions* options)
void ffInitCPUOptions(FFCPUOptions* options)
{
options->moduleName = FF_CPU_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CPU_MODULE_NAME, ffParseCPUCommandOptions, ffParseCPUJsonObject, ffPrintCPU);
ffOptionInitModuleArg(&options->moduleArgs);
options->temp = false;
}
@@ -105,11 +105,8 @@ void ffDestroyCPUOptions(FFCPUOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseCPUJsonObject(yyjson_val* module)
void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module)
{
FFCPUOptions __attribute__((__cleanup__(ffDestroyCPUOptions))) options;
ffInitCPUOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -120,18 +117,16 @@ void ffParseCPUJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
if (ffStrEqualsIgnCase(key, "temp"))
{
options.temp = yyjson_get_bool(val);
options->temp = yyjson_get_bool(val);
continue;
}
ffPrintError(FF_CPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintCPU(&options);
}
src/modules/cpu/cpu.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintCPU(FFCPUOptions* options);
void ffInitCPUOptions(FFCPUOptions* options);
bool ffParseCPUCommandOptions(FFCPUOptions* options, const char* key, const char* value);
void ffDestroyCPUOptions(FFCPUOptions* options);
void ffParseCPUJsonObject(yyjson_val* module);
void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module);
src/modules/cpu/option.h
+1 -1
View File
@@ -6,7 +6,7 @@
typedef struct FFCPUOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
bool temp;
src/modules/cpuusage/cpuusage.c
+4 -9
View File
@@ -44,7 +44,7 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options)
void ffInitCPUUsageOptions(FFCPUUsageOptions* options)
{
options->moduleName = FF_CPUUSAGE_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageCommandOptions, ffParseCPUUsageJsonObject, ffPrintCPUUsage);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -63,11 +63,8 @@ void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseCPUUsageJsonObject(yyjson_val* module)
void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module)
{
FFCPUUsageOptions __attribute__((__cleanup__(ffDestroyCPUUsageOptions))) options;
ffInitCPUUsageOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -78,12 +75,10 @@ void ffParseCPUUsageJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintCPUUsage(&options);
}
src/modules/cpuusage/cpuusage.h
+1 -1
View File
@@ -10,4 +10,4 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options);
void ffInitCPUUsageOptions(FFCPUUsageOptions* options);
bool ffParseCPUUsageCommandOptions(FFCPUUsageOptions* options, const char* key, const char* value);
void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options);
void ffParseCPUUsageJsonObject(yyjson_val* module);
void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module);
src/modules/cpuusage/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFCPUUsageOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFCPUUsageOptions;
src/modules/cursor/cursor.c
+4 -9
View File
@@ -52,7 +52,7 @@ void ffPrintCursor(FFCursorOptions* options)
void ffInitCursorOptions(FFCursorOptions* options)
{
options->moduleName = FF_CURSOR_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CURSOR_MODULE_NAME, ffParseCursorCommandOptions, ffParseCursorJsonObject, ffPrintCursor);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -71,11 +71,8 @@ void ffDestroyCursorOptions(FFCursorOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseCursorJsonObject(yyjson_val* module)
void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module)
{
FFCursorOptions __attribute__((__cleanup__(ffDestroyCursorOptions))) options;
ffInitCursorOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -86,12 +83,10 @@ void ffParseCursorJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintCursor(&options);
}
src/modules/cursor/cursor.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintCursor(FFCursorOptions* options);
void ffInitCursorOptions(FFCursorOptions* options);
bool ffParseCursorCommandOptions(FFCursorOptions* options, const char* key, const char* value);
void ffDestroyCursorOptions(FFCursorOptions* options);
void ffParseCursorJsonObject(yyjson_val* module);
void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module);
src/modules/cursor/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFCursorOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFCursorOptions;
src/modules/custom/custom.c
+4 -9
View File
@@ -19,7 +19,7 @@ void ffPrintCustom(FFCustomOptions* options)
void ffInitCustomOptions(FFCustomOptions* options)
{
options->moduleName = FF_CUSTOM_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CUSTOM_MODULE_NAME, ffParseCustomCommandOptions, ffParseCustomJsonObject, ffPrintCustom);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -38,11 +38,8 @@ void ffDestroyCustomOptions(FFCustomOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseCustomJsonObject(yyjson_val* module)
void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module)
{
FFCustomOptions __attribute__((__cleanup__(ffDestroyCustomOptions))) options;
ffInitCustomOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -53,12 +50,10 @@ void ffParseCustomJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintCustom(&options);
}
src/modules/custom/custom.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintCustom(FFCustomOptions* options);
void ffInitCustomOptions(FFCustomOptions* options);
bool ffParseCustomCommandOptions(FFCustomOptions* options, const char* key, const char* value);
void ffDestroyCustomOptions(FFCustomOptions* options);
void ffParseCustomJsonObject(yyjson_val* module);
void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module);
src/modules/custom/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFCustomOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFCustomOptions;
src/modules/datetime/datetime.c
+4 -9
View File
@@ -51,7 +51,7 @@ void ffPrintDateTime(FFDateTimeOptions* options)
void ffInitDateTimeOptions(FFDateTimeOptions* options)
{
options->moduleName = FF_DATETIME_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DATETIME_MODULE_NAME, ffParseDateTimeCommandOptions, ffParseDateTimeJsonObject, ffPrintDateTime);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -70,11 +70,8 @@ void ffDestroyDateTimeOptions(FFDateTimeOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseDateTimeJsonObject(yyjson_val* module)
void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module)
{
FFDateTimeOptions __attribute__((__cleanup__(ffDestroyDateTimeOptions))) options;
ffInitDateTimeOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseDateTimeJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintDateTime(&options);
}
src/modules/datetime/datetime.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintDateTime(FFDateTimeOptions* options);
void ffInitDateTimeOptions(FFDateTimeOptions* options);
bool ffParseDateTimeCommandOptions(FFDateTimeOptions* options, const char* key, const char* value);
void ffDestroyDateTimeOptions(FFDateTimeOptions* options);
void ffParseDateTimeJsonObject(yyjson_val* module);
void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module);
src/modules/datetime/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFDateTimeOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFDateTimeOptions;
src/modules/de/de.c
+4 -9
View File
@@ -42,7 +42,7 @@ void ffPrintDE(FFDEOptions* options)
void ffInitDEOptions(FFDEOptions* options)
{
options->moduleName = FF_DE_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DE_MODULE_NAME, ffParseDECommandOptions, ffParseDEJsonObject, ffPrintDE);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -61,11 +61,8 @@ void ffDestroyDEOptions(FFDEOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseDEJsonObject(yyjson_val* module)
void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module)
{
FFDEOptions __attribute__((__cleanup__(ffDestroyDEOptions))) options;
ffInitDEOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -76,12 +73,10 @@ void ffParseDEJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_DE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintDE(&options);
}
src/modules/de/de.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintDE(FFDEOptions* options);
void ffInitDEOptions(FFDEOptions* options);
bool ffParseDECommandOptions(FFDEOptions* options, const char* key, const char* value);
void ffDestroyDEOptions(FFDEOptions* options);
void ffParseDEJsonObject(yyjson_val* module);
void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module);
src/modules/de/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFDEOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFDEOptions;
src/modules/disk/disk.c
+13 -19
View File
@@ -184,10 +184,9 @@ void ffPrintDisk(FFDiskOptions* options)
}
}
void ffInitDiskOptions(FFDiskOptions* options)
{
options->moduleName = FF_DISK_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DISK_MODULE_NAME, ffParseDiskCommandOptions, ffParseDiskJsonObject, ffPrintDisk);
ffOptionInitModuleArg(&options->moduleArgs);
ffStrbufInit(&options->folders);
@@ -260,11 +259,8 @@ void ffDestroyDiskOptions(FFDiskOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseDiskJsonObject(yyjson_val* module)
void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module)
{
FFDiskOptions __attribute__((__cleanup__(ffDestroyDiskOptions))) options;
ffInitDiskOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -275,54 +271,52 @@ void ffParseDiskJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
if (ffStrEqualsIgnCase(key, "folders"))
{
ffStrbufSetS(&options.folders, yyjson_get_str(val));
ffStrbufSetS(&options->folders, yyjson_get_str(val));
continue;
}
if (ffStrEqualsIgnCase(key, "showExternal"))
{
if (yyjson_get_bool(val))
options.showTypes |= FF_DISK_TYPE_EXTERNAL_BIT;
options->showTypes |= FF_DISK_TYPE_EXTERNAL_BIT;
else
options.showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT;
options->showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "showHidden"))
{
if (yyjson_get_bool(val))
options.showTypes |= FF_DISK_TYPE_HIDDEN_BIT;
options->showTypes |= FF_DISK_TYPE_HIDDEN_BIT;
else
options.showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT;
options->showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "showSubvolumes"))
{
if (yyjson_get_bool(val))
options.showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT;
options->showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT;
else
options.showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT;
options->showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "showUnknown"))
{
if (yyjson_get_bool(val))
options.showTypes |= FF_DISK_TYPE_UNKNOWN_BIT;
options->showTypes |= FF_DISK_TYPE_UNKNOWN_BIT;
else
options.showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT;
options->showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT;
continue;
}
ffPrintError(FF_DISK_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintDisk(&options);
}
src/modules/disk/disk.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintDisk(FFDiskOptions* options);
void ffInitDiskOptions(FFDiskOptions* options);
bool ffParseDiskCommandOptions(FFDiskOptions* options, const char* key, const char* value);
void ffDestroyDiskOptions(FFDiskOptions* options);
void ffParseDiskJsonObject(yyjson_val* module);
void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module);
src/modules/disk/option.h
+1 -1
View File
@@ -16,7 +16,7 @@ typedef enum FFDiskType
typedef struct FFDiskOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
FFstrbuf folders;
src/modules/display/display.c
+7 -12
View File
@@ -109,7 +109,7 @@ void ffPrintDisplay(FFDisplayOptions* options)
void ffInitDisplayOptions(FFDisplayOptions* options)
{
options->moduleName = FF_DISPLAY_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DISPLAY_MODULE_NAME, ffParseDisplayCommandOptions, ffParseDisplayJsonObject, ffPrintDisplay);
ffOptionInitModuleArg(&options->moduleArgs);
options->compactType = FF_DISPLAY_COMPACT_TYPE_NONE;
options->preciseRefreshRate = false;
@@ -147,11 +147,8 @@ void ffDestroyDisplayOptions(FFDisplayOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseDisplayJsonObject(yyjson_val* module)
void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module)
{
FFDisplayOptions __attribute__((__cleanup__(ffDestroyDisplayOptions))) options;
ffInitDisplayOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -162,7 +159,7 @@ void ffParseDisplayJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
if (ffStrEqualsIgnCase(key, "compactType"))
@@ -175,21 +172,19 @@ void ffParseDisplayJsonObject(yyjson_val* module)
{},
});
if (error)
ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error);
else
options.compactType = (FFDisplayCompactType) value;
options->compactType = (FFDisplayCompactType) value;
continue;
}
if (ffStrEqualsIgnCase(key, "preciseRefreshRate"))
{
options.preciseRefreshRate = yyjson_get_bool(val);
options->preciseRefreshRate = yyjson_get_bool(val);
continue;
}
ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintDisplay(&options);
}
src/modules/display/display.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintDisplay(FFDisplayOptions* options);
void ffInitDisplayOptions(FFDisplayOptions* options);
bool ffParseDisplayCommandOptions(FFDisplayOptions* options, const char* key, const char* value);
void ffDestroyDisplayOptions(FFDisplayOptions* options);
void ffParseDisplayJsonObject(yyjson_val* module);
void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module);
src/modules/display/option.h
+1 -1
View File
@@ -13,7 +13,7 @@ typedef enum FFDisplayCompactType
typedef struct FFDisplayOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
FFDisplayCompactType compactType;
src/modules/font/font.c
+4 -9
View File
@@ -45,7 +45,7 @@ void ffPrintFont(FFFontOptions* options)
void ffInitFontOptions(FFFontOptions* options)
{
options->moduleName = FF_FONT_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_FONT_MODULE_NAME, ffParseFontCommandOptions, ffParseFontJsonObject, ffPrintFont);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -64,11 +64,8 @@ void ffDestroyFontOptions(FFFontOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseFontJsonObject(yyjson_val* module)
void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module)
{
FFFontOptions __attribute__((__cleanup__(ffDestroyFontOptions))) options;
ffInitFontOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -79,12 +76,10 @@ void ffParseFontJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_FONT_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintFont(&options);
}
src/modules/font/font.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintFont(FFFontOptions* options);
void ffInitFontOptions(FFFontOptions* options);
bool ffParseFontCommandOptions(FFFontOptions* options, const char* key, const char* value);
void ffDestroyFontOptions(FFFontOptions* options);
void ffParseFontJsonObject(yyjson_val* module);
void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module);
src/modules/font/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFFontOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFFontOptions;
src/modules/gamepad/gamepad.c
+4 -9
View File
@@ -51,7 +51,7 @@ void ffPrintGamepad(FFGamepadOptions* options)
void ffInitGamepadOptions(FFGamepadOptions* options)
{
options->moduleName = FF_GAMEPAD_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_GAMEPAD_MODULE_NAME, ffParseGamepadCommandOptions, ffParseGamepadJsonObject, ffPrintGamepad);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -70,11 +70,8 @@ void ffDestroyGamepadOptions(FFGamepadOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseGamepadJsonObject(yyjson_val* module)
void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module)
{
FFGamepadOptions __attribute__((__cleanup__(ffDestroyGamepadOptions))) options;
ffInitGamepadOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseGamepadJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintGamepad(&options);
}
src/modules/gamepad/gamepad.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintGamepad(FFGamepadOptions* options);
void ffInitGamepadOptions(FFGamepadOptions* options);
bool ffParseGamepadCommandOptions(FFGamepadOptions* options, const char* key, const char* value);
void ffDestroyGamepadOptions(FFGamepadOptions* options);
void ffParseGamepadJsonObject(yyjson_val* module);
void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module);
src/modules/gamepad/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFGamepadOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFGamepadOptions;
src/modules/gpu/gpu.c
+8 -13
View File
@@ -121,7 +121,7 @@ void ffPrintGPU(FFGPUOptions* options)
void ffInitGPUOptions(FFGPUOptions* options)
{
options->moduleName = FF_GPU_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_GPU_MODULE_NAME, ffParseGPUCommandOptions, ffParseGPUJsonObject, ffPrintGPU);
ffOptionInitModuleArg(&options->moduleArgs);
options->forceVulkan = false;
@@ -166,11 +166,8 @@ void ffDestroyGPUOptions(FFGPUOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseGPUJsonObject(yyjson_val* module)
void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module)
{
FFGPUOptions __attribute__((__cleanup__(ffDestroyGPUOptions))) options;
ffInitGPUOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -181,18 +178,18 @@ void ffParseGPUJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
if (ffStrEqualsIgnCase(key, "temp"))
{
options.temp = yyjson_get_bool(val);
options->temp = yyjson_get_bool(val);
continue;
}
if (ffStrEqualsIgnCase(key, "forceVulkan"))
{
options.forceVulkan = yyjson_get_bool(val);
options->forceVulkan = yyjson_get_bool(val);
continue;
}
@@ -206,15 +203,13 @@ void ffParseGPUJsonObject(yyjson_val* module)
{},
});
if (error)
ffPrintError(FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error);
else
options.hideType = (FFGPUType) value;
options->hideType = (FFGPUType) value;
continue;
}
ffPrintError(FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintGPU(&options);
}
src/modules/gpu/gpu.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintGPU(FFGPUOptions* options);
void ffInitGPUOptions(FFGPUOptions* options);
bool ffParseGPUCommandOptions(FFGPUOptions* options, const char* key, const char* value);
void ffDestroyGPUOptions(FFGPUOptions* options);
void ffParseGPUJsonObject(yyjson_val* module);
void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module);
src/modules/gpu/option.h
+1 -1
View File
@@ -13,7 +13,7 @@ typedef enum FFGPUType
typedef struct FFGPUOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
FFGPUType hideType;
src/modules/host/host.c
+4 -9
View File
@@ -67,7 +67,7 @@ exit:
void ffInitHostOptions(FFHostOptions* options)
{
options->moduleName = FF_HOST_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_HOST_MODULE_NAME, ffParseHostCommandOptions, ffParseHostJsonObject, ffPrintHost);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -86,11 +86,8 @@ void ffDestroyHostOptions(FFHostOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseHostJsonObject(yyjson_val* module)
void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module)
{
FFHostOptions __attribute__((__cleanup__(ffDestroyHostOptions))) options;
ffInitHostOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -101,12 +98,10 @@ void ffParseHostJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_HOST_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintHost(&options);
}
src/modules/host/host.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintHost(FFHostOptions* options);
void ffInitHostOptions(FFHostOptions* options);
bool ffParseHostCommandOptions(FFHostOptions* options, const char* key, const char* value);
void ffDestroyHostOptions(FFHostOptions* options);
void ffParseHostJsonObject(yyjson_val* module);
void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module);
src/modules/host/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFHostOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFHostOptions;
src/modules/icons/icons.c
+4 -9
View File
@@ -32,7 +32,7 @@ void ffPrintIcons(FFIconsOptions* options)
void ffInitIconsOptions(FFIconsOptions* options)
{
options->moduleName = FF_ICONS_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_ICONS_MODULE_NAME, ffParseIconsCommandOptions, ffParseIconsJsonObject, ffPrintIcons);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -51,11 +51,8 @@ void ffDestroyIconsOptions(FFIconsOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseIconsJsonObject(yyjson_val* module)
void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module)
{
FFIconsOptions __attribute__((__cleanup__(ffDestroyIconsOptions))) options;
ffInitIconsOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseIconsJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_ICONS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintIcons(&options);
}
src/modules/icons/icons.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintIcons(FFIconsOptions* options);
void ffInitIconsOptions(FFIconsOptions* options);
bool ffParseIconsCommandOptions(FFIconsOptions* options, const char* key, const char* value);
void ffDestroyIconsOptions(FFIconsOptions* options);
void ffParseIconsJsonObject(yyjson_val* module);
void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module);
src/modules/icons/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFIconsOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFIconsOptions;
src/modules/kernel/kernel.c
+4 -9
View File
@@ -32,7 +32,7 @@ void ffPrintKernel(FFKernelOptions* options)
void ffInitKernelOptions(FFKernelOptions* options)
{
options->moduleName = FF_KERNEL_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_KERNEL_MODULE_NAME, ffParseKernelCommandOptions, ffParseKernelJsonObject, ffPrintKernel);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -51,11 +51,8 @@ void ffDestroyKernelOptions(FFKernelOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseKernelJsonObject(yyjson_val* module)
void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module)
{
FFKernelOptions __attribute__((__cleanup__(ffDestroyKernelOptions))) options;
ffInitKernelOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseKernelJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintKernel(&options);
}
src/modules/kernel/kernel.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintKernel(FFKernelOptions* options);
void ffInitKernelOptions(FFKernelOptions* options);
bool ffParseKernelCommandOptions(FFKernelOptions* options, const char* key, const char* value);
void ffDestroyKernelOptions(FFKernelOptions* options);
void ffParseKernelJsonObject(yyjson_val* module);
void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module);
src/modules/kernel/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFKernelOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFKernelOptions;
src/modules/lm/lm.c
+4 -9
View File
@@ -51,7 +51,7 @@ void ffPrintLM(FFLMOptions* options)
void ffInitLMOptions(FFLMOptions* options)
{
options->moduleName = FF_LM_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LM_MODULE_NAME, ffParseLMCommandOptions, ffParseLMJsonObject, ffPrintLM);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -70,11 +70,8 @@ void ffDestroyLMOptions(FFLMOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseLMJsonObject(yyjson_val* module)
void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module)
{
FFLMOptions __attribute__((__cleanup__(ffDestroyLMOptions))) options;
ffInitLMOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseLMJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_LM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintLM(&options);
}
src/modules/lm/lm.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintLM(FFLMOptions* options);
void ffInitLMOptions(FFLMOptions* options);
bool ffParseLMCommandOptions(FFLMOptions* options, const char* key, const char* value);
void ffDestroyLMOptions(FFLMOptions* options);
void ffParseLMJsonObject(yyjson_val* module);
void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module);
src/modules/lm/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFLMOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFLMOptions;
src/modules/locale/locale.c
+4 -9
View File
@@ -32,7 +32,7 @@ void ffPrintLocale(FFLocaleOptions* options)
void ffInitLocaleOptions(FFLocaleOptions* options)
{
options->moduleName = FF_LOCALE_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LOCALE_MODULE_NAME, ffParseLocaleCommandOptions, ffParseLocaleJsonObject, ffPrintLocale);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -51,11 +51,8 @@ void ffDestroyLocaleOptions(FFLocaleOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseLocaleJsonObject(yyjson_val* module)
void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module)
{
FFLocaleOptions __attribute__((__cleanup__(ffDestroyLocaleOptions))) options;
ffInitLocaleOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseLocaleJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintLocale(&options);
}
src/modules/locale/locale.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintLocale(FFLocaleOptions* options);
void ffInitLocaleOptions(FFLocaleOptions* options);
bool ffParseLocaleCommandOptions(FFLocaleOptions* options, const char* key, const char* value);
void ffDestroyLocaleOptions(FFLocaleOptions* options);
void ffParseLocaleJsonObject(yyjson_val* module);
void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module);
src/modules/locale/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFLocaleOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFLocaleOptions;
src/modules/localip/localip.c
+16 -21
View File
@@ -139,7 +139,7 @@ void ffPrintLocalIp(FFLocalIpOptions* options)
void ffInitLocalIpOptions(FFLocalIpOptions* options)
{
options->moduleName = FF_LOCALIP_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LOCALIP_MODULE_NAME, ffParseLocalIpCommandOptions, ffParseLocalIpJsonObject, ffPrintLocalIp);
ffOptionInitModuleArg(&options->moduleArgs);
options->showType = FF_LOCALIP_TYPE_IPV4_BIT;
@@ -220,11 +220,8 @@ void ffDestroyLocalIpOptions(FFLocalIpOptions* options)
ffStrbufDestroy(&options->namePrefix);
}
void ffParseLocalIpJsonObject(yyjson_val* module)
void ffParseLocalIpJsonObject(FFLocalIpOptions* options, yyjson_val* module)
{
FFLocalIpOptions __attribute__((__cleanup__(ffDestroyLocalIpOptions))) options;
ffInitLocalIpOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -235,69 +232,67 @@ void ffParseLocalIpJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
if (ffStrEqualsIgnCase(key, "showIpv4"))
{
if (yyjson_get_bool(val))
options.showType |= FF_LOCALIP_TYPE_IPV4_BIT;
options->showType |= FF_LOCALIP_TYPE_IPV4_BIT;
else
options.showType &= ~FF_LOCALIP_TYPE_IPV4_BIT;
options->showType &= ~FF_LOCALIP_TYPE_IPV4_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "showIpv6"))
{
if (yyjson_get_bool(val))
options.showType |= FF_LOCALIP_TYPE_IPV6_BIT;
options->showType |= FF_LOCALIP_TYPE_IPV6_BIT;
else
options.showType &= ~FF_LOCALIP_TYPE_IPV6_BIT;
options->showType &= ~FF_LOCALIP_TYPE_IPV6_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "showMac"))
{
if (yyjson_get_bool(val))
options.showType |= FF_LOCALIP_TYPE_MAC_BIT;
options->showType |= FF_LOCALIP_TYPE_MAC_BIT;
else
options.showType &= ~FF_LOCALIP_TYPE_MAC_BIT;
options->showType &= ~FF_LOCALIP_TYPE_MAC_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "showLoop"))
{
if (yyjson_get_bool(val))
options.showType |= FF_LOCALIP_TYPE_LOOP_BIT;
options->showType |= FF_LOCALIP_TYPE_LOOP_BIT;
else
options.showType &= ~FF_LOCALIP_TYPE_LOOP_BIT;
options->showType &= ~FF_LOCALIP_TYPE_LOOP_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "compact"))
{
if (yyjson_get_bool(val))
options.showType |= FF_LOCALIP_TYPE_COMPACT_BIT;
options->showType |= FF_LOCALIP_TYPE_COMPACT_BIT;
else
options.showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT;
options->showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT;
continue;
}
if (ffStrEqualsIgnCase(key, "namePrefix"))
{
ffStrbufSetS(&options.namePrefix, yyjson_get_str(val));
ffStrbufSetS(&options->namePrefix, yyjson_get_str(val));
continue;
}
if (ffStrEqualsIgnCase(key, "defaultRouteOnly"))
{
options.defaultRouteOnly = yyjson_get_bool(val);
options->defaultRouteOnly = yyjson_get_bool(val);
continue;
}
ffPrintError(FF_LOCALIP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_LOCALIP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintLocalIp(&options);
}
src/modules/localip/localip.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintLocalIp(FFLocalIpOptions* options);
void ffInitLocalIpOptions(FFLocalIpOptions* options);
bool ffParseLocalIpCommandOptions(FFLocalIpOptions* options, const char* key, const char* value);
void ffDestroyLocalIpOptions(FFLocalIpOptions* options);
void ffParseLocalIpJsonObject(yyjson_val* module);
void ffParseLocalIpJsonObject(FFLocalIpOptions* options, yyjson_val* module);
src/modules/localip/option.h
+1 -1
View File
@@ -17,7 +17,7 @@ typedef enum FFLocalIpType
typedef struct FFLocalIpOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
FFLocalIpType showType;
src/modules/media/media.c
+4 -9
View File
@@ -107,7 +107,7 @@ void ffPrintMedia(FFMediaOptions* options)
void ffInitMediaOptions(FFMediaOptions* options)
{
options->moduleName = FF_MEDIA_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MEDIA_MODULE_NAME, ffParseMediaCommandOptions, ffParseMediaJsonObject, ffPrintMedia);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -126,11 +126,8 @@ void ffDestroyMediaOptions(FFMediaOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseMediaJsonObject(yyjson_val* module)
void ffParseMediaJsonObject(FFMediaOptions* options, yyjson_val* module)
{
FFMediaOptions __attribute__((__cleanup__(ffDestroyMediaOptions))) options;
ffInitMediaOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -141,12 +138,10 @@ void ffParseMediaJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintMedia(&options);
}
src/modules/media/media.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintMedia(FFMediaOptions* options);
void ffInitMediaOptions(FFMediaOptions* options);
bool ffParseMediaCommandOptions(FFMediaOptions* options, const char* key, const char* value);
void ffDestroyMediaOptions(FFMediaOptions* options);
void ffParseMediaJsonObject(yyjson_val* module);
void ffParseMediaJsonObject(FFMediaOptions* options, yyjson_val* module);
src/modules/media/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFMediaOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFMediaOptions;
src/modules/memory/memory.c
+4 -9
View File
@@ -66,7 +66,7 @@ void ffPrintMemory(FFMemoryOptions* options)
void ffInitMemoryOptions(FFMemoryOptions* options)
{
options->moduleName = FF_MEMORY_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MEMORY_MODULE_NAME, ffParseMemoryCommandOptions, ffParseMemoryJsonObject, ffPrintMemory);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -85,11 +85,8 @@ void ffDestroyMemoryOptions(FFMemoryOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseMemoryJsonObject(yyjson_val* module)
void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module)
{
FFMemoryOptions __attribute__((__cleanup__(ffDestroyMemoryOptions))) options;
ffInitMemoryOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -100,12 +97,10 @@ void ffParseMemoryJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintMemory(&options);
}
src/modules/memory/memory.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintMemory(FFMemoryOptions* options);
void ffInitMemoryOptions(FFMemoryOptions* options);
bool ffParseMemoryCommandOptions(FFMemoryOptions* options, const char* key, const char* value);
void ffDestroyMemoryOptions(FFMemoryOptions* options);
void ffParseMemoryJsonObject(yyjson_val* module);
void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module);
src/modules/memory/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFMemoryOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFMemoryOptions;
src/modules/monitor/monitor.c
+4 -9
View File
@@ -77,7 +77,7 @@ void ffPrintMonitor(FFMonitorOptions* options)
void ffInitMonitorOptions(FFMonitorOptions* options)
{
options->moduleName = FF_MONITOR_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MONITOR_MODULE_NAME, ffParseMonitorCommandOptions, ffParseMonitorJsonObject, ffPrintMonitor);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -96,11 +96,8 @@ void ffDestroyMonitorOptions(FFMonitorOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseMonitorJsonObject(yyjson_val* module)
void ffParseMonitorJsonObject(FFMonitorOptions* options, yyjson_val* module)
{
FFMonitorOptions __attribute__((__cleanup__(ffDestroyMonitorOptions))) options;
ffInitMonitorOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -111,12 +108,10 @@ void ffParseMonitorJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintMonitor(&options);
}
src/modules/monitor/monitor.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintMonitor(FFMonitorOptions* options);
void ffInitMonitorOptions(FFMonitorOptions* options);
bool ffParseMonitorCommandOptions(FFMonitorOptions* options, const char* key, const char* value);
void ffDestroyMonitorOptions(FFMonitorOptions* options);
void ffParseMonitorJsonObject(yyjson_val* module);
void ffParseMonitorJsonObject(FFMonitorOptions* options, yyjson_val* module);
src/modules/monitor/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFMonitorOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFMonitorOptions;
src/modules/opencl/opencl.c
+4 -9
View File
@@ -41,7 +41,7 @@ void ffPrintOpenCL(FFOpenCLOptions* options)
void ffInitOpenCLOptions(FFOpenCLOptions* options)
{
options->moduleName = FF_OPENCL_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OPENCL_MODULE_NAME, ffParseOpenCLCommandOptions, ffParseOpenCLJsonObject, ffPrintOpenCL);
ffOptionInitModuleArg(&options->moduleArgs);
}
@@ -60,11 +60,8 @@ void ffDestroyOpenCLOptions(FFOpenCLOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseOpenCLJsonObject(yyjson_val* module)
void ffParseOpenCLJsonObject(FFOpenCLOptions* options, yyjson_val* module)
{
FFOpenCLOptions __attribute__((__cleanup__(ffDestroyOpenCLOptions))) options;
ffInitOpenCLOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -75,12 +72,10 @@ void ffParseOpenCLJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintOpenCL(&options);
}
src/modules/opencl/opencl.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintOpenCL(FFOpenCLOptions* options);
void ffInitOpenCLOptions(FFOpenCLOptions* options);
bool ffParseOpenCLCommandOptions(FFOpenCLOptions* options, const char* key, const char* value);
void ffDestroyOpenCLOptions(FFOpenCLOptions* options);
void ffParseOpenCLJsonObject(yyjson_val* module);
void ffParseOpenCLJsonObject(FFOpenCLOptions* options, yyjson_val* module);
src/modules/opencl/option.h
+1 -1
View File
@@ -6,6 +6,6 @@
typedef struct FFOpenCLOptions
{
const char* moduleName;
FFModuleBaseInfo moduleInfo;
FFModuleArgs moduleArgs;
} FFOpenCLOptions;
src/modules/opengl/opengl.c
+6 -11
View File
@@ -44,7 +44,7 @@ void ffPrintOpenGL(FFOpenGLOptions* options)
void ffInitOpenGLOptions(FFOpenGLOptions* options)
{
options->moduleName = FF_OPENGL_MODULE_NAME;
ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OPENGL_MODULE_NAME, ffParseOpenGLCommandOptions, ffParseOpenGLJsonObject, ffPrintOpenGL);
ffOptionInitModuleArg(&options->moduleArgs);
#if defined(__linux__) || defined(__FreeBSD__)
@@ -80,11 +80,8 @@ void ffDestroyOpenGLOptions(FFOpenGLOptions* options)
ffOptionDestroyModuleArg(&options->moduleArgs);
}
void ffParseOpenGLJsonObject(yyjson_val* module)
void ffParseOpenGLJsonObject(FFOpenGLOptions* options, yyjson_val* module)
{
FFOpenGLOptions __attribute__((__cleanup__(ffDestroyOpenGLOptions))) options;
ffInitOpenGLOptions(&options);
if (module)
{
yyjson_val *key_, *val;
@@ -95,7 +92,7 @@ void ffParseOpenGLJsonObject(yyjson_val* module)
if(ffStrEqualsIgnCase(key, "type"))
continue;
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
continue;
#if defined(__linux__) || defined(__FreeBSD__)
@@ -110,16 +107,14 @@ void ffParseOpenGLJsonObject(yyjson_val* module)
{},
});
if (error)
ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error);
else
options.library = (FFOpenGLLibrary) value;
options->library = (FFOpenGLLibrary) value;
continue;
}
#endif
ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintOpenGL(&options);
}
src/modules/opengl/opengl.h
+1 -1
View File
@@ -8,4 +8,4 @@ void ffPrintOpenGL(FFOpenGLOptions* options);
void ffInitOpenGLOptions(FFOpenGLOptions* options);
bool ffParseOpenGLCommandOptions(FFOpenGLOptions* options, const char* key, const char* value);
void ffDestroyOpenGLOptions(FFOpenGLOptions* options);
void ffParseOpenGLJsonObject(yyjson_val* module);
void ffParseOpenGLJsonObject(FFOpenGLOptions* options, yyjson_val* module);

Some files were not shown because too many files have changed in this diff Show More