Merge pull request #2 from ic-it/dev

Ddystopia · web-flow · commit 4ac78d5f6628 · 2023-04-04T16:20:43.000+02:00
simple check, run
diff --git a/Cargo.toml b/Cargo.toml
@@ -7,4 +7,5 @@ edition = "2021"
 
 [dependencies]
 clap = { version = "4.2.1", features = ["derive"] }
-ram = { git = "https://github.com/AVO-cado-team/ramemu.git", tag = "0.1.2"}
+colored = "2.0.0"
+ramemu = { git = "https://github.com/AVO-cado-team/ramemu.git", tag = "0.1.3"}
diff --git a/src/cli.rs b/src/cli.rs
@@ -1,27 +1,18 @@
 use clap::{Parser, Subcommand, ValueHint};
 use std::path::PathBuf;
 
-#[derive(Parser, Debug)] // requires `derive` feature
-#[command(author, version, about, long_about = None)]
+#[derive(Parser, Debug)]
+#[command(author, about = "CLI for ramemu (Random Access Machine Emulator)", version, long_about = None)]
 pub struct Cli {
-    // Subcommand to check file
     #[clap(subcommand)]
-    subcommand: Subcommands,
+    pub subcommand: Subcommands,
 }
 
 #[derive(Subcommand, Debug)]
 pub enum Subcommands {
     Check {
         #[clap(value_hint(ValueHint::DirPath))]
         file: PathBuf,
-
-        #[clap(value_hint(ValueHint::DirPath), short, long)]
-        #[arg(value_parser = clap::value_parser!(PathBuf))]
-        input: Option<PathBuf>,
-
-        #[clap(value_hint(ValueHint::DirPath), short, long)]
-        #[arg(value_parser = clap::value_parser!(PathBuf))]
-        output: Option<PathBuf>,
     },
     Run {
         #[clap(value_hint(ValueHint::DirPath))]
@@ -35,16 +26,16 @@ pub enum Subcommands {
         #[arg(value_parser = clap::value_parser!(PathBuf))]
         output: Option<PathBuf>,
     },
-    Compile {
-        #[clap(value_hint(ValueHint::DirPath))]
-        file: PathBuf,
+    // Compile {
+    //     #[clap(value_hint(ValueHint::DirPath))]
+    //     file: PathBuf,
 
-        #[arg(default_value_t = false)]
-        #[clap(long)]
-        turing_machine: bool,
-    },
-    Debug {
-        #[clap(value_hint(ValueHint::DirPath))]
-        file: PathBuf,
-    },
+    //     #[arg(default_value_t = false)]
+    //     #[clap(long)]
+    //     turing_machine: bool,
+    // },
+    // Debug {
+    //     #[clap(value_hint(ValueHint::DirPath))]
+    //     file: PathBuf,
+    // },
 }
diff --git a/src/compile.rs b/src/compile.rs
diff --git a/src/create_program.rs b/src/create_program.rs
@@ -0,0 +1,37 @@
+use crate::display_error::display_parsing_error;
+use crate::errors::RamCliError;
+use colored::Colorize;
+use ramemu::parser;
+use ramemu::program::Program;
+use ramemu::stmt::Stmt;
+use std::path::PathBuf;
+
+pub fn create_program(source: &str, file_path: PathBuf) -> Result<Program, RamCliError> {
+    let stmts_result: Vec<_> = parser::parse(source).collect();
+    let errors: Vec<_> = stmts_result
+        .iter()
+        .filter_map(|stmt| stmt.as_ref().err().cloned())
+        .collect();
+    errors
+        .iter()
+        .try_for_each(|error| display_parsing_error(source, error))?;
+
+    if errors.is_empty() {
+        let stmts: Vec<Stmt> = stmts_result
+            .into_iter()
+            .filter_map(|stmt| stmt.ok())
+            .collect();
+        return Ok(Program::from(stmts));
+    }
+
+    Err(RamCliError::Parse(format!(
+        "Found {} {} in file: {}",
+        errors.len().to_string().bright_yellow().bold(),
+        if errors.len() == 1 { "error" } else { "errors" },
+        file_path
+            .to_str()
+            .expect("This should never happen")
+            .bright_yellow()
+            .bold()
+    )))
+}
diff --git a/src/display_error.rs b/src/display_error.rs
@@ -0,0 +1,117 @@
+use crate::errors::RamCliError;
+use colored::Colorize;
+use ramemu::errors::InterpretError;
+use ramemu::errors::InvalidArgument;
+use ramemu::errors::ParseError;
+
+fn get_line_from_source(source: &str, line_index: usize) -> Result<&str, RamCliError> {
+    source
+        .lines()
+        .nth(line_index - 1)
+        .ok_or_else(|| RamCliError::Other(format!("Could not find line {} in source", line_index)))
+}
+
+fn display_error_message(
+    source: &str,
+    line_index: usize,
+    message: &str,
+) -> Result<(), RamCliError> {
+    let line = get_line_from_source(source, line_index)?;
+    let (command, comment) = line.split_once('#').unwrap_or((line, ""));
+
+    let comment = if !comment.is_empty() {
+        format!("#{}", comment).as_str().truecolor(100, 100, 100)
+    } else {
+        "".normal()
+    };
+
+    println!("{}: {}", "Error".red().bold(), message);
+    println!(
+        "{}\t{} {}{}\n",
+        line_index.to_string().bright_blue().bold(),
+        '|'.to_string().bright_blue().bold(),
+        command,
+        comment
+    );
+    Ok(())
+}
+
+pub fn display_parsing_error(source: &str, error: &ParseError) -> Result<(), RamCliError> {
+    let (line_index, message) = match error {
+        ParseError::LabelIsNotValid(line_index) => (
+            *line_index,
+            format!(
+                "Label is not valid. Use only labels from {}:",
+                "[a-zA-Z0-9_]+".bright_blue().bold()
+            ),
+        ),
+        ParseError::UnsupportedSyntax(line_index) => (
+            *line_index,
+            "Unsupported syntax. Maybe you passed on an extra argument".to_string(),
+        ),
+        ParseError::UnsupportedOpcode(line_index, opcode) => (
+            *line_index,
+            format!(
+                "Unsupported opcode: {}",
+                opcode.to_string().bright_blue().bold()
+            ),
+        ),
+        ParseError::ArgumentIsRequired(line_index) => {
+            (*line_index, "Argument is required".to_string())
+        }
+        ParseError::ArgumentIsNotValid(line_index, argument) => (
+            *line_index,
+            format!(
+                "Argument is not valid: {}",
+                match argument {
+                    InvalidArgument::LabelIsNotValid => "Label is not valid",
+                    InvalidArgument::ArgumentIsRequired => "Argument is required",
+                    InvalidArgument::ArgumentValueMustBeNumberic =>
+                        "Argument value must be numeric",
+                    InvalidArgument::PureArgumentIsNotAllowed =>
+                        "Pure argument is not allowed in this context",
+                    InvalidArgument::ArgumentIsNotValid => "Argument is not valid",
+                }
+            ),
+        ),
+        ParseError::UnknownError(line_index) => (*line_index, "Unknown error".to_string()),
+    };
+
+    display_error_message(source, line_index, &message)?;
+    Ok(())
+}
+
+pub fn display_runtime_error(source: &str, error: &InterpretError) -> Result<(), RamCliError> {
+    let (line_index, message) = match error {
+        InterpretError::SegmentationFault(line_index) => (
+            *line_index,
+            "Segmentation fault. Look for possible reasons in the documentation".to_string(),
+        ),
+        InterpretError::UnknownLabel(line_index) => (
+            *line_index,
+            "Unknown label. Attempted to jump to unknown label".to_string(),
+        ),
+        InterpretError::InvalidInput(line_index, input) => {
+            (*line_index, format!("Invalid input: {}", input))
+        }
+        InterpretError::InvalidLiteral(line_index) => (
+            *line_index,
+            "Invalid literal. Attempted to use invalid literal value".to_string(),
+        ),
+        InterpretError::DivisionByZero(line_index) => (
+            *line_index,
+            "Division by zero. Are you trying to divide by zero?".to_string(),
+        ),
+        InterpretError::WriteError(line_index) => (
+            *line_index,
+            "Output stream error. Can I write in the specified output?".to_string(),
+        ),
+        InterpretError::Halted(line_index) => (
+            *line_index,
+            "Halted! You have reached the end of the program. Don't try to continue execution!"
+                .to_string(),
+        ),
+    };
+    display_error_message(source, line_index, &message)?;
+    Ok(())
+}
diff --git a/src/errors.rs b/src/errors.rs
@@ -0,0 +1,24 @@
+use colored::Colorize;
+use std::error::Error;
+
+#[derive(Debug, PartialEq, Eq, Clone, Hash, PartialOrd, Ord)]
+pub enum RamCliError {
+    Io(String),
+    Parse(String),
+    Runtime(String),
+    Other(String),
+}
+
+impl std::fmt::Display for RamCliError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let (kind, message) = match &self {
+            RamCliError::Io(message) => ("IO error", message),
+            RamCliError::Parse(message) => ("Parse error", message),
+            RamCliError::Runtime(message) => ("Runtime error", message),
+            RamCliError::Other(message) => ("Unknown error", message),
+        };
+        write!(f, "{}: {}", kind.red().bold(), message)
+    }
+}
+
+impl Error for RamCliError {}
diff --git a/src/io_manager.rs b/src/io_manager.rs
@@ -0,0 +1,85 @@
+use colored::Colorize;
+use std::fs::{canonicalize, read_to_string, File};
+use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Result as IoResult, Write};
+use std::path::PathBuf;
+
+use crate::errors::RamCliError;
+
+struct RamCliStdin;
+struct RamCliStdout;
+
+impl Read for RamCliStdin {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
+        print!("{}", ">>> ".cyan().bold());
+        stdout().flush().unwrap();
+        stdin().read(buf)
+    }
+}
+
+impl Write for RamCliStdout {
+    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
+        if buf == b"\n" || buf == b"\r" {
+            println!();
+            return Ok(buf.len());
+        }
+        print!("{} {}", "<<<".cyan().bold(), String::from_utf8_lossy(buf));
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> IoResult<()> {
+        stdout().flush()
+    }
+}
+
+fn ramcli_stdin() -> RamCliStdin {
+    RamCliStdin
+}
+
+fn ramcli_stdout() -> RamCliStdout {
+    RamCliStdout
+}
+
+pub fn read_source(file: PathBuf) -> Result<String, RamCliError> {
+    let file_path_str = if let Some(fps) = file.to_str() {
+        fps
+    } else {
+        return Err(RamCliError::Io(
+            "You specified a file with an invalid path".to_string(),
+        ));
+    };
+
+    let abs_path = canonicalize(&file)
+        .map_err(|_| RamCliError::Io(format!("File not found: {}", file_path_str)))?;
+
+    if !abs_path.is_file() {
+        return Err(RamCliError::Io(format!(
+            "You must specify a file, not a directory: {}",
+            file_path_str
+        )));
+    }
+
+    let source = read_to_string(abs_path)
+        .map_err(|_| RamCliError::Io(format!("Could not read file: {}", file_path_str)))?;
+
+    Ok(source)
+}
+
+pub fn create_input_buf(input: Option<PathBuf>) -> Result<Box<dyn BufRead>, RamCliError> {
+    if let Some(input) = input {
+        let input_file = File::open(input)
+            .map_err(|_| RamCliError::Io("Could not open input file".to_string()))?;
+        Ok(Box::new(BufReader::new(input_file)))
+    } else {
+        Ok(Box::new(BufReader::new(ramcli_stdin())))
+    }
+}
+
+pub fn create_output_buf(output: Option<PathBuf>) -> Result<Box<dyn std::io::Write>, RamCliError> {
+    if let Some(output) = output {
+        let output_file = File::create(output)
+            .map_err(|_| RamCliError::Io("Could not open output file".to_string()))?;
+        Ok(Box::new(BufWriter::new(output_file)))
+    } else {
+        Ok(Box::new(ramcli_stdout()))
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -0,0 +1,6 @@
+pub mod cli;
+pub mod create_program;
+pub mod display_error;
+pub mod errors;
+pub mod io_manager;
+pub mod run;
diff --git a/src/main.rs b/src/main.rs
@@ -1,7 +1,45 @@
-mod cli;
 use clap::Parser;
-use cli::Cli;
+use colored::Colorize;
+use ram_cli::cli::{Cli, Subcommands};
+use ram_cli::create_program::create_program;
+use ram_cli::io_manager::read_source;
+use ram_cli::run::run_source;
 
 fn main() {
     let args = Cli::parse();
+
+    match args.subcommand {
+        Subcommands::Check { file } => {
+            let source = match read_source(file.clone()) {
+                Ok(s) => s,
+                Err(e) => return println!("{}", e),
+            };
+
+            let Err(e) = create_program(&source, file) else {
+                return println!("{}: No errors found {}", "Syntax analysis".cyan().bold(), "✓".green().bold())
+            };
+            println!("{}", e);
+        }
+
+        Subcommands::Run {
+            file,
+            input,
+            output,
+        } => {
+            let source = match read_source(file.clone()) {
+                Ok(s) => s,
+                Err(e) => return println!("{}", e),
+            };
+
+            let program = match create_program(&source, file) {
+                Ok(program) => program,
+                Err(e) => return println!("{}", e),
+            };
+
+            let Err(e) = run_source(&source, program, input, output) else {
+                return println!("{}: Program finished with no errors {}", "Runtime".cyan().bold(), "✓".green().bold())
+            };
+            println!("{}", e);
+        }
+    }
 }
diff --git a/src/run.rs b/src/run.rs
diff --git a/tests/isprime.ramemu b/tests/isprime.ramemu
