diff --git a/pendragon.project b/pendragon.project index 8d5f043..14db419 100644 --- a/pendragon.project +++ b/pendragon.project @@ -1 +1 @@ -{"categories":[{"name":"todo","content":[{"name":"erreur calcul bool/nombre","description":"affiche element precedent lorsque mauvais enchainement","id":1},{"name":"if","description":"implémente if avec des guillemets de délimitation","id":1},{"name":"scope variable","description":"// Hello there","id":6},{"name":"while","description":"implémente un while","id":2},{"name":"else","description":"// Hello there","id":7},{"name":"break","description":"// Hello there","id":8},{"name":"continue","description":"// Hello there","id":9},{"name":"compilation","description":"// Hello there","id":3},{"name":"puis à la ligne, alinéa","description":"// Hello there","id":1}]},{"name":"in progress","content":[]},{"name":"done","content":[{"name":"comparaison","description":"// Hello there","id":2},{"name":"booleen type","description":"// Hello there","id":4},{"name":"soixante-dix","description":"// Hello there","id":1},{"name":"parenthese comparaison","description":"// Hello there","id":1},{"name":"test comparaison","description":"// Hello there","id":4},{"name":"error ligne compilation","description":"// Hello there","id":2},{"name":"commentaires","description":"// Hello there","id":3},{"name":"compile time verification","description":"odre des termes rpn","id":1},{"name":"test multiple space in texte","description":"// Hello there","id":3},{"name":"test puis in texte","description":"// Hello there","id":2},{"name":"enchainement puis","description":"// Hello there","id":5},{"name":"guillemet mal ferme","description":"// Hello there","id":4},{"name":"display element","description":"for better print","id":6}]},{"name":"bug","content":[]},{"name":"to test","content":[{"name":"tests mod","description":"// Hello there","id":3},{"name":"test variable","description":"// Hello there","id":2}]},{"name":"bonus","content":[{"name":"stop cheating with \"-\"","description":"// Hello there","id":5},{"name":"affiche ligne et position erreur","description":"// Hello there","id":1},{"name":"pour numero de ligne execution","description":"sauvegarde numero de ligne dans la commande\n\ncommande.ligne(12)","id":3}]},{"name":"+","content":[]}]} \ No newline at end of file +{"categories":[{"name":"todo","content":[{"name":"if","description":"implémente if avec des guillemets de délimitation","id":1},{"name":"scope variable","description":"// Hello there","id":6},{"name":"while","description":"implémente un while","id":2},{"name":"else","description":"// Hello there","id":7},{"name":"break","description":"// Hello there","id":8},{"name":"continue","description":"// Hello there","id":9},{"name":"compilation","description":"// Hello there","id":3}]},{"name":"in progress","content":[]},{"name":"done","content":[{"name":"comparaison","description":"// Hello there","id":2},{"name":"booleen type","description":"// Hello there","id":4},{"name":"soixante-dix","description":"// Hello there","id":1},{"name":"parenthese comparaison","description":"// Hello there","id":1},{"name":"test comparaison","description":"// Hello there","id":4},{"name":"error ligne compilation","description":"// Hello there","id":2},{"name":"commentaires","description":"// Hello there","id":3},{"name":"compile time verification","description":"odre des termes rpn","id":1},{"name":"test multiple space in texte","description":"// Hello there","id":3},{"name":"test puis in texte","description":"// Hello there","id":2},{"name":"enchainement puis","description":"// Hello there","id":5},{"name":"guillemet mal ferme","description":"// Hello there","id":4},{"name":"display element","description":"for better print","id":6},{"name":"puis à la ligne, alinéa","description":"// Hello there","id":1},{"name":"teste double tiret","description":"// Hello there","id":2},{"name":"teste puis seul","description":"tout seul, seul devant, seul fin","id":3},{"name":"erreur calcul bool/nombre","description":"affiche element precedent lorsque mauvais enchainement","id":1}]},{"name":"bug","content":[]},{"name":"to test","content":[{"name":"tests mod","description":"// Hello there","id":3},{"name":"test variable","description":"// Hello there","id":2}]},{"name":"bonus","content":[{"name":"stop cheating with \"-\"","description":"// Hello there","id":5},{"name":"affiche ligne et position erreur","description":"// Hello there","id":1},{"name":"pour numero de ligne execution","description":"sauvegarde numero de ligne dans la commande\n\ncommande.ligne(12)","id":3},{"name":"standardizer erreur","description":"regarder les texte répétés","id":1}]},{"name":"+","content":[]}]} \ No newline at end of file diff --git a/src/pendragon/booleen.rs b/src/pendragon/booleen.rs index 5db8931..528c516 100644 --- a/src/pendragon/booleen.rs +++ b/src/pendragon/booleen.rs @@ -32,7 +32,7 @@ impl Pendragon { self.fin_comparaison("vrai", &mut pile_inconnu, &mut pile_operateurs, &mut expression, &mut possible_comparaison)?; expression.push(Element::Booleen(true)); if !precede_par_operation { - return Err(ErreurPendragon::CalculBooleen(format!("il manque un opérateur entre '{}' et 'vrai'", element_precedent))) + return Err(ErreurPendragon::OrdreCalculBooleen("opérateur".into(), element_precedent.into(), "vrai".into())) } precede_par_operation = false; continue; @@ -41,7 +41,7 @@ impl Pendragon { self.fin_comparaison("faux", &mut pile_inconnu, &mut pile_operateurs, &mut expression, &mut possible_comparaison)?; expression.push(Element::Booleen(false)); if !precede_par_operation { - return Err(ErreurPendragon::CalculBooleen(format!("il manque un opérateur entre '{}' et 'faux'", element_precedent))) + return Err(ErreurPendragon::OrdreCalculBooleen("opérateur".into(), element_precedent.into(), "faux".into())) } precede_par_operation = false; continue; @@ -50,7 +50,7 @@ impl Pendragon { self.fin_comparaison("non", &mut pile_inconnu, &mut pile_operateurs, &mut expression, &mut possible_comparaison)?; pile_operateurs.push(Operateur::Non); if !precede_par_operation { - return Err(ErreurPendragon::CalculBooleen(format!("il manque un opérateur entre '{}' et 'non'", element_precedent))) + return Err(ErreurPendragon::OrdreCalculBooleen("opérateur".into(), element_precedent.into(), "non".into())) } continue; } @@ -78,14 +78,14 @@ impl Pendragon { } "ouvre-la-parenthese" => { if !precede_par_operation && pile_inconnu.len() > 0 { - return Err(ErreurPendragon::CalculBooleen(format!("il manque un opérateur entre '{}' et l'ouverture de la parenthèse", element_precedent))) + return Err(ErreurPendragon::OrdreCalculBooleen("opérateur".into(), element_precedent.into(), "l'ouverture de la parenthèse".into())) } pile_inconnu.push("ouvre-la-parenthese".into()); continue; } "ferme-la-parenthese" => { if precede_par_operation { - return Err(ErreurPendragon::CalculBooleen(format!("il manque un booleen entre '{}' et la fermeture de la parenthèse", element_precedent))) + return Err(ErreurPendragon::OrdreCalculBooleen("booleen".into(), element_precedent.into(), "la fermeture de la parenthèse".into())) } let nombre_parenthese = compare_parentheses(&pile_inconnu); if nombre_parenthese.0 > nombre_parenthese.1 { @@ -111,7 +111,7 @@ impl Pendragon { } } else if let Ok(type_comparaison) = texte_comme_comparaison(autre) { if let Some(comparaison) = possible_comparaison { - return Err(ErreurPendragon::BooleenInvalide(format!("il manque un operateur booleen entre '{}' et '{}'", comparaison, type_comparaison))) + return Err(ErreurPendragon::ComparaisonInvalide(format!("il manque un operateur booleen entre les comparaisons '{}' et '{}'", comparaison, type_comparaison))) } let mut comparaison = Comparaison::nouvelle(); let nombre_parenthese = compare_parentheses(&pile_inconnu); @@ -131,7 +131,7 @@ impl Pendragon { } } if precede_par_operation { - return Err(ErreurPendragon::CalculBooleen(format!("il manque un booleen entre '{}' et '{}'", element_precedent, element))) + return Err(ErreurPendragon::OrdreCalculBooleen("booleen".into(), element_precedent.into(), element.into())) } precede_par_operation = true; } @@ -457,7 +457,7 @@ mod test { let Err(raison) = pendragon.elements_booleen(texte) else { panic!("Devrait détecter une erreur pour '{}'", texte); }; - let ErreurPendragon::CalculBooleen(_) = raison else { + let ErreurPendragon::OrdreCalculBooleen(_,_,_) = raison else { panic!("Devrait détecter une erreur de calcul booléen pour '{}', a déclenché : {}", texte, raison); }; } diff --git a/src/pendragon/debug.rs b/src/pendragon/debug.rs index 2b3c30d..5ac9f21 100644 --- a/src/pendragon/debug.rs +++ b/src/pendragon/debug.rs @@ -13,6 +13,9 @@ impl ErreurCompilation { erreur, } } + pub fn raison(&self) -> ErreurPendragon { + self.erreur.clone() + } } @@ -22,20 +25,28 @@ impl fmt::Display for ErreurCompilation { } } +#[derive(PartialEq, Debug, Clone)] pub enum ErreurPendragon { CommandeInconnue(String), ManqueArgument, - NombreInvalide(String), - BooleenInvalide(String), - TexteInvalide(String), - ComparaisonInvalide(String), MauvaisArgument(String), + ManquePonctuation, + + NombreInvalide(String), + CalculEntier(String), + OrdreCalculEntier(String, String, String), + + TexteInvalide(String), + + BooleenInvalide(String), + ComparaisonInvalide(String), + CalculBooleen(String), + OrdreCalculBooleen(String, String, String), + VariableInconnue(String), MauvaisType(String, String, String), - ManquePonctuation, + Lecture(String), - CalculBooleen(String), - CalculEntier(String), } impl fmt::Display for ErreurPendragon { @@ -43,17 +54,24 @@ impl fmt::Display for ErreurPendragon { match self { Self::CommandeInconnue(commande) => write!(f, "La commande \"{}\" est inconnue.", commande), Self::ManqueArgument => write!(f, "Il manque un argument."), - Self::NombreInvalide(nombre) => write!(f, "Le nombre \"{}\" est mal orthographié.", nombre), - Self::TexteInvalide(raison) => write!(f, "Le texte est invalide, {}.", raison), - Self::BooleenInvalide(booleen) => write!(f, "Le booleen \"{}\" est invalide.", booleen), - Self::ComparaisonInvalide(raison) => write!(f, "La comparaison est invalide, {}.", raison), Self::MauvaisArgument(message) => write!(f, "La commande a reçu un mauvais argument, {}.", message), + Self::ManquePonctuation => write!(f, "Il manque la ponctuation de la phrase."), + + Self::NombreInvalide(nombre) => write!(f, "Le nombre \"{}\" est mal orthographié.", nombre), + Self::CalculEntier(raison) => write!(f, "Calcul entier échoué, {}.", raison), + Self::OrdreCalculEntier(manque, precedent, suivant) => write!(f, "Calcul entier échoué, il manque un {} entre '{}' et '{}'.", manque, precedent, suivant), + + Self::TexteInvalide(raison) => write!(f, "Le texte est invalide, {}.", raison), + + Self::BooleenInvalide(booleen) => write!(f, "Le booleen \"{}\" est invalide.", booleen), + Self::CalculBooleen(raison) => write!(f, "Calcul booleen échoué, {}.", raison), + Self::ComparaisonInvalide(raison) => write!(f, "La comparaison est invalide, {}.", raison), + Self::OrdreCalculBooleen(manque, precedent, suivant) => write!(f, "Calcul boolen échoué, il manque un {} entre '{}' et '{}'.", manque, precedent, suivant), + Self::VariableInconnue(nom) => write!(f, "La variable \"{}\" est inconnue.", nom), Self::MauvaisType(nom, type_variable, type_attendu) => write!(f, "La {} est du mauvais type ({}), attendais {}.", nom, type_variable, type_attendu), - Self::ManquePonctuation => write!(f, "Il manque la ponctuation de la phrase."), + Self::Lecture(raison) => write!(f, "Lecture d'entrées utilisateur impossible : {}.", raison), - Self::CalculBooleen(raison) => write!(f, "Calcul booleen échoué, {}.", raison), - Self::CalculEntier(raison) => write!(f, "Calcul entier échoué, {}.", raison), } } } diff --git a/src/pendragon/mod.rs b/src/pendragon/mod.rs index 5ad3750..7a05c99 100644 --- a/src/pendragon/mod.rs +++ b/src/pendragon/mod.rs @@ -32,7 +32,7 @@ impl Pendragon { } for phrase in phrases { if phrase.ends_with(".") { - if phrase.starts_with("Nota Bene :") { + if phrase.replace(" ", "").starts_with("NotaBene:") { continue } match self.compile_commande(&phrase[..phrase.len() - 1]) { @@ -131,12 +131,46 @@ mod test { #[test] fn commentaire_valide() { - panic!("todo"); + let mut pendragon = Pendragon::nouveau(); + let commentaires = [ + "Nota Bene : ceci est un commentaire.", + "NotaBene : ceci est un commentaire.", + "Nota Bene: ceci est un commentaire.", + "NotaBene: ceci est un commentaire.", + "Nota Bene :ceci est un commentaire.", + "NotaBene :ceci est un commentaire.", + "Nota Bene:ceci est un commentaire.", + "NotaBene:ceci est un commentaire." + ]; + for commentaire in commentaires { + match pendragon.compile(commentaire.into()) { + Ok(_) => assert_eq!(pendragon.programme.commandes.len(), 0, "Le commentaire '{}' ne devrait pas générer de commande", commentaire), + Err(raison) => panic!("Erreur de compilation du commentaire '{}' : {}", commentaire, raison) + } + } } #[test] fn commentaire_invalide() { - panic!("todo"); + let mut pendragon = Pendragon::nouveau(); + let commentaires = [ + "Nota Bene ceci n'est pas un commentaire.", + "Nota bene : ceci n'est pas un commentaire.", + "Nota ene: ceci n'est pas un commentaire.", + "notaBene: ceci n'est pas un commentaire.", + "NotBene :ceci n'est pas un commentaire.", + "NotaBenececi n'est pas un commentaire.", + "notabene:ceci n'est pas un commentaire.", + "NNotaBene:ceci n'est pas un commentaire." + ]; + for commentaire in commentaires { + let Err(erreur) = pendragon.compile(commentaire.into()) else { + panic!("Ne devrait pas pouvoir compiler un commentaire invalide '{}'", commentaire); + }; + let ErreurPendragon::CommandeInconnue(_) = erreur.raison() else { + panic!("Erreur inattendue de compilation du commentaire '{}' : {}", commentaire, erreur.raison()); + }; + } } #[test] diff --git a/src/pendragon/nombre.rs b/src/pendragon/nombre.rs index b61ff47..743dd9c 100644 --- a/src/pendragon/nombre.rs +++ b/src/pendragon/nombre.rs @@ -67,14 +67,14 @@ impl Pendragon { } "ouvre-la-parenthese" => { if !precede_par_operation { - return Err(ErreurPendragon::CalculEntier(format!("il manque un opérateur entre '{}' l'ouverture de parenthèse", element_precedent))) + return Err(ErreurPendragon::OrdreCalculEntier("opérateur".into(), element_precedent.into(), "l'ouverture de parenthèse".into())) } pile_operateurs.push(Operateur::ParentheseEntier); continue } "ferme-la-parenthese" => { if precede_par_operation { - return Err(ErreurPendragon::CalculEntier(format!("il manque un nombre entre '{}' et la fermeture de parenthèse", element_precedent))) + return Err(ErreurPendragon::OrdreCalculEntier("nombre".into(), element_precedent.into(), "la fermeture de parenthèse".into())) } while let Some(operateur) = pile_operateurs.pop() { if operateur == Operateur::ParentheseEntier { @@ -86,7 +86,7 @@ impl Pendragon { } autre => { if !precede_par_operation { - return Err(ErreurPendragon::CalculEntier(format!("il manque un opérateur entre '{}' et '{}'", element_precedent, autre))) + return Err(ErreurPendragon::OrdreCalculEntier("opérateur".into(), element_precedent.into(), autre.into())) } precede_par_operation = false; if format_de_variable(autre) { @@ -99,7 +99,7 @@ impl Pendragon { } } if precede_par_operation { - return Err(ErreurPendragon::CalculEntier(format!("il manque un nombre entre '{}' et '{}'", element_precedent, element))) + return Err(ErreurPendragon::OrdreCalculEntier("nombre".into(), element_precedent.into(), element.into())) } precede_par_operation = true; } @@ -222,8 +222,6 @@ fn petit_nombre_comme_texte(nombre: usize) -> String { let dizaine = (nombre % 100) / 10; let unité = nombre % 10; - let décalage_dizaine = if [1, 7, 9].contains(&dizaine) {1} else {0}; - let centaine_texte = if centaine > 1 { format!("{}{}cent", NOMS_UNITES[centaine], UNION) } else if centaine > 0 { @@ -232,28 +230,23 @@ fn petit_nombre_comme_texte(nombre: usize) -> String { "".to_string() }; - let dizaine_union = if centaine > 0 && dizaine > 0 { - UNION.to_string() - } else { - "".to_string() - }; - + let décalage_dizaine = if [1, 7, 9].contains(&dizaine) {1} else {0}; let dizaine_texte = NOMS_DIZAINES[dizaine - décalage_dizaine]; - let séparation = if unité == 1 && ![0, 1, 8, 9].contains(&dizaine) {UNION.to_string() + "et"} else {"".to_string()}; - - let unité_union = if (nombre - unité > 0 && unité > 0 && (nombre%100 > 16 || nombre%100 < 10)) || (unité == 0 && dizaine == 7) { - UNION.to_string() - } else { - "".to_string() - }; - let unité_texte = if [1, 7, 9].contains(&dizaine) { - unité_union + NOMS_UNITES_DIX[unité] - } else { - unité_union + NOMS_UNITES[unité] - }; + let unité_texte = if [1, 7, 9].contains(&dizaine) {NOMS_UNITES_DIX[unité]} else {NOMS_UNITES[unité]}; - format!("{}{}{}{}{}", centaine_texte, dizaine_union, dizaine_texte, séparation, unité_texte) + let mut texte_nombre = format!("{}{}{}{}{}{}", centaine_texte, UNION, dizaine_texte, séparation, UNION, unité_texte); + + while texte_nombre.contains("--") { + texte_nombre = texte_nombre.replace("--","-"); + } + if texte_nombre.starts_with("-") { + texte_nombre = texte_nombre[1..texte_nombre.len()].to_string(); + } + if texte_nombre.ends_with("-") { + texte_nombre = texte_nombre[0..texte_nombre.len()-1].to_string(); + } + texte_nombre } pub fn texte_comme_nombre(texte: &str) -> Result { @@ -378,10 +371,14 @@ fn texte_comme_petit_nombre(texte: &str) -> Result { mod test { use std::collections::HashMap; use super::*; + #[test] fn conversion_nombres_texte() { - for i in [0, 1, 42, 70, 123, 999, 1031, 1_001_091, 72_036_854_775_807usize].iter() { + for i in [0, 1, 42, 70, 123, 999, 1031, 1_001_091, 72_036_854_775_807usize, 2345678*987654].iter() { let texte = nombre_comme_texte(*i); // Convert number to text + if texte.contains("--") { + panic!("Il y a deux tirets pour {} : {}", i, texte); + } match texte_comme_nombre(&texte) { // Convert text back to number Ok(nombre) => { assert_eq!(Element::Entier(*i), nombre, "Nombre inexact : {}, texte : {}", i, texte); @@ -440,7 +437,7 @@ mod test { let Err(raison) = pendragon.elements_nombre(texte) else { panic!("Devrait détecter une erreur pour '{}'", texte); }; - let ErreurPendragon::CalculEntier(_) = raison else { + let ErreurPendragon::OrdreCalculEntier(_,_,_) = raison else { panic!("Devrait détecter une erreur de calcul entier pour '{}', a déclenché : {}", texte, raison); }; } diff --git a/src/pendragon/texte.rs b/src/pendragon/texte.rs index c31104b..b2d8e6a 100644 --- a/src/pendragon/texte.rs +++ b/src/pendragon/texte.rs @@ -37,47 +37,46 @@ impl Pendragon { pile_inconnu.push(element.into()); continue; } - self.puis(&mut expression, &mut pile_inconnu)?; + expression.extend(self.puis(&expression, &pile_inconnu)?); + pile_inconnu = Vec::new(); + expression.push(Element::Operateur(Operateur::Puis)); } - self.puis(&mut expression, &mut pile_inconnu)?; + expression.extend(self.puis(&expression, &pile_inconnu)?); + pile_inconnu = Vec::new(); + expression.push(Element::Operateur(Operateur::Puis)); Ok(expression) } - pub fn puis(&self, expression: &mut Vec, pile_inconnu: &mut Vec) -> Result<(), ErreurPendragon> { - if let Some(dernier_element) = expression.last() { - if let Element::Texte(_) = dernier_element.clone() { - if pile_inconnu.is_empty() { - expression.push(Element::Operateur(Operateur::Puis)); - return Ok(()); + pub fn puis(&self, expression: &Vec, pile_inconnu: &Vec) -> Result, ErreurPendragon> { + let Some(premier_element) = pile_inconnu.first() else { + if let Some(dernier_element) = expression.last() { + if let Element::Texte(_) = dernier_element.clone() { + return Ok(vec![]); } } - } - let Some(premier_element) = pile_inconnu.first() else { return Err(ErreurPendragon::TexteInvalide("il manque un élément avant le puis".into())) }; + let total_inconnu = pile_inconnu.join(" "); + if total_inconnu == "alinéa" { + return Ok(vec![Element::Texte("\t".into())]) + } + if total_inconnu == "retour à la ligne" { + return Ok(vec![Element::Texte("\n".into())]) + } if pile_inconnu.len() == 1 && format_de_variable(premier_element) { - expression.push(Element::Variable(premier_element.into(), self.programme.variable(premier_element)?)); - *pile_inconnu = Vec::new(); - expression.push(Element::Operateur(Operateur::Puis)); - return Ok(()); + return Ok(vec![Element::Variable(premier_element.into(), self.programme.variable(premier_element)?)]); } let Err(raison) = self.elements_nombre(premier_element) else { - expression.extend(self.elements_nombre(&pile_inconnu.join(" "))?); - *pile_inconnu = Vec::new(); - expression.push(Element::Operateur(Operateur::Puis)); - return Ok(()) + return self.elements_nombre(&total_inconnu) }; if let ErreurPendragon::CalculEntier(_) = raison { return Err(raison) } let Err(raison) = self.elements_booleen(premier_element) else { - expression.extend(self.elements_booleen(&pile_inconnu.join(" "))?); - *pile_inconnu = Vec::new(); - expression.push(Element::Operateur(Operateur::Puis)); - return Ok(()); + return self.elements_booleen(&total_inconnu) }; let ErreurPendragon::CalculBooleen(_) = raison else { - return Err(ErreurPendragon::MauvaisArgument(pile_inconnu.join(" ").to_string())); + return Err(ErreurPendragon::TexteInvalide(format!("'{}' ne peut pas être converti en texte", pile_inconnu.join(" ")))); }; Err(raison) } @@ -145,14 +144,14 @@ mod test { let a = 2345678; let b = 987654; - let possible_expression = pendragon.elements_texte(&format!("\"hello\" puis {} fois {} puis \"there\" puis vrai ou faux puis trois puis deux", + let possible_expression = pendragon.elements_texte(&format!("\"hello\" puis {} fois {} puis \"there\" puis vrai ou faux puis trois puis deux puis alinéa puis retour à la ligne", nombre::nombre_comme_texte(a), nombre::nombre_comme_texte(b))); match possible_expression { Ok(expression) => { match calcule_texte(expression, &HashMap::new()) { Ok(texte) => { - let vrai_texte = format!("hello{}therevraitroisdeux", nombre::nombre_comme_texte(a*b)); + let vrai_texte = format!("hello{}therevraitroisdeux\t\n", nombre::nombre_comme_texte(a*b)); assert_eq!(texte, vrai_texte, "Calcul d'expression (texte) donne un mauvais résultat : {}", texte); } Err(raison) => { @@ -169,7 +168,7 @@ mod test { #[test] fn conversion_texte() { let pendragon = Pendragon::nouveau(); - let texte = "\"hello aaaa puis AERTY et ou fois six\""; + let texte = "\"hello aaaa puis AERTY et ou fois six\""; match pendragon.elements_texte(texte) { Ok(expression) => { if expression.len() != 2 { @@ -189,6 +188,9 @@ mod test { let textes = vec![ "trois puis puis un", "\" test", + "puis", + "un puis", + "puis un", ]; for texte in textes { let Err(raison) = pendragon.elements_texte(texte) else { diff --git a/src/pendragon/vocabulaire.rs b/src/pendragon/vocabulaire.rs new file mode 100644 index 0000000..26e4b59 --- /dev/null +++ b/src/pendragon/vocabulaire.rs @@ -0,0 +1,54 @@ + + +pub enum MotCle { + Definis, + Modifie, + Affiche, + Demande, + Si, + Sinon, + NotaBene, + Plus, + Moins, + Fois, + Divise, + Et, + Ou, + Non, + OuvreParenthese, + FermeParenthese, + Puis, + Alinea, + RetourLigne, +} + +pub impl MotCle { + fn comme_texte(&self) -> String { + match Self { + Self::Definis, + Self::Modifie, + Self::Affiche, + Self::Demande, + Self::Si, + Self::Sinon, + Self::NotaBene, + Plus, + Moins, + Fois, + Divise, + Et, + Ou, + Non, + OuvreParenthese, + FermeParenthese, + Puis, + Alinea, + RetourLigne, + } + } + + fn depuis_texte(texte: &str) -> Self { + match texte { + + } + } \ No newline at end of file diff --git a/test.dr b/test.dr index 0cad3c0..0d24628 100644 --- a/test.dr +++ b/test.dr @@ -1,9 +1,9 @@ -Définis A comme entier. +Définis A comme entier. Définis F comme texte. Définis B comme entier. Définis C comme entier. Nota Bene : A est la variable pour un polynôme. -Modifie A avec dix-sept. +Modifie A avec dix-sept plus trois. Modifie C avec six-cent-soixante-douze. Modifie B avec trois fois A fois ouvre la parenthèse trois fois A plus C ferme la parenthèse. Nota Bene : 3*A*(3*A+C). @@ -16,4 +16,4 @@ Définis Bool comme booléen. Modifie Bool avec vrai. Affiche vrai et faux. -Affiche trois plus un. \ No newline at end of file +Affiche alinéa puis trois plus un puis retour à la ligne puis "test". \ No newline at end of file