147 lines
3.7 KiB
Rust
147 lines
3.7 KiB
Rust
mod buffer;
|
|
mod enums;
|
|
pub use self::buffer::Buffer;
|
|
pub use self::enums::{Address, Command, parse_address, parse_command};
|
|
|
|
use std::env;
|
|
use std::fs::File;
|
|
use std::io::BufReader;
|
|
use std::io::prelude::*;
|
|
use std::io;
|
|
use nom::bytes::complete::{tag, take_while, take_till};
|
|
use nom::character::complete::one_of;
|
|
use nom::sequence::Tuple;
|
|
use nom::branch::alt;
|
|
use nom::error::ErrorKind;
|
|
use nom::Err::Error;
|
|
|
|
const FILE : &'static str = "test";
|
|
|
|
/*
|
|
* .
|
|
* $
|
|
* [:digit:]
|
|
* '[:alpha:]
|
|
* /BRE/
|
|
* +[:digit:]
|
|
* -[:digit:]
|
|
* [:digit:],[:digit:]
|
|
* [:digit:];[:digit:]
|
|
*/
|
|
|
|
// TODO juste $ pour l'instant dans l'adresse
|
|
// TODO faire les commandes mais juste p pour l'instant
|
|
// TODO faire un système de retour d'erreur pour afficher ? et l'erreur si l'utilisateur le demande
|
|
// (cad les fonctions pour parser retournent un Err et on peut parser ce Err pour voir le type de
|
|
// l'erreur, idem pour les fonctions d'exécutiosn ?)
|
|
|
|
/*
|
|
fn read_address(input: &str) -> Result<&str, Address> {
|
|
|
|
}
|
|
*/
|
|
|
|
/*
|
|
* Le char doit être une commande valide.
|
|
*/
|
|
|
|
|
|
/*
|
|
fn parse_multi_addr(addr: &str) -> Address {
|
|
//let extract = take_till::<&str, &str, Error>(|c| c == ',');
|
|
let extract = take_till::<&str, &str, Error<&str>>(|c| c != ",");
|
|
if let Ok((still, before)) = extract(addr) {
|
|
if let Ok((still, after)) = extract(addr) {
|
|
}
|
|
}
|
|
|
|
Address::Null
|
|
}
|
|
*/
|
|
|
|
fn check_address(c: char) -> bool {
|
|
c.is_digit(10) || c == '$' || c == ' ' || c == '.'
|
|
}
|
|
|
|
fn check_address_complete(c: char) -> bool {
|
|
check_address(c) || c == ','
|
|
}
|
|
|
|
fn print(buffer: &Buffer, addr: Address, print_numbers: bool) {
|
|
match addr {
|
|
Address::Actual => buffer.print_line(buffer.act(), print_numbers),
|
|
Address::Null => println!("nul !"),
|
|
_ => println!("coucou2"),
|
|
}
|
|
}
|
|
|
|
fn execute_command(buffer: &mut Buffer, c: Command) -> bool {
|
|
println!("coucou {:?}", c);
|
|
let mut ret = false;
|
|
|
|
match c {
|
|
Command::Print(a) => print(buffer, a, false),
|
|
Command::Number(a) => print(buffer, a, true),
|
|
Command::Quit(_) => ret = true,
|
|
_ => println!("coucou"),
|
|
}
|
|
|
|
ret
|
|
}
|
|
|
|
fn parse_line(input: &str) -> Result<Command, String> {
|
|
let address = take_while(check_address_complete);
|
|
let command = one_of::<_, _, (&str, ErrorKind)>("pnqQ");
|
|
|
|
//if let Ok((input, (a, c))) = alt(address, command).parse(input) {
|
|
let tmp = (address, command).parse(input);
|
|
if let Ok((input, (a, c))) = tmp {
|
|
println!("Ok");
|
|
//println!("{:?} - {:?} - {:?}", input, a, c);
|
|
let addr = parse_address(a);
|
|
Ok(parse_command(c, addr))
|
|
} else if let Err(Error(("bc", ErrorKind::OneOf))) = tmp {
|
|
//println!("{:?}", e);
|
|
println!("?");
|
|
Err(String::from("bruh moment"))
|
|
} else if let Err(Error((_, t))) = tmp {
|
|
println!("?");
|
|
Err(String::from("bruh moment"))
|
|
} else {
|
|
println!("bruh");
|
|
Err(String::from("bruh moment"))
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let buffer : Vec<Result<String, io::Error>> = if let Ok(f) = File::open(FILE) {
|
|
let buff = BufReader::new(f);
|
|
buff.lines().collect()
|
|
} else {
|
|
panic!("Le fichier n'existe pas.");
|
|
};
|
|
|
|
let mut buffer_struct = Buffer::new(buffer);
|
|
|
|
println!("fichier lu !");
|
|
let mut quit = false;
|
|
|
|
while !quit {
|
|
let mut input = String::new();
|
|
match io::stdin().read_line(&mut input) {
|
|
Ok(n) => {
|
|
if let Ok(c) = parse_line(&input) {
|
|
let tmp = execute_command(&mut buffer_struct, c);
|
|
if tmp {
|
|
quit = true;
|
|
}
|
|
} else {
|
|
println!("coucou");
|
|
}
|
|
},
|
|
Err(e) => println!("error"),
|
|
}
|
|
}
|
|
|
|
}
|