mirror of
https://github.com/Dr-Noob/cpufetch.git
synced 2026-03-25 07:50:40 +01:00
266 lines
6.5 KiB
C
266 lines
6.5 KiB
C
#include <getopt.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "args.h"
|
|
#include "global.h"
|
|
|
|
#define COLOR_STR_INTEL "intel"
|
|
#define COLOR_STR_AMD "amd"
|
|
#define COLOR_STR_ARM "arm"
|
|
|
|
static const char *SYTLES_STR_LIST[] = {
|
|
[STYLE_EMPTY] = NULL,
|
|
[STYLE_FANCY] = "fancy",
|
|
[STYLE_RETRO] = "retro",
|
|
[STYLE_LEGACY] = "legacy",
|
|
[STYLE_INVALID] = NULL
|
|
};
|
|
|
|
enum {
|
|
ARG_CHAR_STYLE,
|
|
ARG_CHAR_COLOR,
|
|
ARG_CHAR_HELP,
|
|
#ifdef ARCH_X86
|
|
ARG_CHAR_LEVELS,
|
|
#endif
|
|
ARG_CHAR_VERBOSE,
|
|
ARG_CHAR_VERSION
|
|
};
|
|
|
|
struct args_struct {
|
|
bool levels_flag;
|
|
bool help_flag;
|
|
bool verbose_flag;
|
|
bool version_flag;
|
|
STYLE style;
|
|
struct colors* colors;
|
|
};
|
|
|
|
static struct args_struct args;
|
|
|
|
STYLE get_style() {
|
|
return args.style;
|
|
}
|
|
|
|
struct colors* get_colors() {
|
|
return args.colors;
|
|
}
|
|
|
|
bool show_help() {
|
|
return args.help_flag;
|
|
}
|
|
|
|
bool show_version() {
|
|
return args.version_flag;
|
|
}
|
|
|
|
bool show_levels() {
|
|
return args.levels_flag;
|
|
}
|
|
|
|
bool verbose_enabled() {
|
|
return args.verbose_flag;
|
|
}
|
|
|
|
STYLE parse_style(char* style) {
|
|
uint8_t i = 0;
|
|
uint8_t styles_count = sizeof(SYTLES_STR_LIST) / sizeof(SYTLES_STR_LIST[0]);
|
|
|
|
while(i != styles_count && (SYTLES_STR_LIST[i] == NULL || strcmp(SYTLES_STR_LIST[i], style) != 0))
|
|
i++;
|
|
|
|
if(i == styles_count)
|
|
return STYLE_INVALID;
|
|
|
|
return i;
|
|
}
|
|
|
|
void free_colors_struct(struct colors* cs) {
|
|
free(cs->c1);
|
|
free(cs->c2);
|
|
free(cs->c3);
|
|
free(cs->c4);
|
|
free(cs);
|
|
}
|
|
|
|
bool parse_color(char* optarg_str, struct colors** cs) {
|
|
*cs = malloc(sizeof(struct colors));
|
|
(*cs)->c1 = malloc(sizeof(struct color));
|
|
(*cs)->c2 = malloc(sizeof(struct color));
|
|
(*cs)->c3 = malloc(sizeof(struct color));
|
|
(*cs)->c4 = malloc(sizeof(struct color));
|
|
struct color** c1 = &((*cs)->c1);
|
|
struct color** c2 = &((*cs)->c2);
|
|
struct color** c3 = &((*cs)->c3);
|
|
struct color** c4 = &((*cs)->c4);
|
|
int32_t ret;
|
|
char* str_to_parse = NULL;
|
|
bool free_ptr;
|
|
|
|
if(strcmp(optarg_str, COLOR_STR_INTEL) == 0) {
|
|
str_to_parse = malloc(sizeof(char) * 46);
|
|
strcpy(str_to_parse, COLOR_DEFAULT_INTEL);
|
|
free_ptr = true;
|
|
}
|
|
else if(strcmp(optarg_str, COLOR_STR_AMD) == 0) {
|
|
str_to_parse = malloc(sizeof(char) * 44);
|
|
strcpy(str_to_parse, COLOR_DEFAULT_AMD);
|
|
free_ptr = true;
|
|
}
|
|
else if(strcmp(optarg_str, COLOR_STR_ARM) == 0) {
|
|
str_to_parse = malloc(sizeof(char) * 46);
|
|
strcpy(str_to_parse, COLOR_DEFAULT_ARM);
|
|
free_ptr = true;
|
|
}
|
|
else {
|
|
str_to_parse = optarg_str;
|
|
free_ptr = false;
|
|
}
|
|
|
|
ret = sscanf(str_to_parse, "%d,%d,%d:%d,%d,%d:%d,%d,%d:%d,%d,%d",
|
|
&(*c1)->R, &(*c1)->G, &(*c1)->B,
|
|
&(*c2)->R, &(*c2)->G, &(*c2)->B,
|
|
&(*c3)->R, &(*c3)->G, &(*c3)->B,
|
|
&(*c4)->R, &(*c4)->G, &(*c4)->B);
|
|
|
|
if(ret != 12) {
|
|
printErr("Expected to read 12 values for color but read %d", ret);
|
|
return false;
|
|
}
|
|
|
|
//TODO: Refactor c1->R c2->R ... to c[i]->R
|
|
if((*c1)->R < 0 || (*c1)->R > 255) {
|
|
printErr("Red in color 1 is invalid. Must be in range (0, 255)");
|
|
return false;
|
|
}
|
|
if((*c1)->G < 0 || (*c1)->G > 255) {
|
|
printErr("Green in color 1 is invalid. Must be in range (0, 255)");
|
|
return false;
|
|
}
|
|
if((*c1)->B < 0 || (*c1)->B > 255) {
|
|
printErr("Blue in color 1 is invalid. Must be in range (0, 255)");
|
|
return false;
|
|
}
|
|
if((*c2)->R < 0 || (*c2)->R > 255) {
|
|
printErr("Red in color 2 is invalid. Must be in range (0, 255)");
|
|
return false;
|
|
}
|
|
if((*c2)->G < 0 || (*c2)->G > 255) {
|
|
printErr("Green in color 2 is invalid. Must be in range (0, 255)");
|
|
return false;
|
|
}
|
|
if((*c2)->B < 0 || (*c2)->B > 255) {
|
|
printErr("Blue in color 2 is invalid. Must be in range (0, 255)");
|
|
return false;
|
|
}
|
|
|
|
if(free_ptr) free (str_to_parse);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool parse_args(int argc, char* argv[]) {
|
|
int c;
|
|
int option_index = 0;
|
|
opterr = 0;
|
|
|
|
bool color_flag = false;
|
|
args.levels_flag = false;
|
|
args.verbose_flag = false;
|
|
args.help_flag = false;
|
|
args.style = STYLE_EMPTY;
|
|
args.colors = NULL;
|
|
|
|
static struct option long_options[] = {
|
|
{"style", required_argument, 0, ARG_CHAR_STYLE },
|
|
{"color", required_argument, 0, ARG_CHAR_COLOR },
|
|
{"help", no_argument, 0, ARG_CHAR_HELP },
|
|
#ifdef ARCH_X86
|
|
{"levels", no_argument, 0, ARG_CHAR_LEVELS },
|
|
#endif
|
|
{"verbose", no_argument, 0, ARG_CHAR_VERBOSE },
|
|
{"version", no_argument, 0, ARG_CHAR_VERSION },
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
c = getopt_long(argc, argv, "", long_options, &option_index);
|
|
|
|
while (c != -1) {
|
|
if(c == ARG_CHAR_COLOR) {
|
|
if(color_flag) {
|
|
printErr("Color option specified more than once");
|
|
return false;
|
|
}
|
|
color_flag = true;
|
|
if(!parse_color(optarg, &args.colors)) {
|
|
printErr("Color parsing failed");
|
|
return false;
|
|
}
|
|
}
|
|
else if(c == ARG_CHAR_STYLE) {
|
|
if(args.style != STYLE_EMPTY) {
|
|
printErr("Style option specified more than once");
|
|
return false;
|
|
}
|
|
args.style = parse_style(optarg);
|
|
if(args.style == STYLE_INVALID) {
|
|
printErr("Invalid style '%s'",optarg);
|
|
return false;
|
|
}
|
|
}
|
|
else if(c == ARG_CHAR_HELP) {
|
|
if(args.help_flag) {
|
|
printErr("Help option specified more than once");
|
|
return false;
|
|
}
|
|
args.help_flag = true;
|
|
}
|
|
else if(c == ARG_CHAR_VERBOSE) {
|
|
if(args.verbose_flag) {
|
|
printErr("Verbose option specified more than once");
|
|
return false;
|
|
}
|
|
args.verbose_flag = true;
|
|
}
|
|
#ifdef ARCH_X86
|
|
else if(c == ARG_CHAR_LEVELS) {
|
|
if(args.levels_flag) {
|
|
printErr("Levels option specified more than once");
|
|
return false;
|
|
}
|
|
args.levels_flag = true;
|
|
}
|
|
#endif
|
|
else if (c == ARG_CHAR_VERSION) {
|
|
if(args.version_flag) {
|
|
printErr("Version option specified more than once");
|
|
return false;
|
|
}
|
|
args.version_flag = true;
|
|
}
|
|
else if(c == '?') {
|
|
printWarn("Invalid options");
|
|
args.help_flag = true;
|
|
break;
|
|
}
|
|
else
|
|
printBug("Bug at line number %d in file %s", __LINE__, __FILE__);
|
|
|
|
option_index = 0;
|
|
c = getopt_long(argc, argv,"",long_options, &option_index);
|
|
}
|
|
|
|
if (optind < argc) {
|
|
printWarn("Invalid options");
|
|
args.help_flag = true;
|
|
}
|
|
|
|
if((args.help_flag + args.version_flag + color_flag) > 1) {
|
|
printWarn("You should specify just one option");
|
|
args.help_flag = true;
|
|
}
|
|
|
|
return true;
|
|
}
|