From fc7129d16dd3e4eccd84a22c4fb019ad855f3b60 Mon Sep 17 00:00:00 2001 From: primardj Date: Tue, 16 Jan 2024 21:11:34 +0000 Subject: [PATCH] =?UTF-8?q?terminer=20la=20cas=20ou=20il=20y=20=C3=A0=20un?= =?UTF-8?q?=20caract=C3=A8re=20vide=20de=20re=C3=A7u?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/objects/structure.rs | 11 +++++- src/parser.rs | 80 ++++++++++++++++++++++++---------------- 2 files changed, 58 insertions(+), 33 deletions(-) diff --git a/src/objects/structure.rs b/src/objects/structure.rs index 387eff5..4688d69 100644 --- a/src/objects/structure.rs +++ b/src/objects/structure.rs @@ -79,10 +79,17 @@ impl Structure { } } - fn new_commentaire(cont: Vec) -> 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], } } diff --git a/src/parser.rs b/src/parser.rs index 7b3128e..00f892a 100644 --- a/src/parser.rs +++ b/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, - Structure::new_commande(vec![word]) + 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) -> 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, 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 - // la fin de l'entree. - entree - } - else { - // Sinon, il y as une structure donc il faut l'ajoutter à entree avant de le - // renvoyer. + + if !struct_in_construct.is_empty() { + // si une nouvelle structure est apparue, l'ajoutter à l'entrée. 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, stack_last_quote: Vec, 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, 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.