127 lines
4.2 KiB
C
127 lines
4.2 KiB
C
#include "utilities.h"
|
||
#include <getopt.h>
|
||
#include <string.h>
|
||
#include "utilities.h"
|
||
|
||
/**
|
||
* \brief Affiche un message d'aide
|
||
*
|
||
* Affiche un message d'aide pour le logiciel ainsi que son utilisation, puis
|
||
* termine le processus avec le code de sortie indiqué par l'argument de la
|
||
* fonction.
|
||
*
|
||
* \param[in] t_exit_code Code de sortie du processus
|
||
*/
|
||
void help(int t_exit_code) {
|
||
puts("Usage:");
|
||
puts("surfaces-unies -i path [-o path] [-options]\n");
|
||
puts("The default action is to compress the mandatory input image to a .sf");
|
||
puts("file saved in the current directory.");
|
||
puts("The input image MUST be saved in the ppm format.");
|
||
puts("Options available:");
|
||
puts("-h --help\n\tdisplay the current message");
|
||
puts("-i --input\n\tpath to the input file (MANDATORY)");
|
||
puts("-o --output");
|
||
puts("\tpath to the output file (if the file already exists, it will be\n");
|
||
puts("-c --compress\n\tcompress the input file");
|
||
puts("-u --uncompress\n\tuncompresses the input file to the output file.");
|
||
exit(t_exit_code);
|
||
}
|
||
|
||
/**
|
||
* \struct Argres
|
||
* \brief Résultats du traitement des arguments du processus
|
||
*
|
||
* Cette structure est utilisée pour consolider ensemble les résultats du
|
||
* traitement des arguments et les renvoyer en une fois au lieu d'avoir à
|
||
* utiliser des variables globales ou des pointeurs en arguments
|
||
* supplémentaires aux fonctions.
|
||
*/
|
||
struct Argres {
|
||
char *input; /*!< Nom du fichier d'entrée */
|
||
char *output; /*!< Nom du fichier de sortie */
|
||
bool compress; /*!< Le fichier d'entrée doit-il être compressé ? */
|
||
};
|
||
typedef struct Argres Argres;
|
||
|
||
/**
|
||
* \brief Processes independently the arguments of the process
|
||
*
|
||
* Each option and switch will be processed here and will modify appropriately
|
||
* the parameter `args`
|
||
*
|
||
* \param[out] t_args Result of the arguments processing
|
||
* \param[in] t_c Switch or option passed
|
||
*/
|
||
void get_args(Argres *t_args, int *t_c) {
|
||
switch (*t_c) {
|
||
case 0: break;
|
||
case 'h': help(NOERROR); break;
|
||
case 'i': (*t_args).input = optarg; break;
|
||
case 'o': (*t_args).output = optarg; break;
|
||
case 'c': (*t_args).compress = true; break;
|
||
case 'u': (*t_args).compress = false; break;
|
||
case '?':
|
||
default: help(ARGERROR);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* \brief Traite les arguments passés au processus
|
||
*
|
||
* Les arguments passés au processus seront traités ici. Les arguments passés
|
||
* dans cette fonction ne subiront aucune modification. La fonction renvoie une
|
||
* structure \ref Argres contenant le nom de fichier d’entrée et de sortie
|
||
* ainsi qu’un booléen indiquant si le fichier d’entrée doit être compressé ou
|
||
* décompressé.
|
||
*
|
||
* \param[in] t_argc Nombre d’arguments reçus
|
||
* \param[in] t_argv Arguments reçus par le processus
|
||
* \return structure \ref Argres
|
||
*/
|
||
Argres process_args(const int t_argc, char *t_argv[]) {
|
||
Argres res;
|
||
res.input = NULL;
|
||
res.output = NULL;
|
||
while (true) {
|
||
int option_index = 0;
|
||
static struct option long_options[] = {
|
||
{"help", no_argument, NULL, 'h'}, {"input", required_argument, NULL, 'i'},
|
||
{"output", required_argument, NULL, 'o'}, {"compress", no_argument, NULL, 'c'},
|
||
{"uncompress", no_argument, NULL, 'u'}, {NULL, 0, NULL, 0}};
|
||
int c = getopt_long(t_argc, t_argv, "hi:o:cu", long_options, &option_index);
|
||
if (c == -1) break;
|
||
get_args(&res, &c);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* \brief Fonction `main` lancée avec le processus
|
||
*
|
||
* This function is launched with the process. It will analyze the arguments it
|
||
* received, and depending on them will either compress or uncompress the input
|
||
* file, or will throw an error and stop in case of incorrect arguments.
|
||
*
|
||
* \param[in] argc Nombre d’arguments reçus par le processus
|
||
* \param[in] argv Tableau des arguments reçus par le processus
|
||
* \return Code de status du processus
|
||
*/
|
||
int main(int argc, char **argv) {
|
||
Argres argresults = process_args(argc, argv);
|
||
if (NULL == argresults.input) {
|
||
fprintf(stderr, "ERROR: no input file.");
|
||
help(ARGERROR);
|
||
}
|
||
if (!argresults.output) {
|
||
argresults.output = "output.fs";
|
||
}
|
||
printf("input: %s\noutput: %s\n", argresults.input, argresults.output);
|
||
if(argresults.compress) {
|
||
puts("Compressing...");
|
||
} else {
|
||
puts("Uncompressing...");
|
||
}
|
||
return 0;
|
||
}
|