pendragon
This commit is contained in:
parent
a8b1110f97
commit
62513b59a3
2
Cargo.lock
generated
2
Cargo.lock
generated
|
@ -3,5 +3,5 @@
|
|||
version = 3
|
||||
|
||||
[[package]]
|
||||
name = "sophie"
|
||||
name = "pendragon"
|
||||
version = "0.1.0"
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
[package]
|
||||
name = "sophie"
|
||||
name = "pendragon"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
|
|
10
src/main.rs
10
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<String> = env::args().collect();
|
||||
|
||||
if arguments.len() < 2 {
|
||||
eprintln!("Utilisation : sophie <FILE>");
|
||||
eprintln!("Utilisation : pendragon <FILE>");
|
||||
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);
|
||||
|
|
|
@ -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<bool, ErreurSophie> {
|
||||
impl Pendragon {
|
||||
pub fn condition(&self, arguments: &str) -> Result<bool, ErreurPendragon> {
|
||||
self.condition_elementaire(arguments)
|
||||
}
|
||||
|
||||
pub fn condition_elementaire(&self, texte: &str) -> Result<bool, ErreurSophie> {
|
||||
pub fn condition_elementaire(&self, texte: &str) -> Result<bool, ErreurPendragon> {
|
||||
let mut expression: Vec<String> = 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<bool, ErreurSophie> {
|
||||
pub fn texte_comme_booleen(&self, texte: &str) -> Result<bool, ErreurPendragon> {
|
||||
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<bool, ErreurSophie> {
|
||||
pub fn texte_comme_booleen(texte: &str) -> Result<bool, ErreurPendragon> {
|
||||
match texte {
|
||||
"vrai" => Ok(true),
|
||||
"faux" => Ok(false),
|
||||
_ => Err(ErreurSophie::BooleenInvalide(texte.into())),
|
||||
_ => Err(ErreurPendragon::BooleenInvalide(texte.into())),
|
||||
}
|
||||
}
|
|
@ -10,23 +10,23 @@ use structure::*;
|
|||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
pub struct Sophie {
|
||||
pub struct Pendragon {
|
||||
variables: HashMap<String, Element>,
|
||||
}
|
||||
|
||||
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<Element, ErreurSophie> {
|
||||
fn recupere_variable(&self, nom: &str) -> Result<Element, ErreurPendragon> {
|
||||
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()))
|
||||
}
|
|
@ -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<usize, ErreurSophie> {
|
||||
impl Pendragon {
|
||||
pub fn operation(&self, arguments: &str) -> Result<usize, ErreurPendragon> {
|
||||
//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<usize, ErreurSophie> {
|
||||
pub fn operation_elementaire(&self, arguments: &str) -> Result<usize, ErreurPendragon> {
|
||||
let texte = arguments.replace("divisé par", "divise-par");
|
||||
let mut expression: Vec<String> = 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<usize, ErreurSophie> {
|
||||
pub fn texte_comme_nombre(&self, texte: &str) -> Result<usize, ErreurPendragon> {
|
||||
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<usize, ErreurSophie> {
|
||||
pub fn texte_comme_nombre(texte: &str) -> Result<usize, ErreurPendragon> {
|
||||
if texte == "zéro" {
|
||||
return Ok(0)
|
||||
}
|
||||
|
@ -215,7 +215,7 @@ pub fn texte_comme_nombre(texte: &str) -> Result<usize, ErreurSophie> {
|
|||
}
|
||||
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<usize, ErreurSophie> {
|
|||
Ok(nombre)
|
||||
}
|
||||
|
||||
fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
|
||||
fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurPendragon> {
|
||||
let elements: Vec<&str> = texte.split(UNION).collect();
|
||||
|
||||
let mut nombre = 0;
|
||||
|
@ -258,7 +258,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
|
|||
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<usize, ErreurSophie> {
|
|||
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<usize, ErreurSophie> {
|
|||
}
|
||||
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<usize, ErreurSophie> {
|
|||
}
|
||||
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<usize, ErreurSophie> {
|
|||
if chiffre_texte == "et" {
|
||||
continue
|
||||
}
|
||||
return Err(ErreurSophie::NombreInvalide(texte.to_string()))
|
||||
return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
|
||||
}
|
||||
|
||||
Ok(nombre)
|
|
@ -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),
|
|
@ -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);
|
||||
};
|
||||
}
|
|
@ -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<String, ErreurSophie> {
|
||||
impl Pendragon {
|
||||
pub fn texte(&self, arguments: &str) -> Result<String, ErreurPendragon> {
|
||||
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;
|
Loading…
Reference in a new issue