pendragon
This commit is contained in:
parent
a8b1110f97
commit
62513b59a3
2
Cargo.lock
generated
2
Cargo.lock
generated
|
@ -3,5 +3,5 @@
|
||||||
version = 3
|
version = 3
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "sophie"
|
name = "pendragon"
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
[package]
|
[package]
|
||||||
name = "sophie"
|
name = "pendragon"
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
edition = "2021"
|
edition = "2021"
|
||||||
|
|
||||||
|
|
10
src/main.rs
10
src/main.rs
|
@ -1,23 +1,23 @@
|
||||||
use std::env;
|
use std::env;
|
||||||
use std::fs;
|
use std::fs;
|
||||||
|
|
||||||
mod sophie;
|
mod pendragon;
|
||||||
use sophie::*;
|
use pendragon::*;
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
let arguments: Vec<String> = env::args().collect();
|
let arguments: Vec<String> = env::args().collect();
|
||||||
|
|
||||||
if arguments.len() < 2 {
|
if arguments.len() < 2 {
|
||||||
eprintln!("Utilisation : sophie <FILE>");
|
eprintln!("Utilisation : pendragon <FILE>");
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
let chemin_de_fichier = &arguments[1];
|
let chemin_de_fichier = &arguments[1];
|
||||||
let mut sophie = Sophie::new();
|
let mut pendragon = Pendragon::new();
|
||||||
|
|
||||||
match fs::read_to_string(chemin_de_fichier) {
|
match fs::read_to_string(chemin_de_fichier) {
|
||||||
Ok(contenu) => {
|
Ok(contenu) => {
|
||||||
let _ = sophie.execute(contenu);
|
let _ = pendragon.execute(contenu);
|
||||||
}
|
}
|
||||||
Err(raison) => {
|
Err(raison) => {
|
||||||
eprintln!("Fichier illisible : {}", raison);
|
eprintln!("Fichier illisible : {}", raison);
|
||||||
|
|
|
@ -1,13 +1,13 @@
|
||||||
use super::Sophie;
|
use super::Pendragon;
|
||||||
use super::ErreurSophie;
|
use super::ErreurPendragon;
|
||||||
use super::Element;
|
use super::Element;
|
||||||
|
|
||||||
impl Sophie {
|
impl Pendragon {
|
||||||
pub fn condition(&self, arguments: &str) -> Result<bool, ErreurSophie> {
|
pub fn condition(&self, arguments: &str) -> Result<bool, ErreurPendragon> {
|
||||||
self.condition_elementaire(arguments)
|
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 expression: Vec<String> = texte.split(" ").map(String::from).collect();
|
||||||
|
|
||||||
let mut index = 0;
|
let mut index = 0;
|
||||||
|
@ -17,7 +17,7 @@ impl Sophie {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if index == expression.len() - 1 {
|
if index == expression.len() - 1 {
|
||||||
return Err(ErreurSophie::ManqueArgument);
|
return Err(ErreurPendragon::ManqueArgument);
|
||||||
}
|
}
|
||||||
let a = self.texte_comme_booleen(&expression[index + 1])?;
|
let a = self.texte_comme_booleen(&expression[index + 1])?;
|
||||||
expression[index] = booleen_comme_texte(!a);
|
expression[index] = booleen_comme_texte(!a);
|
||||||
|
@ -30,7 +30,7 @@ impl Sophie {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if index == 0 || index == expression.len() - 1 {
|
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 a = self.texte_comme_booleen(&expression[index - 1])?;
|
||||||
let b = self.texte_comme_booleen(&expression[index + 1])?;
|
let b = self.texte_comme_booleen(&expression[index + 1])?;
|
||||||
|
@ -46,7 +46,7 @@ impl Sophie {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if index == 0 || index == expression.len() - 1 {
|
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 a = self.texte_comme_booleen(&expression[index - 1])?;
|
||||||
let b = 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);
|
expression.remove(index + 1);
|
||||||
}
|
}
|
||||||
if expression.len() > 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])
|
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 texte.chars().next().map_or(false, |c| c.is_uppercase()) {
|
||||||
if self.variables.contains_key(texte) {
|
if self.variables.contains_key(texte) {
|
||||||
let Element::Booleen(booleen) = self.variables[texte] else {
|
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);
|
return Ok(booleen);
|
||||||
} else {
|
} else {
|
||||||
return Err(ErreurSophie::VariableInconnue(texte.to_string()))
|
return Err(ErreurPendragon::VariableInconnue(texte.to_string()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
texte_comme_booleen(texte)
|
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 {
|
match texte {
|
||||||
"vrai" => Ok(true),
|
"vrai" => Ok(true),
|
||||||
"faux" => Ok(false),
|
"faux" => Ok(false),
|
||||||
_ => Err(ErreurSophie::BooleenInvalide(texte.into())),
|
_ => Err(ErreurPendragon::BooleenInvalide(texte.into())),
|
||||||
}
|
}
|
||||||
}
|
}
|
|
@ -10,23 +10,23 @@ use structure::*;
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests;
|
mod tests;
|
||||||
|
|
||||||
pub struct Sophie {
|
pub struct Pendragon {
|
||||||
variables: HashMap<String, Element>,
|
variables: HashMap<String, Element>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Sophie {
|
impl Pendragon {
|
||||||
pub fn new() -> Self {
|
pub fn new() -> Self {
|
||||||
Self {
|
Self {
|
||||||
variables: HashMap::new(),
|
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 contenu_propre = contenu.replace("\n", "");
|
||||||
let mut texte: Vec<&str> = contenu_propre.split('.').collect();
|
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("") {
|
if reste != Some("") {
|
||||||
eprintln!("Erreur phrase {} : Il manque un point.", texte.len() + 1);
|
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() {
|
for (index_phrase, phrase) in texte.iter().enumerate() {
|
||||||
match self.execute_phrase(phrase) {
|
match self.execute_phrase(phrase) {
|
||||||
|
@ -40,16 +40,16 @@ impl Sophie {
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurSophie> {
|
fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurPendragon> {
|
||||||
let phrase = phrase.trim();
|
let phrase = phrase.trim();
|
||||||
let parties: Vec<&str> = phrase.splitn(2, ' ').collect();
|
let parties: Vec<&str> = phrase.splitn(2, ' ').collect();
|
||||||
|
|
||||||
if parties.is_empty() {
|
if parties.is_empty() {
|
||||||
return Err(ErreurSophie::PhraseVide)
|
return Err(ErreurPendragon::PhraseVide)
|
||||||
}
|
}
|
||||||
|
|
||||||
if parties.len() == 1 {
|
if parties.len() == 1 {
|
||||||
return Err(ErreurSophie::ManqueArgument)
|
return Err(ErreurPendragon::ManqueArgument)
|
||||||
}
|
}
|
||||||
|
|
||||||
match parties[0] {
|
match parties[0] {
|
||||||
|
@ -66,26 +66,26 @@ impl Sophie {
|
||||||
self.demande(parties[1])?;
|
self.demande(parties[1])?;
|
||||||
}
|
}
|
||||||
autre_commande => {
|
autre_commande => {
|
||||||
return Err(ErreurSophie::CommandeInconnue(autre_commande.to_string()))
|
return Err(ErreurPendragon::CommandeInconnue(autre_commande.to_string()))
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn affiche(&self, arguments: &str) -> Result<(), ErreurSophie> {
|
fn affiche(&self, arguments: &str) -> Result<(), ErreurPendragon> {
|
||||||
println!("{}", self.texte(arguments)?);
|
println!("{}", self.texte(arguments)?);
|
||||||
Ok(())
|
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 (variable_nom, variable_type) = self.nom_de_variable(arguments, "comme")?;
|
||||||
|
|
||||||
let possible_variable = self.recupere_variable(&variable_nom);
|
let possible_variable = self.recupere_variable(&variable_nom);
|
||||||
|
|
||||||
let Err(raison) = possible_variable else {
|
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)
|
return Err(raison)
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -93,14 +93,14 @@ impl Sophie {
|
||||||
"entier" => Element::Entier(0),
|
"entier" => Element::Entier(0),
|
||||||
"texte" => Element::Texte("".to_string()),
|
"texte" => Element::Texte("".to_string()),
|
||||||
"booléen" => Element::Booleen(false),
|
"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);
|
self.variables.insert(variable_nom, contenu);
|
||||||
Ok(())
|
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_nom, contenu) = self.nom_de_variable(arguments, "avec")?;
|
||||||
let variable = self.recupere_variable(&variable_nom)?;
|
let variable = self.recupere_variable(&variable_nom)?;
|
||||||
|
|
||||||
|
@ -114,7 +114,7 @@ impl Sophie {
|
||||||
Ok(())
|
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 (variable_nom, _) = self.nom_de_variable(arguments, "")?;
|
||||||
|
|
||||||
let _ = self.recupere_variable(&variable_nom)?;
|
let _ = self.recupere_variable(&variable_nom)?;
|
||||||
|
@ -122,7 +122,7 @@ impl Sophie {
|
||||||
println!("Quelle valeur pour {} ?", variable_nom);
|
println!("Quelle valeur pour {} ?", variable_nom);
|
||||||
let mut reponse: String = String::new();
|
let mut reponse: String = String::new();
|
||||||
if let Err(_) = io::stdin().read_line(&mut reponse) {
|
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();
|
let contenu = reponse.trim();
|
||||||
|
@ -137,20 +137,20 @@ impl Sophie {
|
||||||
Ok(())
|
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 {
|
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() {
|
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) {
|
if !self.variables.contains_key(nom) {
|
||||||
return Err(ErreurSophie::VariableInconnue(nom.into()))
|
return Err(ErreurPendragon::VariableInconnue(nom.into()))
|
||||||
}
|
}
|
||||||
Ok(self.variables[nom].clone())
|
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 == "" {
|
let parties = if separateur == "" {
|
||||||
vec![arguments, ""]
|
vec![arguments, ""]
|
||||||
} else {
|
} else {
|
||||||
|
@ -160,7 +160,7 @@ impl Sophie {
|
||||||
let nom_variable = parties[0].trim().to_string();
|
let nom_variable = parties[0].trim().to_string();
|
||||||
|
|
||||||
if parties.len() == 1 {
|
if parties.len() == 1 {
|
||||||
return Err(ErreurSophie::ManqueArgument)
|
return Err(ErreurPendragon::ManqueArgument)
|
||||||
}
|
}
|
||||||
Ok((nom_variable, parties[1].trim().to_string()))
|
Ok((nom_variable, parties[1].trim().to_string()))
|
||||||
}
|
}
|
|
@ -1,5 +1,5 @@
|
||||||
use super::ErreurSophie;
|
use super::ErreurPendragon;
|
||||||
use super::Sophie;
|
use super::Pendragon;
|
||||||
use super::Element;
|
use super::Element;
|
||||||
|
|
||||||
const NOMS_UNITES: [&str; 10] = ["", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf"];
|
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 NOMS_SEPARATEURS: [&str; 7] = ["", "mille", "million", "milliard", "billion", "billiard", "trillion"];
|
||||||
const UNION: &str = "-";
|
const UNION: &str = "-";
|
||||||
|
|
||||||
impl Sophie {
|
impl Pendragon {
|
||||||
pub fn operation(&self, arguments: &str) -> Result<usize, ErreurSophie> {
|
pub fn operation(&self, arguments: &str) -> Result<usize, ErreurPendragon> {
|
||||||
//return self.operation_elementaire(arguments);
|
//return self.operation_elementaire(arguments);
|
||||||
let texte = arguments
|
let texte = arguments
|
||||||
.replace("ouvre la parenthèse", "ouvre-la-parenthese")
|
.replace("ouvre la parenthèse", "ouvre-la-parenthese")
|
||||||
|
@ -30,10 +30,10 @@ impl Sophie {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
let Some(index_ouverture) = ouverture else {
|
let Some(index_ouverture) = ouverture else {
|
||||||
return Err(ErreurSophie::DesequilibreParenthese);
|
return Err(ErreurPendragon::DesequilibreParenthese);
|
||||||
};
|
};
|
||||||
let Some(index_fermeture) = fermeture else {
|
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 contenu: String = expression[(index_ouverture+1)..(index_fermeture)].join(" ");
|
||||||
let nombre = self.operation_elementaire(&contenu)?;
|
let nombre = self.operation_elementaire(&contenu)?;
|
||||||
|
@ -44,12 +44,12 @@ impl Sophie {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if expression.contains(&"ferme-la-parenthese".to_string()) {
|
if expression.contains(&"ferme-la-parenthese".to_string()) {
|
||||||
return Err(ErreurSophie::DesequilibreParenthese);
|
return Err(ErreurPendragon::DesequilibreParenthese);
|
||||||
}
|
}
|
||||||
self.operation_elementaire(&expression.join(" "))
|
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 texte = arguments.replace("divisé par", "divise-par");
|
||||||
let mut expression: Vec<String> = texte.split(" ").map(String::from).collect();
|
let mut expression: Vec<String> = texte.split(" ").map(String::from).collect();
|
||||||
|
|
||||||
|
@ -60,7 +60,7 @@ impl Sophie {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if index == 0 || index == expression.len() - 1 {
|
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 a = self.texte_comme_nombre(&expression[index - 1])?;
|
||||||
let b = self.texte_comme_nombre(&expression[index + 1])?;
|
let b = self.texte_comme_nombre(&expression[index + 1])?;
|
||||||
|
@ -79,7 +79,7 @@ impl Sophie {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if index == 0 || index == expression.len() - 1 {
|
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 a = self.texte_comme_nombre(&expression[index - 1])?;
|
||||||
let b = 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 {
|
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])
|
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 texte.chars().next().map_or(false, |c| c.is_uppercase()) {
|
||||||
if self.variables.contains_key(texte) {
|
if self.variables.contains_key(texte) {
|
||||||
let Element::Entier(nombre) = self.variables[texte] else {
|
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);
|
return Ok(nombre);
|
||||||
} else {
|
} else {
|
||||||
return Err(ErreurSophie::VariableInconnue(texte.to_string()))
|
return Err(ErreurPendragon::VariableInconnue(texte.to_string()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
texte_comme_nombre(texte)
|
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)
|
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" {
|
if texte == "zéro" {
|
||||||
return Ok(0)
|
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();
|
let texte_separe: Vec<&str> = texte_modifie.split(separateur_texte).collect();
|
||||||
if texte_separe.len() > 2 {
|
if texte_separe.len() > 2 {
|
||||||
return Err(ErreurSophie::NombreInvalide(texte.to_string()))
|
return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
|
||||||
}
|
}
|
||||||
if texte_separe.len() > 1 {
|
if texte_separe.len() > 1 {
|
||||||
let petit_nombre_texte = texte_separe[0]
|
let petit_nombre_texte = texte_separe[0]
|
||||||
|
@ -246,7 +246,7 @@ pub fn texte_comme_nombre(texte: &str) -> Result<usize, ErreurSophie> {
|
||||||
Ok(nombre)
|
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 elements: Vec<&str> = texte.split(UNION).collect();
|
||||||
|
|
||||||
let mut nombre = 0;
|
let mut nombre = 0;
|
||||||
|
@ -258,7 +258,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
|
||||||
nombre = 1;
|
nombre = 1;
|
||||||
}
|
}
|
||||||
if nombre >= 100 {
|
if nombre >= 100 {
|
||||||
return Err(ErreurSophie::NombreInvalide(texte.to_string()))
|
return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
|
||||||
}
|
}
|
||||||
nombre *= 100;
|
nombre *= 100;
|
||||||
dernier_chiffre_texte = chiffre_texte;
|
dernier_chiffre_texte = chiffre_texte;
|
||||||
|
@ -270,12 +270,12 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
|
||||||
dernier_chiffre_texte = chiffre_texte;
|
dernier_chiffre_texte = chiffre_texte;
|
||||||
continue
|
continue
|
||||||
} else {
|
} 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 let Some(chiffre) = NOMS_UNITES.iter().position(|&s| s == chiffre_texte) {
|
||||||
if nombre%10 > 0 {
|
if nombre%10 > 0 {
|
||||||
return Err(ErreurSophie::NombreInvalide(texte.to_string()))
|
return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
|
||||||
}
|
}
|
||||||
nombre += chiffre;
|
nombre += chiffre;
|
||||||
dernier_chiffre_texte = chiffre_texte;
|
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 let Some(chiffre) = NOMS_DIZAINES.iter().position(|&s| s == chiffre_texte) {
|
||||||
if nombre%100 > 0 && chiffre != 1 {
|
if nombre%100 > 0 && chiffre != 1 {
|
||||||
return Err(ErreurSophie::NombreInvalide(texte.to_string()))
|
return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
|
||||||
}
|
}
|
||||||
nombre += chiffre*10;
|
nombre += chiffre*10;
|
||||||
dernier_chiffre_texte = chiffre_texte;
|
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 let Some(chiffre) = NOMS_UNITES_DIX.iter().position(|&s| s == chiffre_texte) {
|
||||||
if nombre%10 > 0 {
|
if nombre%10 > 0 {
|
||||||
return Err(ErreurSophie::NombreInvalide(texte.to_string()))
|
return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
|
||||||
}
|
}
|
||||||
nombre += 10 + chiffre;
|
nombre += 10 + chiffre;
|
||||||
dernier_chiffre_texte = chiffre_texte;
|
dernier_chiffre_texte = chiffre_texte;
|
||||||
|
@ -300,7 +300,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
|
||||||
if chiffre_texte == "et" {
|
if chiffre_texte == "et" {
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
return Err(ErreurSophie::NombreInvalide(texte.to_string()))
|
return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
|
||||||
}
|
}
|
||||||
|
|
||||||
Ok(nombre)
|
Ok(nombre)
|
|
@ -20,10 +20,10 @@ impl Expression {
|
||||||
contenu: vec![]
|
contenu: vec![]
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn ajoute(&mut self, element: Element) -> Result<(), ErreurSophie> {
|
fn ajoute(&mut self, element: Element) -> Result<(), ErreurPendragon> {
|
||||||
let type_element = element.type_element();
|
let type_element = element.type_element();
|
||||||
if self.type_expression != 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);
|
self.contenu.push(element);
|
||||||
Ok(())
|
Ok(())
|
||||||
|
@ -70,7 +70,7 @@ impl Element {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub enum ErreurSophie {
|
pub enum ErreurPendragon {
|
||||||
CommandeInconnue(String),
|
CommandeInconnue(String),
|
||||||
PhraseVide,
|
PhraseVide,
|
||||||
ManqueArgument,
|
ManqueArgument,
|
||||||
|
@ -85,7 +85,7 @@ pub enum ErreurSophie {
|
||||||
ManquePoint,
|
ManquePoint,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl fmt::Display for ErreurSophie {
|
impl fmt::Display for ErreurPendragon {
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {//'
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {//'
|
||||||
match self {
|
match self {
|
||||||
Self::CommandeInconnue(commande) => write!(f, "La commande \"{}\" est inconnue.", commande),
|
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)] {
|
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_a = nombre::nombre_comme_texte(a);
|
||||||
let texte_b = nombre::nombre_comme_texte(b);
|
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));
|
let resultat = sophie.operation(&format!("{} plus {}", texte_a, texte_b));
|
||||||
match resultat { // Convert text back to number
|
match resultat { // Convert text back to number
|
||||||
Ok(nombre) => {
|
Ok(nombre) => {
|
||||||
|
@ -35,7 +35,7 @@ fn teste_somme() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_definition_variable() {
|
fn teste_definition_variable() {
|
||||||
let mut sophie = Sophie::new();
|
let mut sophie = Pendragon::new();
|
||||||
let resultat = sophie.execute_phrase("Définis Element comme entier");
|
let resultat = sophie.execute_phrase("Définis Element comme entier");
|
||||||
match resultat {
|
match resultat {
|
||||||
Ok(_) => {
|
Ok(_) => {
|
||||||
|
@ -49,7 +49,7 @@ fn teste_definition_variable() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_modification_variable() {
|
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") {
|
if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") {
|
||||||
panic!("Définition de variable échouée : {}", raison);
|
panic!("Définition de variable échouée : {}", raison);
|
||||||
}
|
}
|
||||||
|
@ -67,7 +67,7 @@ fn teste_modification_variable() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_operation_variable() {
|
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") {
|
if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") {
|
||||||
panic!("Définition de variable échouée : {}", raison);
|
panic!("Définition de variable échouée : {}", raison);
|
||||||
}
|
}
|
||||||
|
@ -89,7 +89,7 @@ fn teste_operation_variable() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_maths() {
|
fn teste_maths() {
|
||||||
let sophie = Sophie::new();
|
let sophie = Pendragon::new();
|
||||||
let a = 2345678;
|
let a = 2345678;
|
||||||
let b = 987654;
|
let b = 987654;
|
||||||
let c = 34523456;
|
let c = 34523456;
|
||||||
|
@ -113,7 +113,7 @@ fn teste_maths() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_texte() {
|
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") {
|
if let Err(raison) = sophie.execute_phrase("Définis A comme entier") {
|
||||||
panic!("Définition de variable échouée : {}", raison);
|
panic!("Définition de variable échouée : {}", raison);
|
||||||
}
|
}
|
||||||
|
@ -139,14 +139,14 @@ fn teste_texte() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_redefinition_variable() {
|
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") {
|
if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") {
|
||||||
panic!("Définition de variable échouée : {}", raison);
|
panic!("Définition de variable échouée : {}", raison);
|
||||||
};
|
};
|
||||||
let Err(raison) = sophie.execute_phrase("Définis Element comme texte") else {
|
let Err(raison) = sophie.execute_phrase("Définis Element comme texte") else {
|
||||||
panic!("Ne devrais pas pouvoir redéfinir une variable");
|
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);
|
assert_eq!(texte, "la variable \"Element\" existe déjà", "Définition échouée avec erreur imprévue : {}", raison);
|
||||||
} else {
|
} else {
|
||||||
panic!("Définition échouée avec erreur imprévue : {}", raison);
|
panic!("Définition échouée avec erreur imprévue : {}", raison);
|
||||||
|
@ -155,12 +155,12 @@ fn teste_redefinition_variable() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_echec_modification() {
|
fn teste_echec_modification() {
|
||||||
let mut sophie = Sophie::new();
|
let mut sophie = Pendragon::new();
|
||||||
let resultat = sophie.execute_phrase("Modifie Element avec deux");
|
let resultat = sophie.execute_phrase("Modifie Element avec deux");
|
||||||
let Err(raison) = resultat else {
|
let Err(raison) = resultat else {
|
||||||
panic!("Ne devrais pas pouvoir modifier une variable non définie");
|
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);
|
assert_eq!(nom, "Element", "Mauvais nom de variable reconnu : {}", nom);
|
||||||
} else {
|
} else {
|
||||||
panic!("Modification échouée avec erreur imprévue : {}", raison);
|
panic!("Modification échouée avec erreur imprévue : {}", raison);
|
||||||
|
@ -169,12 +169,12 @@ fn teste_echec_modification() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_majuscule_variable() {
|
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 resultat = sophie.execute_phrase("Définis variable comme entier");
|
||||||
let Err(raison) = resultat else {
|
let Err(raison) = resultat else {
|
||||||
panic!("Ne devrais pas pouvoir definir une variable sans majuscule");
|
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);
|
assert_eq!(explication, "il manque une majuscule à la variable", "Mauvaise explication : {}", explication);
|
||||||
} else {
|
} else {
|
||||||
panic!("Définition échouée avec erreur imprévue : {}", raison);
|
panic!("Définition échouée avec erreur imprévue : {}", raison);
|
||||||
|
@ -183,12 +183,12 @@ fn teste_majuscule_variable() {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn teste_point_phrase() {
|
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 resultat = sophie.execute("Définis Element comme entier".into());
|
||||||
let Err(raison) = resultat else {
|
let Err(raison) = resultat else {
|
||||||
panic!("Ne devrais pas pouvoir faire de commande sans point à la fin");
|
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);
|
panic!("Définition échouée avec erreur imprévue : {}", raison);
|
||||||
};
|
};
|
||||||
}
|
}
|
|
@ -1,11 +1,11 @@
|
||||||
use super::Sophie;
|
use super::Pendragon;
|
||||||
use super::ErreurSophie;
|
use super::ErreurPendragon;
|
||||||
use super::Element;
|
use super::Element;
|
||||||
use super::nombre;
|
use super::nombre;
|
||||||
use super::booleen;
|
use super::booleen;
|
||||||
|
|
||||||
impl Sophie {
|
impl Pendragon {
|
||||||
pub fn texte(&self, arguments: &str) -> Result<String, ErreurSophie> {
|
pub fn texte(&self, arguments: &str) -> Result<String, ErreurPendragon> {
|
||||||
let liste_arguments: Vec<&str> = arguments.split(',').collect();
|
let liste_arguments: Vec<&str> = arguments.split(',').collect();
|
||||||
|
|
||||||
let mut texte = "".to_string();
|
let mut texte = "".to_string();
|
||||||
|
@ -16,7 +16,7 @@ impl Sophie {
|
||||||
if argument.ends_with('"') {
|
if argument.ends_with('"') {
|
||||||
texte += &argument[1..argument.len()-1];
|
texte += &argument[1..argument.len()-1];
|
||||||
} else {
|
} else {
|
||||||
return Err(ErreurSophie::TexteInvalide("guillemet mal refermé".into()))
|
return Err(ErreurPendragon::TexteInvalide("guillemet mal refermé".into()))
|
||||||
}
|
}
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
@ -34,7 +34,7 @@ impl Sophie {
|
||||||
let variable = self.recupere_variable(argument)?;
|
let variable = self.recupere_variable(argument)?;
|
||||||
|
|
||||||
let Element::Texte(contenu) = variable else {
|
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;
|
texte += &contenu;
|
|
@ -4,4 +4,4 @@ Affiche A.
|
||||||
Définis B comme booléen.
|
Définis B comme booléen.
|
||||||
Affiche "B ou : ", B ou vrai.
|
Affiche "B ou : ", B ou vrai.
|
||||||
Affiche "B et : ", B et vrai.
|
Affiche "B et : ", B et vrai.
|
||||||
Affiche dix fois dix fois dix.
|
Affiche dix fois dix fois dix.
|
Loading…
Reference in a new issue