ajout du constructeur Structure vide terminaision de la fonction parse2 et création de la fonction parse_initial

src/objects/structure.rs

@@ -76,6 +76,13 @@ impl Structure {
             contents: cont,
         }
     }
+    pub fn empty() -> Self {
+        Self {
+            name: String::new(),
+            contents: Vec::new(),
+        }
+    }
+
     pub fn get_name(&self) -> &String {
         &self.name
     }

src/parser.rs

@@ -4,6 +4,7 @@
 // parse2(command_line: &String) -> Entree
 
 use crate::objects::entree::Entree;
+use crate::objects::structure::Structure;
 
 
 fn parse_after_whitespace(char_splitted_command_line: &mut Vec<char>, argv: &mut Vec<String>) -> Vec<String> {
@@ -41,6 +42,7 @@ 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
     string_to_split.chars().rev().collect()
 }
 
@@ -57,16 +59,38 @@ 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 {
+    // 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.
+    //
+    // 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.
+    
+    // TODO
+    entree
+}
 
 
 pub fn parse2(command_line: &String) -> Entree {
     // prends en paramettre un ligne de commande, et retourne une Entree.
-    let mut jaaj: Entree = Entree::new();
+    let mut entree: Entree = Entree::new();
     // Je vais fortement m'inspirer de ce qu'as fait hippolyte dans sa version de parser. 
-    // Tout dabord, je vais couper ma chaine en caractères.
+    // je vais appeler une fonction recursive qui vas faire comme ceci: 
-    // puis, je vais appeler une fonction recursive qui vas faire comme ceci: 
     //
-    // parser_initial(entree: &mut Entree, Restant_à_parser: &mut Vec<char>, stack_last_quote: &mut Vec<char>, last_word: &mut String, struct_in_construct: &mut Structure)
+    // parser_initial(entree: Entree, Restant_à_parser: Vec<char>, stack_last_quote: Vec<char>, last_word: String, struct_in_construct: Structure)
     //                      { si Restant_à_parser.pop() == ';' et stack_last_quote.len() == 0 et
     //                      struct_in_construct == None et last_word == None => Rien faire
     //                      { si Restant_à_parser.pop() == ';' et stack_last_quote.len() == 0 et
@@ -79,5 +103,15 @@ pub fn parse2(command_line: &String) -> Entree {
     //                      entree.add_structure(struct_in_construct); struct_in_construct = None
     //                      {
     //
-    jaaj
+
+    // Etape 0, découper la commande_line: &String en command_line: Vec<char>
+    let mut char_splitted_command_line: Vec<char> = split_string_in_chars(&command_line);
+
+    // Etape 1, préparer les variables pour lancer le parser recursif
+    let mut stack_char_empty: Vec<char> = Vec::new();
+    let mut empty_word: String = String::new();
+
+    // Etape 2, lancer le parser recursif. Il retournera une Entree bien parsé comme il faut.
+    parse_initial( entree, char_splitted_command_line, stack_char_empty, empty_word, Structure::empty())
+
 }