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

in progress of restructure

Browse source
This commit is contained in:
WanderingPenwing 2024-12-09 13:44:46 +01:00
parent 62513b59a3
commit 797b9991ea
4 changed files with 170 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/main.rs
View file

@ -17,7 +17,7 @@ fn main() {
match fs::read_to_string(chemin_de_fichier) { match fs::read_to_string(chemin_de_fichier) {
Ok(contenu) => { Ok(contenu) => {
let _ = pendragon.execute(contenu); let _ = pendragon.compile(contenu);
} }
Err(raison) => { Err(raison) => {
eprintln!("Fichier illisible : {}", raison); eprintln!("Fichier illisible : {}", raison);

54
src/pendragon/mod.rs
View file

@ -20,7 +20,7 @@ impl Pendragon {
variables: HashMap::new(), variables: HashMap::new(),
} }
} }
pub fn execute(&mut self, contenu: String) -> Result<(), ErreurPendragon> { pub fn compile(&mut self, contenu: String) -> Result<Vec<Commande>, 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(); let reste = texte.pop();
@ -28,56 +28,50 @@ impl Pendragon {
eprintln!("Erreur phrase {} : Il manque un point.", texte.len() + 1); eprintln!("Erreur phrase {} : Il manque un point.", texte.len() + 1);
return Err(ErreurPendragon::ManquePoint) return Err(ErreurPendragon::ManquePoint)
} }
let mut liste_commandes = Vec<Commande> = vec![];
for (index_phrase, phrase) in texte.iter().enumerate() { for (index_phrase, phrase) in texte.iter().enumerate() {
match self.execute_phrase(phrase) { match self.compile_phrase(phrase) {
Ok(_) => {}, Ok(commande) => {liste_commandes.push(commande)},
Err(raison) => { Err(raison) => {
eprintln!("Erreur phrase {} : {}", index_phrase + 1, raison); eprintln!("Erreur phrase {} : {}", index_phrase + 1, raison);
return Err(raison) return Err(raison)
} }
} }
} }
Ok(()) Ok(liste_commande)
} }
fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurPendragon> { fn compile_phrase(&self, phrase: &str) -> Result<Commande, 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() {
return Err(ErreurPendragon::PhraseVide)
}
if parties.len() == 1 {
return Err(ErreurPendragon::ManqueArgument)
}
match parties[0] { match parties[0] {
"Définis" => { "Définis" => {
self.definie(parties[1])?; self.definis(parties[1])
} },
"Modifie" => { "Modifie" => {
self.modifie(parties[1])?; self.modifie(parties[1])
}, },
"Affiche" => { "Affiche" => {
self.affiche(parties[1])?; self.affiche(parties[1])
}, },
"Demande" => { "Demande" => {
self.demande(parties[1])?; self.demande(parties[1])
} }
autre_commande => { autre_commande => {
return Err(ErreurPendragon::CommandeInconnue(autre_commande.to_string())) return Err(ErreurPendragon::CommandeInconnue(autre_commande.to_string()))
} }
}; }
Ok(())
} }
fn affiche(&self, arguments: &str) -> Result<(), ErreurPendragon> { fn affiche(&self, arguments: &str) -> Result<Commande, ErreurPendragon> {
println!("{}", self.texte(arguments)?); println!("{}", self.texte(arguments)?);
Ok(())
let commande = Affiche(Expression::avec_arguments(TypeElement::Texte, arguments)?)
Ok(commande)
} }
fn definie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> { fn definis(&mut self, arguments: &str) -> Result<Commande, 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);
@ -97,10 +91,12 @@ impl Pendragon {
}; };
self.variables.insert(variable_nom, contenu); self.variables.insert(variable_nom, contenu);
Ok(())
let commande = Definis(variable_nom.into(), contenu.type_element());
Ok(commande)
} }
fn modifie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> { fn modifie(&mut self, arguments: &str) -> Result<Commande, 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)?;
@ -111,10 +107,11 @@ impl Pendragon {
}; };
self.variables.insert(variable_nom, valeur); self.variables.insert(variable_nom, valeur);
Ok(()) let commande = Modifie(variable_nom, Expression::avec_arguments(variable.type_element(), arguments)?),
Ok(commande)
} }
fn demande(&mut self, arguments: &str) -> Result<(), ErreurPendragon> { fn demande(&mut self, arguments: &str) -> Result<Commande, 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)?;
@ -134,7 +131,8 @@ impl Pendragon {
}; };
self.variables.insert(variable_nom, valeur); self.variables.insert(variable_nom, valeur);
Ok(()) let commande = Demande(variable_nom.into());
Ok(commande)
} }
fn recupere_variable(&self, nom: &str) -> Result<Element, ErreurPendragon> { fn recupere_variable(&self, nom: &str) -> Result<Element, ErreurPendragon> {

10
src/pendragon/structure.rs
View file

@ -20,6 +20,16 @@ impl Expression {
contenu: vec![] contenu: vec![]
} }
} }
fn avec_arguments(type_expression: TypeElement, arguments: &str) -> Result<Self, ErreurPendragon> {
let expression = Self {
type_expression,
contenu: vec![]
}
Ok(expression)
}
fn ajoute(&mut self, element: Element) -> Result<(), ErreurPendragon> { 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 {

262
src/pendragon/tests.rs
View file

@ -33,59 +33,59 @@ fn teste_somme() {
} }
} }
#[test] //#[test]
fn teste_definition_variable() { //fn teste_definition_variable() {
let mut sophie = Pendragon::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(_) => {
assert_eq!(sophie.variables["Element"], Element::Entier(0), "Element mal définie"); // assert_eq!(sophie.variables["Element"], Element::Entier(0), "Element mal définie");
} // }
Err(raison) => { // Err(raison) => {
panic!("Définition de variable échouée : {}", raison); // panic!("Définition de variable échouée : {}", raison);
} // }
} // }
} //}
//
#[test] //#[test]
fn teste_modification_variable() { //fn teste_modification_variable() {
let mut sophie = Pendragon::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 a = 2345678; // let a = 2345678;
let resultat = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a))); // let resultat = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a)));
match resultat { // match resultat {
Ok(_) => { // Ok(_) => {
assert_eq!(sophie.variables["Element"], Element::Entier(a), "Element mal modifiée"); // assert_eq!(sophie.variables["Element"], Element::Entier(a), "Element mal modifiée");
} // }
Err(raison) => { // Err(raison) => {
panic!("Modification de variable échouée : {}", raison); // panic!("Modification de variable échouée : {}", raison);
} // }
} // }
} //}
//
#[test] //#[test]
fn teste_operation_variable() { //fn teste_operation_variable() {
let mut sophie = Pendragon::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 a = 2345678; // let a = 2345678;
if let Err(raison) = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a))) { // if let Err(raison) = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a))) {
panic!("Modification de variable échouée : {}", raison); // panic!("Modification de variable échouée : {}", raison);
} // }
let b = 987654; // let b = 987654;
let resultat = sophie.operation(&format!("Element plus {}", nombre::nombre_comme_texte(b))); // let resultat = sophie.operation(&format!("Element plus {}", nombre::nombre_comme_texte(b)));
match resultat { // match resultat {
Ok(nombre) => { // Ok(nombre) => {
assert_eq!(nombre, a+b, "Echec de la somme d'un entier et d'une variable, attendais {}, a reçu {}", a+b, nombre); // assert_eq!(nombre, a+b, "Echec de la somme d'un entier et d'une variable, attendais {}, a reçu {}", a+b, nombre);
} // }
Err(raison) => { // Err(raison) => {
panic!("Opération de variable échouée : {}", raison); // panic!("Opération de variable échouée : {}", raison);
} // }
} // }
} //}
#[test] #[test]
fn teste_maths() { fn teste_maths() {
@ -111,84 +111,84 @@ fn teste_maths() {
} }
} }
#[test] //#[test]
fn teste_texte() { //fn teste_texte() {
let mut sophie = Pendragon::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);
} // }
let a = 2345678; // let a = 2345678;
if let Err(raison) = sophie.execute_phrase(&format!("Modifie A avec {} ", nombre::nombre_comme_texte(a))) { // if let Err(raison) = sophie.execute_phrase(&format!("Modifie A avec {} ", nombre::nombre_comme_texte(a))) {
panic!("Modification de variable échouée : {}", raison); // panic!("Modification de variable échouée : {}", raison);
} // }
if let Err(raison) = sophie.execute_phrase("Définis B comme texte") { // if let Err(raison) = sophie.execute_phrase("Définis B comme texte") {
panic!("Définition de variable échouée : {}", raison); // panic!("Définition de variable échouée : {}", raison);
} // }
if let Err(raison) = sophie.execute_phrase("Modifie B avec \"hello there\", \" general\", \" Kenobi\"") { // if let Err(raison) = sophie.execute_phrase("Modifie B avec \"hello there\", \" general\", \" Kenobi\"") {
panic!("Modification de variable échouée : {}", raison); // panic!("Modification de variable échouée : {}", raison);
} // }
let resultat = sophie.texte("\"Combo : \", B, \" / \", A plus ouvre la parenthèse un plus cinq ferme la parenthèse fois ouvre la parenthèse huit moins un ferme la parenthèse"); // let resultat = sophie.texte("\"Combo : \", B, \" / \", A plus ouvre la parenthèse un plus cinq ferme la parenthèse fois ouvre la parenthèse huit moins un ferme la parenthèse");
//
match resultat { // match resultat {
Ok(texte) => assert_eq!(texte, "Combo : hello there general Kenobi / deux-millions-trois-cent-quarante-cinq-mille-sept-cent-vingt", "Texte mal calculé"), // Ok(texte) => assert_eq!(texte, "Combo : hello there general Kenobi / deux-millions-trois-cent-quarante-cinq-mille-sept-cent-vingt", "Texte mal calculé"),
Err(raison) => panic!("Calcul de texte échoué : {}", raison), // Err(raison) => panic!("Calcul de texte échoué : {}", raison),
} // }
} //}
// --------------------------------------------- anti-test // --------------------------------------------- anti-test
#[test] //#[test]
fn teste_redefinition_variable() { //fn teste_redefinition_variable() {
let mut sophie = Pendragon::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 ErreurPendragon::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);
} // }
} //}
//
#[test] //#[test]
fn teste_echec_modification() { //fn teste_echec_modification() {
let mut sophie = Pendragon::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 ErreurPendragon::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);
} // }
} //}
//
#[test] //#[test]
fn teste_majuscule_variable() { //fn teste_majuscule_variable() {
let mut sophie = Pendragon::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 ErreurPendragon::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);
} // }
} //}
//
#[test] //#[test]
fn teste_point_phrase() { //fn teste_point_phrase() {
let mut sophie = Pendragon::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 ErreurPendragon::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);
}; // };
} //}