commit b40156ba4b58d50eb8b4af6f65950e91115e5d83 Author: Unbewohnte Date: Sat Dec 17 18:32:06 2022 +0300 initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1b005d2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/bin +/.vscode +test \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0a04128 --- /dev/null +++ b/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..c07c191 --- /dev/null +++ b/Makefile @@ -0,0 +1,26 @@ +CC:=gcc +CFLAGS:=-O2 -Wall -Werror +LIBNAME:=flagok +LIBNAMESHARED:=$(LIBNAME).so +LIBNAMESTATIC:=$(LIBNAME).a +SRC:=src/flagok.c +BINDIR:=bin +TESTSRC:=testing/test.c +TESTBIN:=test + +shared: + mkdir -p $(BINDIR) && \ + $(CC) $(SRC) $(CFLAGS) -shared -fPIC -o $(BINDIR)/$(LIBNAMESHARED) + +static: + mkdir -p $(BINDIR) && \ + $(CC) $(SRC) $(CFLAGS) -c && \ + ar rcs $(BINDIR)/$(LIBNAMESTATIC) *.o && \ + rm *.o + +test: static + $(CC) $(CFLAGS) -static $(TESTSRC) $(BINDIR)/$(LIBNAMESTATIC) -o $(TESTBIN) && \ + ./test + +clean: + rm -rf $(BINDIR) $(TESTBIN) *.o \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..83267e1 --- /dev/null +++ b/README.md @@ -0,0 +1,11 @@ +# flagok (флажок) - C/C++ command line flags library + +## Installation + + +## Usage + +### Example + +## License +LGPLv3 \ No newline at end of file diff --git a/src/flagok.c b/src/flagok.c new file mode 100644 index 0000000..53f24ca --- /dev/null +++ b/src/flagok.c @@ -0,0 +1,252 @@ +/* +FLAGOK - C/C++ command line flags library +Copyright (C) 2022 Kasyanov Nikolay Alexeyevich (Unbewohnte) + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + +#include "flagok.h" + +flag_collector_t* collector = NULL; + +// Create a new flag collector on heap (should not be called outside of library) +flag_collector_t* flag_new_collector() { + flag_collector_t* new_collector; + new_collector = (flag_collector_t*) malloc(sizeof(flag_collector_t)); + new_collector->count = 0; + + // add default help flag + new_collector->flags[new_collector->count] = (flag_t) { + name: FLAGHELP, + value_type: BOOL, + value: false, + description: "Print this help message" + }; + new_collector->count++; + + return new_collector; +} + +// Free flag collector +void flag_free_collector() { + if (collector) { + free(collector); + } +} + +// Create a new flag and put it in the collector, if it does not exist - creates a new one +void flag(void* value, ValueType type , const char* name, const char* description) { + flag_t new_bool_flag = (flag_t) { + name: name, + value_type: type, + value: value, + description: description, + }; + + if (!collector) { + collector = flag_new_collector(); + } + + if (collector) { + collector->flags[collector->count] = new_bool_flag; + collector->count++; + } +} + +// Register a boolean flag +void flag_bool(bool* value, const char* name, const char* description) { + flag(value, BOOL, name, description); +} + +// Register an integer (long long) flag +void flag_int(long long* value, const char* name, const char* description) { + flag(value, INT, name, description); +} + +// Register an unsigned integer (unsigned long long) flag +void flag_uint(unsigned long long* value, const char* name, const char* description) { + flag(value, UINT, name, description); +} + +// Register an double (long double) flag +void flag_double(long double* value, const char* name, const char* description) { + flag(value, DOUBLE, name, description); +} + +// Register a string flag +void flag_str(char** value, const char* name, const char* description) { + flag(value, STRING, name, description); +} + +// Parse flags and assign new values if present +void flag_parse(int argc, char** argv) { + int collector_index, arg_index; + flag_t flag; + char* arg; + + arg_index = 1; + while (arg_index < argc) { + arg = argv[arg_index]; + + for (collector_index = 0; (unsigned int) collector_index < collector->count; collector_index++) { + flag = collector->flags[collector_index]; + + // compare arugument with each flag's name + if (strcmp(arg, flag.name) == 0) { + // that's a match ! + switch (flag.value_type) { + case INT: { + if (arg_index+1 >= argc) { + break; + } + arg_index++; + arg = argv[arg_index]; + + long long value; + value = strtoll(arg, NULL, 0); + if (value == LLONG_MAX || value == LLONG_MIN) { + break; + } + + *(long long*) flag.value = value; + break; + } + case UINT: { + if (arg_index+1 >= argc) { + break; + } + arg_index++; + arg = argv[arg_index]; + + unsigned long long value; + value = strtoull(arg, NULL, 0); + if (value == ULLONG_MAX) { + break; + } + + *(unsigned long long*) flag.value = value; + break; + } + case BOOL: { + bool value = true; + if (arg_index+1 >= argc) { + break; + } + + if (strcmp(argv[arg_index+1], "true") == 0 || strcmp(argv[arg_index+1], "1") == 0) { + value = true; + } else if (strcmp(argv[arg_index+1], "false") == 0 || strcmp(argv[arg_index+1], "0") == 0) { + value = false; + } + + *(bool*) flag.value = value; + break; + } + case DOUBLE: { + if (arg_index+1 >= argc) { + break; + } + arg_index++; + arg = argv[arg_index]; + + long double value; + if (sscanf(arg, "%Lf", &value) != 0) { + *(long double*) flag.value = value; + } + break; + } + case STRING: { + if (arg_index+1 >= argc) { + break; + } + arg_index++; + arg = argv[arg_index]; + + char* value = arg; + + *(char**) flag.value = value; + break; + } + } + + // check if it's a help message + if (strcmp(flag.name, FLAGHELP) == 0) { + flag_print_help(stdout); + } + } + } + arg_index++; + } +} + +// Print help message containing information about registered flags +void flag_print_help(FILE* output) { + unsigned int i; + flag_t flag; + + fprintf(output, "Usage:\n"); + + for (i = 0; i < collector->count; i++) { + flag = collector->flags[i]; + if (strcmp(flag.name, FLAGHELP) == 0) { + continue; + } + + switch (flag.value_type) { + case BOOL: { + fprintf(output, "%s (bool) [default: %s]\n\t%s\n", + flag.name, + *(bool*) flag.value ? "true" : "false", + flag.description + ); + break; + } + case INT: { + fprintf(output, "%s (int) [default: %lld]\n\t%s\n", + flag.name, + *(long long*) flag.value, + flag.description + ); + break; + } + case UINT: { + fprintf(output, "%s (uint) [default: %lld]\n\t%s\n", + flag.name, + *(unsigned long long*) flag.value, + flag.description + ); + break; + } + case DOUBLE: { + fprintf(output, "%s (double) [default: %Lf]\n\t%s\n", + flag.name, + *(long double*) flag.value, + flag.description + ); + break; + } + case STRING: { + fprintf(output, "%s (string) [default: %s]\n\t%s\n", + flag.name, + *(char**) flag.value, + flag.description + ); + break; + } + } + } + + // exit + exit(EXIT_SUCCESS); +} \ No newline at end of file diff --git a/src/flagok.h b/src/flagok.h new file mode 100644 index 0000000..f0c6250 --- /dev/null +++ b/src/flagok.h @@ -0,0 +1,87 @@ +/* +FLAGOK - C/C++ command line flags library +Copyright (C) 2022 Kasyanov Nikolay Alexeyevich (Unbewohnte) + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + +#ifndef flagok +#define flagok + +#include +#include +#include +#include +#include +#include + +#define FLAGSMAX 64 +#define FLAGHELP "-help" + +// Supported flag value types +typedef enum ValueType { + BOOL, + INT, + UINT, + DOUBLE, + STRING, +} ValueType; + +// Unified flag structure +typedef struct flag_t { + const char* name; + ValueType value_type; + void* value; + const char* description; +} flag_t; + +// Registered flags collector and holder +typedef struct flag_collector_t { + unsigned int count; + flag_t flags[FLAGSMAX]; +} flag_collector_t; + +extern flag_collector_t* collector; + +// Create a new flag collector on heap (should not be called outside of library) +flag_collector_t* flag_new_collector(); + +// Free flag collector +void flag_free_collector(); + +// Create a new flag and put it in the collector, if it does not exist - creates a new one +void flag(void* value, ValueType type, const char* name, const char* description); + +// Register a boolean flag +void flag_bool(bool* value, const char* name, const char* description); + +// Register an integer (long long) flag +void flag_int(long long* value, const char* name, const char* description); + +// Register an unsigned integer (unsigned long long) flag +void flag_uint(unsigned long long* value, const char* name, const char* description); + +// Register an double (long double) flag +void flag_double(long double* value, const char* name, const char* description); + +// Register a string flag +void flag_str(char** value, const char* name, const char* description); + +// Parse flags and assign new values if present +void flag_parse(int argc, char** argv); + +// Print help message containing information about registered flags +void flag_print_help(FILE* output); + +#endif \ No newline at end of file diff --git a/testing/test.c b/testing/test.c new file mode 100644 index 0000000..56f87a1 --- /dev/null +++ b/testing/test.c @@ -0,0 +1,40 @@ +/* +FLAGOK - C/C++ command line flags library +Copyright (C) 2022 Kasyanov Nikolay Alexeyevich (Unbewohnte) + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ +#include "../src/flagok.h" + +int main(int argc, char** argv) { + long long iteration = 1; + char* input = "hello"; + bool to_do_or_not = false; + + flag_int(&iteration, "-iteration", "set iterations"); + flag_str(&input, "-input", "set input"); + flag_bool(&to_do_or_not, "-to_do_or_not", "set true or false"); + + printf("Flags before parsing\n"); + printf("iter %lld\n", iteration); + printf("input %s\n", input); + printf("todo %d\n", to_do_or_not); + + flag_parse(argc, argv); + + printf("Flags after parsing\n"); + printf("iter %lld\n", iteration); + printf("input %s\n", input); + printf("todo %d\n", to_do_or_not); +} \ No newline at end of file