terminer la cas ou il y à un caractère vide de reçu

src/objects/structure.rs

@@ -79,10 +79,17 @@ impl Structure {
         }
     }
 
-    fn new_commentaire(cont: Vec<String>) -> Self {
+    /*
+     * name: "commentaire"
+     * contents: [une quote]
+     *
+     * est utilisé pour dire que l'utilisateur à oublié de refermer sa quote finale.
+     *
+     */
+    pub fn new_commentaire(cont: String) -> Self {
         Self {
             name: String::from("commentaire"),
-            contents: cont,
+            contents: vec![cont],
         }
     }
 

src/parser.rs

@@ -66,56 +66,62 @@ fn parser_word(word: String) -> Structure {
     // si cela est un mot finissant par () alors cela crée une structure 'fonction' sinon cela crée
     // une structure 'commande'
 
-    // TODO
+    // TODo
+    // Pour cette deuxieme version du parser, je ne vais pas faire les autres cas.
     
 
-    // Dans le cas ou aucunes autres structures ne peuvent être crées,
+    if word == "" {
+        // Dans le cas ou la fonction est appellé alors qu'il n'y as pas de mots 
+        Structure::empty()
+    } else {
+        // Dans le cas ou aucunes autres structures ne peuvent être crées, créer une structure
+        // commande avec le mot dedans.
         Structure::new_commande(vec![word])
+    }
 
-    //Structure::empty()
+}
+
+fn generer_comments_a_partir_stack_quote(mut entree: Entree, mut stack_last_quote: Vec<char>) -> Entree {
+    // Tant qu'il reste des quotes dans la stack, générer une Structure commentaire
+    let mut last_quote = stack_last_quote.pop();
+    
+    if last_quote.is_none() {
+        // Si il n'y as plus de quote, renvoyer entree
+        entree
+    } else {
+        // Sinon, rajoutter un commentaire à l'entree donnant la quote en question.
+        entree.add_structure(Structure::new_commentaire(last_quote.expect("last_quote_is_none").to_string()));
+        generer_comments_a_partir_stack_quote(entree, stack_last_quote)
+    }
 }
 
 fn parse_cas_fin_de_chaine(mut entree: Entree, stack_last_quote: Vec<char>, last_word: String, mut struct_in_construct: Structure) -> Entree {
     // Cas final, dans le cas ou le parser recoit un caractère vide.
-    // Si il reste des quotes dans la stack, ajoutter des structures commentaires à la fin TODO
+
     if struct_in_construct.is_empty() {
+        // Puisque la structure est vide, essayer de mettre le last_word dans une structure.
         struct_in_construct = parser_word(last_word);
-        if struct_in_construct.is_empty() {
+
-            // Renvoyer entree sans rien ajoutter dedans car la structure est vide & c
+        if !struct_in_construct.is_empty() {
-            // la fin de l'entree.
+            // si une nouvelle structure est apparue, l'ajoutter à l'entrée.
-            entree 
-        }
-        else {
-            // Sinon, il y as une structure donc il faut l'ajoutter à entree avant de le
-            // renvoyer.
             entree.add_structure(struct_in_construct); 
-            entree
         }
     } else {
+        // Dans le cas ou la structure n'est pas vide, ajoutter le mot, et ajoutter la structure.
         entree.add_structure(struct_in_construct.add_to_contents(last_word));
-        entree
     }
+    // Finalement, regarder la stack des ' et ". Pour chaques commentaires ressortis, rajoutter une
+    // structure commentaire le contenant.
+
+    generer_comments_a_partir_stack_quote(entree, stack_last_quote)
+
 }
 
 fn parse_recursif(mut entree: Entree, mut restant_a_parser: Vec<char>, stack_last_quote: Vec<char>, last_word: String, mut struct_in_construct: Structure) -> Entree {
-    // Est le parseur initial, comence ca recursivitée avec une entree vide, une ligne de command
+    // Est le parseur initial, commence sa recursivitée avec une entree vide, une ligne de commande
     // en char, une pile vide, un mot vide, et une structure vide.
     //
     // Lis les caractères un par un, et détermine l'action à prendre avec chaques caractères.
-    //
-    // Tout dabord, regarde que la pile des quotes est vide, sinon, mettre le caractère dans
-    // last_word sauf si c la dernière quote entré dans ce cas enlever la quote de la pile et
-    // parser last_word
-    //
-    // si la pile de quote est vide, regarde si le caractère est '\n' ou ';' dans ce cas la, si
-    // last_word et Structure sont vide, passer au caractère suivant, sinon si Structure et
-    // last_word ne sont pas vide alors si structure est vide, parser last_word, et ajouter la
-    // structure ressortie à entree, si last_word est vide et structure non vide, ajouter
-    // directement structure à entree.
-    //
-    // Fais appel à la fonction parser_word pour déterminer si le dernier mot entré est une
-    // commande, une variable, un pipe ou une structure de control lol. Retourne une structure du
-    // meme type que last_word, avec last_word au début de ses contents.
     
     // Etape 0; Lis le premier caractère de ce qu'il reste à parser.
     let current_char = restant_a_parser.pop();
@@ -125,7 +131,19 @@ fn parse_recursif(mut entree: Entree, mut restant_a_parser: Vec<char>, stack_las
         parse_cas_fin_de_chaine(entree, stack_last_quote, last_word, struct_in_construct)
 
     } else {
-        // Etape 2, regarde si la stack des quotes est vide
+        // Etape 2, regarde si la stack des quotes est vide, sinon regarder si la quote c la
+        // last_quote dans stack_last_quote cas oui, parser last_word, cas non, ajoutter caractère
+        // à last_word. et relancer le parser_recursif
+        //
+        // Si oui, vérif ';' 
+        // Cas last_word et Structure vide, ignorer le caractère et rappeler le parser_recursif
+        // Cas contraire, completer structure et l'ajoutter à entrer et rappeler le parser_recursif
+        //
+        // si '#' et last_word vide, renvoyer entree
+        // si ' ' ajoutter last_word à structure, ou, cas ou structure vide, parser_word et
+        // rappeler le parser_recursif
+        //
+        // pour tout les autres cas, ajouter char à last_word.
 
         // TODO
         entree // Ici faudra rappeler le parse_recursif pour passer au caractère suivant.