Merge pull request #9 from Loquicom/wildcard

Wildcard

makefile

@@ -3,7 +3,7 @@
 #
 
 EXEC = mysh
-OBJETS = str.o parser.o
+OBJETS = str.o parser.o wildcard.o
 NOM_PROJET = mini-shell
 
 #

parser.c

@@ -12,6 +12,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include "wildcard.h"
 #include "parser.h"
 
 /* --- Fonctions privées --- */
@@ -473,8 +474,8 @@ int parse_line(CommandTab* ct, char* line){
 
 int parse_command(Command* c){
     //Declaration variable
-    int length;
-    char* cmd;
+    int length, nbWildcard = 0, res;
+    char* cmd, **wildcardTab;
     //Parse les redirections
     length = set_redirection(c);
     if(length == SHELL_ERR || length == 0){
@@ -488,7 +489,25 @@ int parse_command(Command* c){
     split_command(c, cmd);
     c->name = c->argv[0];
     //Analyse wildcard
-    /* Todo */
+    for(int i = 0; i < c->argc; i++){
+        //Regarde si il faut remplacer l'argument par une suite de fichier
+        nbWildcard = wildcard_result(c->argv[i]);
+        if(nbWildcard > 0){
+            //Si il y a des resultats on prepare un tableau pour les récupérer
+            wildcardTab = malloc(sizeof(char*) * nbWildcard);
+            nbWildcard = wildcard(c->argv[i], nbWildcard, wildcardTab);
+            //Verif retour
+            if(nbWildcard == ERR){
+                return SHELL_ERR;
+            }
+            //Ajoute les wildcard dans argv (le +1 est la pour garder le NULL à la fin)
+            c->argv = insert_array(i, c->argv, c->argc + 1, wildcardTab, nbWildcard, &res);
+            if(res == ERR){
+                return SHELL_ERR;
+            }
+            c->argc = res - 1;  //On ne compte pas le NULL final
+        }
+    }
     //Ici tous est ok
     return SHELL_OK;
 }

wildcard.c

@@ -0,0 +1,164 @@
+/* 
+ * File:   wildcard.c
+ * Author: Arthur Brandao
+ *
+ * Created on 7 novembre 2018
+ */
+
+#define _DEFAULT_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fnmatch.h>
+#include <string.h>
+#include "wildcard.h"
+
+int wildcard_result(const char* seq) {
+    //Declaration variable
+    struct dirent **namelist;
+    int nbFile, nbRes = 0;
+    //Recup la liste des fichiers dans le dossier courant
+    nbFile = scandir(".", &namelist, 0, alphasort);
+    if (nbFile < 0) {
+        perror("scandir() : ");
+        return ERR;
+    }
+    //Parcours chaque fichier pour compter le nombre de resultat
+    while (nbFile--) {
+        //Si c'est bien un fichier (et non un dossier)
+        if (namelist[nbFile]->d_type == DT_REG) {
+            //Test par rapport au wildcard
+            if (fnmatch(seq, namelist[nbFile]->d_name, 0) == 0) {
+                //Regarde si le resultat est bien different de la wildcard
+                if (strcmp(seq, namelist[nbFile]->d_name) != 0) {
+                    nbRes++;
+                }
+            }
+        }
+        free(namelist[nbFile]);
+    }
+    free(namelist);
+    //Retour
+    return nbRes;
+}
+
+int wildcard(const char* seq, int size, char** result) {
+    //Declaration variable
+    struct dirent **namelist;
+    int nbFile, nbRes = 0;
+    //Verification parametre
+    if (size < 1) {
+        return ERR;
+    }
+    //Recup la liste des fichiers dans le dossier courant
+    nbFile = scandir(".", &namelist, 0, alphasort);
+    if (nbFile < 0) {
+        perror("scandir() : ");
+        return ERR;
+    }
+    //Parcours chaque fichier pour ajouter les resultats à result
+    int i = 0;
+    while (nbFile--) {
+        //Si c'est bien un fichier (et non un dossier)
+        if (namelist[nbFile]->d_type == DT_REG) {
+            //Test par rapport au wildcard
+            if (fnmatch(seq, namelist[nbFile]->d_name, 0) == 0) {
+                result[i] = malloc(strlen(namelist[nbFile]->d_name) * sizeof (char));
+                strcpy(result[i++], namelist[nbFile]->d_name);
+                nbRes++;
+            }
+        }
+        //Nettoyage
+        free(namelist[nbFile]);
+        //Si il n'y a plus de place dans le tableau on s'arrete
+        if (i == size) {
+            break;
+        }
+    }
+    free(namelist);
+    //Retourne
+    return nbRes;
+}
+
+char** insert_array(int pos, char** array, int arraysize, char** insert, int insertsize, int* newsize) {
+    //Erreur parametre
+    if (pos < 0 || arraysize < 1 || insertsize < 1 || pos >= arraysize) {
+        if (newsize != NULL) {
+            *newsize = ERR;
+        }
+        return NULL;
+    }
+    //Si une seul valeur à insérer
+    if (insertsize == 1) {
+        //Vide la chaine precedente
+        free(array[pos]);
+        //Remplace
+        array[pos] = malloc(strlen(insert[0]) * sizeof (char));
+        strcpy(array[pos], insert[0]);
+        //Nettoyage
+        free(insert[0]);
+        free(insert);
+        //Retourne le tableau
+        if (newsize != NULL) {
+            *newsize = arraysize;
+        }
+        return array;
+    }
+    //Sinon generation d'un nouveau tableau
+    char ** newarray;
+    int size = arraysize + insertsize - 1, i;
+    newarray = malloc(sizeof (char*) * size);
+    //Ajout des elements avant la postion
+    for (i = 0; i < pos; i++) {
+        //Si l'element est null
+        if (array[i] == NULL) {
+            newarray[i] = NULL;
+        }            
+        //Sinon on le copie
+        else {
+            newarray[i] = malloc(strlen(array[i]) * sizeof (char));
+            strcpy(newarray[i], array[i]);
+            free(array[i]);
+        }
+    }
+    //Ajout des nouveaux elements
+    for (int j = 0; j < insertsize; j++, i++) {
+        //Si l'element est null
+        if (insert[j] == NULL) {
+            newarray[i] = NULL;
+        }            
+        //Sinon on le copie
+        else {
+            newarray[i] = malloc(strlen(insert[j]) * sizeof (char));
+            strcpy(newarray[i], insert[j]);
+            free(insert[j]);
+        }
+    }
+    //Ajout fin
+    for (int j = pos + 1; j < arraysize; j++, i++) {
+        //Si l'element est null
+        if (array[j] == NULL) {
+            newarray[i] = NULL;
+        }            
+        //Sinon on le copie
+        else {
+            newarray[i] = malloc(strlen(array[j]) * sizeof (char));
+            strcpy(newarray[i], array[j]);
+            free(array[j]);
+        }
+    }
+    //Nettoyage et changement tableau
+    free(array[pos]);
+    free(array);
+    free(insert);
+    //Indique la nouvelle taille
+    if (newsize != NULL) {
+        *newsize = size;
+    }
+    //Retourne le nombre d'element
+    return newarray;
+}

wildcard.h

@@ -0,0 +1,49 @@
+/* 
+ * File:   wildcard.h
+ * Author: Arthur Brandao
+ *
+ * Created on 7 novembre 2018
+ */
+
+#ifndef WILDCARD_H
+#define WILDCARD_H
+
+/* --- Include --- */
+#include "constante.h"
+
+/* --- Fonctions publiques ---*/
+/**
+ * Indique le nombre de fichiers correspond à la sequence dans le dossier de
+ * travail courrant
+ * @param const char* La sequence
+ * @return int Le nombre de fichiers correspondant (0 si aucun ou si le nom du
+ * fichier est identique à la sequence)
+ */
+int wildcard_result(const char*);
+
+/**
+ * Recupere les fichiers correspondant à une sequence
+ * @param const char* La sequence
+ * @param int La taille du tableau (parametre suivant)
+ * @param char** Tableau qui accueillera le resultat
+ * @return int Le nombre d'élement mis dans le tableau (ne depasse jamais la
+ * capacité indiqué en paramètre)
+ */
+int wildcard(const char*, int, char**);
+
+/**
+ * Insert un tableau à la place d'une valeur d'un autre tableau
+ * Tous les tableau passé en pramètre sont vidés et supprimés (ils doivent donc
+ * être alloué dynamiquement, de même pour leurs valeurs)
+ * @param int La position à remplacer dans le 1er tableau
+ * @param char** La tableau à dont un élément est à remplacer
+ * @param int La taille du tableau
+ * @param char** Le tableau à insérer dans l'autre tableau
+ * @param int La taille du tableau à inserer
+ * @param int* Variable récupérant la nouvelle taille du tableau (peut etre NULL)
+ * @return char** Le nouveau tableau
+ */
+char** insert_array(int, char**, int, char**, int, int*);
+
+#endif /* WILDCARD_H */
+