From 02278d482c0c9c241a91686d6317acfc90be7857 Mon Sep 17 00:00:00 2001
From: primardj <b00168148@mytudublin.ie>
Date: Mon, 15 Jan 2024 17:55:58 +0000
Subject: [PATCH] =?UTF-8?q?correction=20objet=20Structure=20&=20ajout=20fo?=
 =?UTF-8?q?nction=20parser=5Fword=20&=20ajout=20cas=20ou=20il=20ne=20reste?=
 =?UTF-8?q?=20plus=20rien=20=C3=A0=20parser.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/objects/structure.rs | 21 +++++++++++++++---
 src/parser.rs            | 46 ++++++++++++++++++++++++++++++++++++----
 2 files changed, 60 insertions(+), 7 deletions(-)

diff --git a/src/objects/structure.rs b/src/objects/structure.rs
index b5f163b..94714e2 100644
--- a/src/objects/structure.rs
+++ b/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 {
-        let _ = &self.contents.push(word.to_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.clone()
     }
 
 }
+
+
+
diff --git a/src/parser.rs b/src/parser.rs
index dc46d51..d1b568a 100644
--- a/src/parser.rs
+++ b/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.
     
-    // TODO
-    entree
+    // 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
+    }
 }