diff --git a/Cargo.lock b/Cargo.lock index 1a1f565..7cab743 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3,5 +3,5 @@ version = 3 [[package]] -name = "sophie" +name = "pendragon" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 15b8556..0e882f7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "sophie" +name = "pendragon" version = "0.1.0" edition = "2021" diff --git a/sophie.project b/pendragon.project similarity index 100% rename from sophie.project rename to pendragon.project diff --git a/src/main.rs b/src/main.rs index c4eb434..6a6efb2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,23 +1,23 @@ use std::env; use std::fs; -mod sophie; -use sophie::*; +mod pendragon; +use pendragon::*; fn main() { let arguments: Vec = env::args().collect(); if arguments.len() < 2 { - eprintln!("Utilisation : sophie "); + eprintln!("Utilisation : pendragon "); return } let chemin_de_fichier = &arguments[1]; - let mut sophie = Sophie::new(); + let mut pendragon = Pendragon::new(); match fs::read_to_string(chemin_de_fichier) { Ok(contenu) => { - let _ = sophie.execute(contenu); + let _ = pendragon.execute(contenu); } Err(raison) => { eprintln!("Fichier illisible : {}", raison); diff --git a/src/sophie/booleen.rs b/src/pendragon/booleen.rs similarity index 75% rename from src/sophie/booleen.rs rename to src/pendragon/booleen.rs index a73bf47..d7be372 100644 --- a/src/sophie/booleen.rs +++ b/src/pendragon/booleen.rs @@ -1,13 +1,13 @@ -use super::Sophie; -use super::ErreurSophie; +use super::Pendragon; +use super::ErreurPendragon; use super::Element; -impl Sophie { - pub fn condition(&self, arguments: &str) -> Result { +impl Pendragon { + pub fn condition(&self, arguments: &str) -> Result { self.condition_elementaire(arguments) } - pub fn condition_elementaire(&self, texte: &str) -> Result { + pub fn condition_elementaire(&self, texte: &str) -> Result { let mut expression: Vec = texte.split(" ").map(String::from).collect(); let mut index = 0; @@ -17,7 +17,7 @@ impl Sophie { continue; } if index == expression.len() - 1 { - return Err(ErreurSophie::ManqueArgument); + return Err(ErreurPendragon::ManqueArgument); } let a = self.texte_comme_booleen(&expression[index + 1])?; expression[index] = booleen_comme_texte(!a); @@ -30,7 +30,7 @@ impl Sophie { continue; } if index == 0 || index == expression.len() - 1 { - return Err(ErreurSophie::ManqueArgument); + return Err(ErreurPendragon::ManqueArgument); } let a = self.texte_comme_booleen(&expression[index - 1])?; let b = self.texte_comme_booleen(&expression[index + 1])?; @@ -46,7 +46,7 @@ impl Sophie { continue; } if index == 0 || index == expression.len() - 1 { - return Err(ErreurSophie::ManqueArgument); + return Err(ErreurPendragon::ManqueArgument); } let a = self.texte_comme_booleen(&expression[index - 1])?; let b = self.texte_comme_booleen(&expression[index + 1])?; @@ -56,20 +56,20 @@ impl Sophie { expression.remove(index + 1); } if expression.len() > 1 { - return Err(ErreurSophie::MauvaisArgument("expression booléenne".to_string())) + return Err(ErreurPendragon::MauvaisArgument("expression booléenne".to_string())) } self.texte_comme_booleen(&expression[0]) } - pub fn texte_comme_booleen(&self, texte: &str) -> Result { + pub fn texte_comme_booleen(&self, texte: &str) -> Result { if texte.chars().next().map_or(false, |c| c.is_uppercase()) { if self.variables.contains_key(texte) { let Element::Booleen(booleen) = self.variables[texte] else { - return Err(ErreurSophie::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "booleen".into())) + return Err(ErreurPendragon::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "booleen".into())) }; return Ok(booleen); } else { - return Err(ErreurSophie::VariableInconnue(texte.to_string())) + return Err(ErreurPendragon::VariableInconnue(texte.to_string())) } } texte_comme_booleen(texte) @@ -84,10 +84,10 @@ pub fn booleen_comme_texte(booleen: bool) -> String { } } -pub fn texte_comme_booleen(texte: &str) -> Result { +pub fn texte_comme_booleen(texte: &str) -> Result { match texte { "vrai" => Ok(true), "faux" => Ok(false), - _ => Err(ErreurSophie::BooleenInvalide(texte.into())), + _ => Err(ErreurPendragon::BooleenInvalide(texte.into())), } } \ No newline at end of file diff --git a/src/sophie/mod.rs b/src/pendragon/mod.rs similarity index 72% rename from src/sophie/mod.rs rename to src/pendragon/mod.rs index 0644f20..e48fb78 100644 --- a/src/sophie/mod.rs +++ b/src/pendragon/mod.rs @@ -10,23 +10,23 @@ use structure::*; #[cfg(test)] mod tests; -pub struct Sophie { +pub struct Pendragon { variables: HashMap, } -impl Sophie { +impl Pendragon { pub fn new() -> Self { Self { variables: HashMap::new(), } } - pub fn execute(&mut self, contenu: String) -> Result<(), ErreurSophie> { + pub fn execute(&mut self, contenu: String) -> Result<(), ErreurPendragon> { let contenu_propre = contenu.replace("\n", ""); let mut texte: Vec<&str> = contenu_propre.split('.').collect(); - let reste = texte.pop(); // remove empty phrase after last dot + let reste = texte.pop(); if reste != Some("") { eprintln!("Erreur phrase {} : Il manque un point.", texte.len() + 1); - return Err(ErreurSophie::ManquePoint) + return Err(ErreurPendragon::ManquePoint) } for (index_phrase, phrase) in texte.iter().enumerate() { match self.execute_phrase(phrase) { @@ -40,16 +40,16 @@ impl Sophie { Ok(()) } - fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurSophie> { + fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurPendragon> { let phrase = phrase.trim(); let parties: Vec<&str> = phrase.splitn(2, ' ').collect(); if parties.is_empty() { - return Err(ErreurSophie::PhraseVide) + return Err(ErreurPendragon::PhraseVide) } if parties.len() == 1 { - return Err(ErreurSophie::ManqueArgument) + return Err(ErreurPendragon::ManqueArgument) } match parties[0] { @@ -66,26 +66,26 @@ impl Sophie { self.demande(parties[1])?; } autre_commande => { - return Err(ErreurSophie::CommandeInconnue(autre_commande.to_string())) + return Err(ErreurPendragon::CommandeInconnue(autre_commande.to_string())) } }; Ok(()) } - fn affiche(&self, arguments: &str) -> Result<(), ErreurSophie> { + fn affiche(&self, arguments: &str) -> Result<(), ErreurPendragon> { println!("{}", self.texte(arguments)?); Ok(()) } - fn definie(&mut self, arguments: &str) -> Result<(), ErreurSophie> { + fn definie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> { let (variable_nom, variable_type) = self.nom_de_variable(arguments, "comme")?; let possible_variable = self.recupere_variable(&variable_nom); let Err(raison) = possible_variable else { - return Err(ErreurSophie::MauvaisArgument(format!("la variable \"{}\" existe déjà", variable_nom))) + return Err(ErreurPendragon::MauvaisArgument(format!("la variable \"{}\" existe déjà", variable_nom))) }; - let ErreurSophie::VariableInconnue(_) = raison else { + let ErreurPendragon::VariableInconnue(_) = raison else { return Err(raison) }; @@ -93,14 +93,14 @@ impl Sophie { "entier" => Element::Entier(0), "texte" => Element::Texte("".to_string()), "booléen" => Element::Booleen(false), - _ => return Err(ErreurSophie::MauvaisArgument(format!("type de variable \"{}\" inconnu", variable_type))), + _ => return Err(ErreurPendragon::MauvaisArgument(format!("type de variable \"{}\" inconnu", variable_type))), }; self.variables.insert(variable_nom, contenu); Ok(()) } - fn modifie(&mut self, arguments: &str) -> Result<(), ErreurSophie> { + fn modifie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> { let (variable_nom, contenu) = self.nom_de_variable(arguments, "avec")?; let variable = self.recupere_variable(&variable_nom)?; @@ -114,7 +114,7 @@ impl Sophie { Ok(()) } - fn demande(&mut self, arguments: &str) -> Result<(), ErreurSophie> { + fn demande(&mut self, arguments: &str) -> Result<(), ErreurPendragon> { let (variable_nom, _) = self.nom_de_variable(arguments, "")?; let _ = self.recupere_variable(&variable_nom)?; @@ -122,7 +122,7 @@ impl Sophie { println!("Quelle valeur pour {} ?", variable_nom); let mut reponse: String = String::new(); if let Err(_) = io::stdin().read_line(&mut reponse) { - return Err(ErreurSophie::ProblemeTerminal("lecture d'entrées utilisateur impossible".into())) + return Err(ErreurPendragon::ProblemeTerminal("lecture d'entrées utilisateur impossible".into())) } let contenu = reponse.trim(); @@ -137,20 +137,20 @@ impl Sophie { Ok(()) } - fn recupere_variable(&self, nom: &str) -> Result { + fn recupere_variable(&self, nom: &str) -> Result { let Some(first_char) = nom.chars().next() else { - return Err(ErreurSophie::MauvaisArgument("il n'y a pas de variable".to_string())) + return Err(ErreurPendragon::MauvaisArgument("il n'y a pas de variable".to_string())) }; if !first_char.is_uppercase() { - return Err(ErreurSophie::MauvaisArgument("il manque une majuscule à la variable".to_string())) + return Err(ErreurPendragon::MauvaisArgument("il manque une majuscule à la variable".to_string())) } if !self.variables.contains_key(nom) { - return Err(ErreurSophie::VariableInconnue(nom.into())) + return Err(ErreurPendragon::VariableInconnue(nom.into())) } Ok(self.variables[nom].clone()) } - fn nom_de_variable(&self, arguments: &str, separateur: &str) -> Result<(String, String), ErreurSophie> { + fn nom_de_variable(&self, arguments: &str, separateur: &str) -> Result<(String, String), ErreurPendragon> { let parties = if separateur == "" { vec![arguments, ""] } else { @@ -160,7 +160,7 @@ impl Sophie { let nom_variable = parties[0].trim().to_string(); if parties.len() == 1 { - return Err(ErreurSophie::ManqueArgument) + return Err(ErreurPendragon::ManqueArgument) } Ok((nom_variable, parties[1].trim().to_string())) } diff --git a/src/sophie/nombre.rs b/src/pendragon/nombre.rs similarity index 87% rename from src/sophie/nombre.rs rename to src/pendragon/nombre.rs index 10a65f7..72badd4 100644 --- a/src/sophie/nombre.rs +++ b/src/pendragon/nombre.rs @@ -1,5 +1,5 @@ -use super::ErreurSophie; -use super::Sophie; +use super::ErreurPendragon; +use super::Pendragon; use super::Element; const NOMS_UNITES: [&str; 10] = ["", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf"]; @@ -8,8 +8,8 @@ const NOMS_DIZAINES: [&str; 9] = ["", "dix", "vingt", "trente", "quarante", "cin const NOMS_SEPARATEURS: [&str; 7] = ["", "mille", "million", "milliard", "billion", "billiard", "trillion"]; const UNION: &str = "-"; -impl Sophie { - pub fn operation(&self, arguments: &str) -> Result { +impl Pendragon { + pub fn operation(&self, arguments: &str) -> Result { //return self.operation_elementaire(arguments); let texte = arguments .replace("ouvre la parenthèse", "ouvre-la-parenthese") @@ -30,10 +30,10 @@ impl Sophie { } } let Some(index_ouverture) = ouverture else { - return Err(ErreurSophie::DesequilibreParenthese); + return Err(ErreurPendragon::DesequilibreParenthese); }; let Some(index_fermeture) = fermeture else { - return Err(ErreurSophie::DesequilibreParenthese); + return Err(ErreurPendragon::DesequilibreParenthese); }; let contenu: String = expression[(index_ouverture+1)..(index_fermeture)].join(" "); let nombre = self.operation_elementaire(&contenu)?; @@ -44,12 +44,12 @@ impl Sophie { } } if expression.contains(&"ferme-la-parenthese".to_string()) { - return Err(ErreurSophie::DesequilibreParenthese); + return Err(ErreurPendragon::DesequilibreParenthese); } self.operation_elementaire(&expression.join(" ")) } - pub fn operation_elementaire(&self, arguments: &str) -> Result { + pub fn operation_elementaire(&self, arguments: &str) -> Result { let texte = arguments.replace("divisé par", "divise-par"); let mut expression: Vec = texte.split(" ").map(String::from).collect(); @@ -60,7 +60,7 @@ impl Sophie { continue; } if index == 0 || index == expression.len() - 1 { - return Err(ErreurSophie::ManqueArgument); + return Err(ErreurPendragon::ManqueArgument); } let a = self.texte_comme_nombre(&expression[index - 1])?; let b = self.texte_comme_nombre(&expression[index + 1])?; @@ -79,7 +79,7 @@ impl Sophie { continue; } if index == 0 || index == expression.len() - 1 { - return Err(ErreurSophie::ManqueArgument); + return Err(ErreurPendragon::ManqueArgument); } let a = self.texte_comme_nombre(&expression[index - 1])?; let b = self.texte_comme_nombre(&expression[index + 1])?; @@ -92,20 +92,20 @@ impl Sophie { } if expression.len() > 1 { - return Err(ErreurSophie::MauvaisArgument("expression mathématique".to_string())) + return Err(ErreurPendragon::MauvaisArgument("expression mathématique".to_string())) } self.texte_comme_nombre(&expression[0]) } - pub fn texte_comme_nombre(&self, texte: &str) -> Result { + pub fn texte_comme_nombre(&self, texte: &str) -> Result { if texte.chars().next().map_or(false, |c| c.is_uppercase()) { if self.variables.contains_key(texte) { let Element::Entier(nombre) = self.variables[texte] else { - return Err(ErreurSophie::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "entier".into())) + return Err(ErreurPendragon::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "entier".into())) }; return Ok(nombre); } else { - return Err(ErreurSophie::VariableInconnue(texte.to_string())) + return Err(ErreurPendragon::VariableInconnue(texte.to_string())) } } texte_comme_nombre(texte) @@ -198,7 +198,7 @@ fn petit_nombre_comme_texte(nombre: usize) -> String { format!("{}{}{}{}{}", centaine_texte, dizaine_union, dizaine_texte, séparation, unité_texte) } -pub fn texte_comme_nombre(texte: &str) -> Result { +pub fn texte_comme_nombre(texte: &str) -> Result { if texte == "zéro" { return Ok(0) } @@ -215,7 +215,7 @@ pub fn texte_comme_nombre(texte: &str) -> Result { } let texte_separe: Vec<&str> = texte_modifie.split(separateur_texte).collect(); if texte_separe.len() > 2 { - return Err(ErreurSophie::NombreInvalide(texte.to_string())) + return Err(ErreurPendragon::NombreInvalide(texte.to_string())) } if texte_separe.len() > 1 { let petit_nombre_texte = texte_separe[0] @@ -246,7 +246,7 @@ pub fn texte_comme_nombre(texte: &str) -> Result { Ok(nombre) } -fn texte_comme_petit_nombre(texte: &str) -> Result { +fn texte_comme_petit_nombre(texte: &str) -> Result { let elements: Vec<&str> = texte.split(UNION).collect(); let mut nombre = 0; @@ -258,7 +258,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result { nombre = 1; } if nombre >= 100 { - return Err(ErreurSophie::NombreInvalide(texte.to_string())) + return Err(ErreurPendragon::NombreInvalide(texte.to_string())) } nombre *= 100; dernier_chiffre_texte = chiffre_texte; @@ -270,12 +270,12 @@ fn texte_comme_petit_nombre(texte: &str) -> Result { dernier_chiffre_texte = chiffre_texte; continue } else { - return Err(ErreurSophie::NombreInvalide(texte.to_string())) + return Err(ErreurPendragon::NombreInvalide(texte.to_string())) } } if let Some(chiffre) = NOMS_UNITES.iter().position(|&s| s == chiffre_texte) { if nombre%10 > 0 { - return Err(ErreurSophie::NombreInvalide(texte.to_string())) + return Err(ErreurPendragon::NombreInvalide(texte.to_string())) } nombre += chiffre; dernier_chiffre_texte = chiffre_texte; @@ -283,7 +283,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result { } if let Some(chiffre) = NOMS_DIZAINES.iter().position(|&s| s == chiffre_texte) { if nombre%100 > 0 && chiffre != 1 { - return Err(ErreurSophie::NombreInvalide(texte.to_string())) + return Err(ErreurPendragon::NombreInvalide(texte.to_string())) } nombre += chiffre*10; dernier_chiffre_texte = chiffre_texte; @@ -291,7 +291,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result { } if let Some(chiffre) = NOMS_UNITES_DIX.iter().position(|&s| s == chiffre_texte) { if nombre%10 > 0 { - return Err(ErreurSophie::NombreInvalide(texte.to_string())) + return Err(ErreurPendragon::NombreInvalide(texte.to_string())) } nombre += 10 + chiffre; dernier_chiffre_texte = chiffre_texte; @@ -300,7 +300,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result { if chiffre_texte == "et" { continue } - return Err(ErreurSophie::NombreInvalide(texte.to_string())) + return Err(ErreurPendragon::NombreInvalide(texte.to_string())) } Ok(nombre) diff --git a/src/sophie/structure.rs b/src/pendragon/structure.rs similarity index 91% rename from src/sophie/structure.rs rename to src/pendragon/structure.rs index 3f37b97..569873f 100644 --- a/src/sophie/structure.rs +++ b/src/pendragon/structure.rs @@ -20,10 +20,10 @@ impl Expression { contenu: vec![] } } - fn ajoute(&mut self, element: Element) -> Result<(), ErreurSophie> { + fn ajoute(&mut self, element: Element) -> Result<(), ErreurPendragon> { let type_element = element.type_element(); if self.type_expression != type_element { - return Err(ErreurSophie::MauvaisType("inconnue".into(), type_element.nom(), self.type_expression.nom())) + return Err(ErreurPendragon::MauvaisType("inconnue".into(), type_element.nom(), self.type_expression.nom())) } self.contenu.push(element); Ok(()) @@ -70,7 +70,7 @@ impl Element { } } -pub enum ErreurSophie { +pub enum ErreurPendragon { CommandeInconnue(String), PhraseVide, ManqueArgument, @@ -85,7 +85,7 @@ pub enum ErreurSophie { ManquePoint, } -impl fmt::Display for ErreurSophie { +impl fmt::Display for ErreurPendragon { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {//' match self { Self::CommandeInconnue(commande) => write!(f, "La commande \"{}\" est inconnue.", commande), diff --git a/src/sophie/tests.rs b/src/pendragon/tests.rs similarity index 91% rename from src/sophie/tests.rs rename to src/pendragon/tests.rs index 57e2ef6..741874c 100644 --- a/src/sophie/tests.rs +++ b/src/pendragon/tests.rs @@ -20,7 +20,7 @@ fn teste_somme() { for (a, b) in [(0, 0), (5, 7), (1467,45678), (1001, 0), (72_036_854_775_807usize, 14_036_567_775_807usize)] { let texte_a = nombre::nombre_comme_texte(a); let texte_b = nombre::nombre_comme_texte(b); - let sophie = Sophie::new(); + let sophie = Pendragon::new(); let resultat = sophie.operation(&format!("{} plus {}", texte_a, texte_b)); match resultat { // Convert text back to number Ok(nombre) => { @@ -35,7 +35,7 @@ fn teste_somme() { #[test] fn teste_definition_variable() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); let resultat = sophie.execute_phrase("Définis Element comme entier"); match resultat { Ok(_) => { @@ -49,7 +49,7 @@ fn teste_definition_variable() { #[test] fn teste_modification_variable() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") { panic!("Définition de variable échouée : {}", raison); } @@ -67,7 +67,7 @@ fn teste_modification_variable() { #[test] fn teste_operation_variable() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") { panic!("Définition de variable échouée : {}", raison); } @@ -89,7 +89,7 @@ fn teste_operation_variable() { #[test] fn teste_maths() { - let sophie = Sophie::new(); + let sophie = Pendragon::new(); let a = 2345678; let b = 987654; let c = 34523456; @@ -113,7 +113,7 @@ fn teste_maths() { #[test] fn teste_texte() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); if let Err(raison) = sophie.execute_phrase("Définis A comme entier") { panic!("Définition de variable échouée : {}", raison); } @@ -139,14 +139,14 @@ fn teste_texte() { #[test] fn teste_redefinition_variable() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") { panic!("Définition de variable échouée : {}", raison); }; let Err(raison) = sophie.execute_phrase("Définis Element comme texte") else { panic!("Ne devrais pas pouvoir redéfinir une variable"); }; - if let ErreurSophie::MauvaisArgument(ref texte) = raison { + if let ErreurPendragon::MauvaisArgument(ref texte) = raison { assert_eq!(texte, "la variable \"Element\" existe déjà", "Définition échouée avec erreur imprévue : {}", raison); } else { panic!("Définition échouée avec erreur imprévue : {}", raison); @@ -155,12 +155,12 @@ fn teste_redefinition_variable() { #[test] fn teste_echec_modification() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); let resultat = sophie.execute_phrase("Modifie Element avec deux"); let Err(raison) = resultat else { panic!("Ne devrais pas pouvoir modifier une variable non définie"); }; - if let ErreurSophie::VariableInconnue(nom) = raison { + if let ErreurPendragon::VariableInconnue(nom) = raison { assert_eq!(nom, "Element", "Mauvais nom de variable reconnu : {}", nom); } else { panic!("Modification échouée avec erreur imprévue : {}", raison); @@ -169,12 +169,12 @@ fn teste_echec_modification() { #[test] fn teste_majuscule_variable() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); let resultat = sophie.execute_phrase("Définis variable comme entier"); let Err(raison) = resultat else { panic!("Ne devrais pas pouvoir definir une variable sans majuscule"); }; - if let ErreurSophie::MauvaisArgument(explication) = raison { + if let ErreurPendragon::MauvaisArgument(explication) = raison { assert_eq!(explication, "il manque une majuscule à la variable", "Mauvaise explication : {}", explication); } else { panic!("Définition échouée avec erreur imprévue : {}", raison); @@ -183,12 +183,12 @@ fn teste_majuscule_variable() { #[test] fn teste_point_phrase() { - let mut sophie = Sophie::new(); + let mut sophie = Pendragon::new(); let resultat = sophie.execute("Définis Element comme entier".into()); let Err(raison) = resultat else { panic!("Ne devrais pas pouvoir faire de commande sans point à la fin"); }; - let ErreurSophie::ManquePoint = raison else { + let ErreurPendragon::ManquePoint = raison else { panic!("Définition échouée avec erreur imprévue : {}", raison); }; } diff --git a/src/sophie/texte.rs b/src/pendragon/texte.rs similarity index 70% rename from src/sophie/texte.rs rename to src/pendragon/texte.rs index 1a4a4cf..e4efc02 100644 --- a/src/sophie/texte.rs +++ b/src/pendragon/texte.rs @@ -1,11 +1,11 @@ -use super::Sophie; -use super::ErreurSophie; +use super::Pendragon; +use super::ErreurPendragon; use super::Element; use super::nombre; use super::booleen; -impl Sophie { - pub fn texte(&self, arguments: &str) -> Result { +impl Pendragon { + pub fn texte(&self, arguments: &str) -> Result { let liste_arguments: Vec<&str> = arguments.split(',').collect(); let mut texte = "".to_string(); @@ -16,7 +16,7 @@ impl Sophie { if argument.ends_with('"') { texte += &argument[1..argument.len()-1]; } else { - return Err(ErreurSophie::TexteInvalide("guillemet mal refermé".into())) + return Err(ErreurPendragon::TexteInvalide("guillemet mal refermé".into())) } continue; } @@ -34,7 +34,7 @@ impl Sophie { let variable = self.recupere_variable(argument)?; let Element::Texte(contenu) = variable else { - return Err(ErreurSophie::MauvaisType(argument.into(), variable.type_element().nom(), "texte".into())) + return Err(ErreurPendragon::MauvaisType(argument.into(), variable.type_element().nom(), "texte".into())) }; texte += &contenu; diff --git a/test.sp b/test.dr similarity index 85% rename from test.sp rename to test.dr index 72b305a..bcbd5c2 100644 --- a/test.sp +++ b/test.dr @@ -4,4 +4,4 @@ Affiche A. Définis B comme booléen. Affiche "B ou : ", B ou vrai. Affiche "B et : ", B et vrai. -Affiche dix fois dix fois dix. \ No newline at end of file +Affiche dix fois dix fois dix.