correction objet Structure & ajout fonction parser_word & ajout cas ou il ne reste plus rien à parser.

src/objects/structure.rs

@@ -3,6 +3,7 @@
 // s'utilise par l'appel de la fonction static parse, qui prends en param une ligne de commande
 // (Vect<String>) et qui renvois une Entree.
 
+#[derive(Clone)]
 pub struct Structure {
     /*
      * Il y à 5 types de structs differentes.
@@ -83,6 +84,14 @@ impl Structure {
         }
     }
 
+    pub fn is_empty(&self) -> bool {
+        if self.name == "" {
+            true
+        } else {
+            false
+        }
+    }
+
     pub fn get_name(&self) -> &String {
         &self.name
     }
@@ -90,9 +99,15 @@ impl Structure {
         &self.contents
     }
 
-    fn add_to_contents(&mut self, word: &String) -> &Self {
+    pub fn add_to_contents(&mut self, word: String) -> Self {
+        // si le mot n'est pas vide l'ajoutter aux contents.
+        if word != "" { 
             let _ = &self.contents.push(word.to_string());
-        self
+        }
+        self.clone()
     }
 
 }
+
+
+

src/parser.rs

@@ -42,7 +42,8 @@ fn parse_initial_state(char_splitted_command_line: &mut Vec<char>, current_arg:
 }
 
 fn split_string_in_chars(string_to_split: &String) -> Vec<char> {
-    // découpe une chaine de caractère &String en Vec<char
+    // découpe une chaine de caractère &String en Vec<char et inverse le pour que
+    // string_to_split.pop ressorte le premier caractère.  
     string_to_split.chars().rev().collect()
 }
 
@@ -59,7 +60,18 @@ pub fn parse(command_line: &String) -> Vec<String> {
 // Up to this line is the old version parser.
 
 
-fn parse_initial(entree: Entree, restant_a_parser: Vec<char>, stack_last_quote: Vec<char>, last_word: String, struct_in_construct: Structure) -> Entree {
+fn parser_word(word: String) -> Structure {
+    // Génère à partir d'un mot une structure. Example, si le mot c jaaj=truc, alors cela créerras
+    // une structure 'variable' si le mot c if|while|for|etc alors cela fait une structure 'control'
+    // si cela est un mot finissant par () alors cela crée une structure 'fonction' sinon cela crée
+    // une structure 'commande'
+
+    // TODO
+
+    Structure::empty()
+}
+
+fn parse_initial(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
     // en char, une pile vide, un mot vide, et une structure vide.
     //
@@ -79,8 +91,34 @@ fn parse_initial(entree: Entree, restant_a_parser: Vec<char>, stack_last_quote:
     // 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();
+
+    // Etape 1, test cas ou la chaine est vide
+    if current_char.is_none() {
+        // Mettre tout ce cas la dans une fonction et renvoyer le résultat de la fonction.
+        if struct_in_construct.is_empty() {
+            struct_in_construct = parser_word(last_word);
+            if struct_in_construct.is_empty() {
+                entree // Renvoyer entree sans rien ajoutter dedans car la structure est vide & c
+                       // la fin de l'entree.
+            }
+            else {
+                entree.add_structure(struct_in_construct); // Sinon, il y as une structure donc il
+                                                           // faut l'ajoutter à entree avant de le
+                                                           // renvoyer.
+                entree
+            }
+        } else {
+            entree.add_structure(struct_in_construct.add_to_contents(last_word));
+            entree
+        }
+
+    } else {
+
         // TODO
         entree
+    }
 }