penwing/Pendragon
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

pendragon

Browse source
This commit is contained in:
WanderingPenwing 2024-12-09 13:19:00 +01:00
parent a8b1110f97
commit 62513b59a3
11 changed files with 92 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -3,5 +3,5 @@
version = 3
[[package]]
name = "sophie"
name = "pendragon"
version = "0.1.0"

2
Cargo.toml
View file

@ -1,5 +1,5 @@
[package]
name = "sophie"
name = "pendragon"
version = "0.1.0"
edition = "2021"

0
sophie.project → pendragon.project
View file

10
src/main.rs
View file

@ -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);

28
src/sophie/booleen.rs → src/pendragon/booleen.rs
View file

@ -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())),
}
}

46
src/sophie/mod.rs → src/pendragon/mod.rs
View file

@ -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()))
}

46
src/sophie/nombre.rs → src/pendragon/nombre.rs
View file

@ -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)

8
src/sophie/structure.rs → src/pendragon/structure.rs
View file

@ -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),

28
src/sophie/tests.rs → src/pendragon/tests.rs
View file

@ -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);
};
}

12
src/sophie/texte.rs → src/pendragon/texte.rs
View file

@ -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;

2
test.sp → test.dr
View file

@ -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.
Affiche dix fois dix fois dix.