Created a fully functionnal CLI based on Cythan and Cythan-compiler

Author: ccgauche

.gitignore

@@ -8,3 +8,8 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+
+# Added by cargo
+
+/target

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "cythan-cli"
+version = "0.1.0"
+authors = ["ccgauche <gaucheron.laurent@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = "*"
+cythan = {git = "https://github.com/Cypooos/Cythan-v3#cfd832b"}
+cythan-compiler = {git = "https://github.com/Cythan-Project/cythan-compiler#26d0194"}
+compression = "*"
+anyhow = "*"

README.md

@@ -1,2 +1,42 @@
 # cythan-cli
  A CLI that uses cythan-compiler and cythan to build, test and execute Cythan V3 Code
+
+## Usage
+
+### Compile
+This will compile the file `cythan.ct` to `compiled.cct`
+```
+ $ cythan-cli compile cythan.ct
+```
+
+You can define the output file:
+```
+ $ cythan-cli compile cythan.ct compiled-custom.cct
+```
+
+If you want raw (readable by human but way larger) compiled cythan use the `.rct` extension for your output path:
+```
+ $ cythan-cli compile cythan.ct compiled-custom.ct
+```
+
+The compiler can also compress `.rct` files.
+
+### Execute
+This will execute both raw compiled file (`.rct`) or compressed compiled ones (`.cct`):
+```
+ $ cythan-cli execute cythan.cct 100
+```
+In this case 100 iterations of Cythan are computed and drawn to the terminal.
+
+If you want the output be be written to a file: (You can use both `.rct` and `.cct`)
+```
+ $ cythan-cli execute cythan.cct 100 executed.rct
+```
+
+### Decompile
+This will convert `.cct` file into `.rct` ones.
+
+In this example `cythan.cct` will be decompiled to `decompiled.rct`
+```
+ $ cythan-cli decompile cythan.cct decompiled.rct
+```

src/compiler.rs

@@ -0,0 +1,6 @@
+pub fn compile(file: &str, out: &str) -> anyhow::Result<()> {
+    let vec = cythan_compiler::Context::new().compute(&cythan_compiler::generate_tokens(
+        &std::fs::read_to_string(file)?,
+    ));
+    super::cythanenc::write_file_and_compress(out, &vec)
+}

src/cythanenc.rs

@@ -0,0 +1,91 @@
+fn compress(v: &Vec<u32>) -> Vec<u8> {
+    v.iter()
+        .map(|x| x.to_be_bytes())
+        .fold(Vec::with_capacity(v.len() * 4), |mut a, b| {
+            a.extend(b.iter());
+            a
+        })
+}
+
+fn decompress(v: &Vec<u8>) -> Vec<u32> {
+    (0..(v.len() / 4))
+        .map(|i| {
+            let i = i * 4;
+            u32::from_be_bytes([v[i], v[i + 1], v[i + 2], v[i + 3]])
+        })
+        .collect()
+}
+
+#[test]
+fn check_encode_validity() {
+    let v: Vec<u32> = vec![
+        12, 58, 23, 0, 2, 14, 25, 78, 52, 63, 60456, 4894, 91509, 4509090, 848554965, 645569511,
+        489488, 845546154,
+    ];
+    let o1 = compress(&v);
+    let o2 = decompress(&o1);
+    assert_eq!(v, o2);
+}
+
+#[test]
+fn check_file_encode_decode() {
+    let v: Vec<u32> = (0..100_000).collect();
+
+    std::fs::write(
+        "raw.ctt",
+        v.iter()
+            .map(|x| x.to_string())
+            .collect::<Vec<String>>()
+            .join(" "),
+    );
+
+    write_file_and_compress("compressed.cct", &v);
+    let p = read_file_and_decompress("compressed.cct");
+    assert_eq!(v, p.unwrap());
+}
+
+use std::fs::File;
+use std::io::Read;
+use std::io::Write;
+
+use compression::prelude::*;
+
+pub fn read_file_and_decompress(filename: &str) -> anyhow::Result<Vec<u32>> {
+    if filename.ends_with(".cct") {
+        let mut f = File::open(&filename)?;
+        let mut buffer = Vec::new();
+        f.read_to_end(&mut buffer)?;
+        Ok(decompress(
+            &buffer
+                .into_iter()
+                .decode(&mut BZip2Decoder::new())
+                .collect::<Result<Vec<u8>, _>>()?,
+        ))
+    } else {
+        Ok(std::fs::read_to_string(filename)?
+            .split_whitespace()
+            .flat_map(|x| x.parse::<u32>())
+            .collect())
+    }
+}
+
+pub fn write_file_and_compress(filename: &str, data: &Vec<u32>) -> anyhow::Result<()> {
+    if filename.ends_with(".cct") {
+        let mut f = File::create(filename)?;
+        f.write_all(
+            &compress(data)
+                .into_iter()
+                .encode(&mut BZip2Encoder::new(9), Action::Finish)
+                .collect::<Result<Vec<u8>, _>>()?,
+        )?;
+        Ok(())
+    } else {
+        std::fs::write(
+            filename,
+            data.iter()
+                .map(|x| x.to_string())
+                .fold(String::new(), |a, b| a + &b),
+        )?;
+        Ok(())
+    }
+}

src/decompiler.rs

@@ -0,0 +1,12 @@
+pub fn decompile(file: &str, out: &str) -> anyhow::Result<()> {
+    let i = super::cythanenc::read_file_and_decompress(file)?;
+
+    std::fs::write(
+        out,
+        &i.iter()
+            .map(|x| x.to_string())
+            .collect::<Vec<String>>()
+            .join(" "),
+    )?;
+    Ok(())
+}

src/execute.rs

@@ -0,0 +1,22 @@
+use cythan::{BasicCythan, Cythan};
+
+pub fn execute(file: &str, iterations: usize, outfile: Option<String>) -> anyhow::Result<()> {
+    let mut vec = BasicCythan::new(
+        super::cythanenc::read_file_and_decompress(file)?
+            .into_iter()
+            .map(|x| x as usize)
+            .collect(),
+    );
+    for _ in 0..iterations {
+        vec.next();
+    }
+    if let Some(e) = outfile {
+        super::cythanenc::write_file_and_compress(
+            &e,
+            &vec.cases.into_iter().map(|x| x as u32).collect(),
+        )?;
+    } else {
+        println!("{:?}", vec.cases);
+    };
+    Ok(())
+}

src/main.rs

@@ -0,0 +1,109 @@
+mod compiler;
+mod cythanenc;
+mod decompiler;
+mod execute;
+
+use clap::*;
+
+fn main() {
+    let matches = App::new("My Super Program")
+        .version("1.0")
+        .author("Kevin K. <kbknapp@gmail.com>")
+        .about("Does awesome things")
+        .subcommand(SubCommand::with_name("compile")
+            .about("Compile a Cythan file | use .cct extension for Compressed Executable or .rct for raw format")
+            .version("1.0")
+            .author("Laurent Gaucheron <gaucheron.laurent@gmail.com>")
+            .arg(Arg::with_name("INPUT")
+                .required(true)
+                .help("Set input file"))
+            .arg(Arg::with_name("OUTPUT")
+                .help("Set output file")))
+        .subcommand(SubCommand::with_name("decompile")
+            .about("Decompile a Cythan file | This require a compressed cythan file in .cct to work")
+            .version("1.0")
+            .author("Laurent Gaucheron <gaucheron.laurent@gmail.com>")
+            .arg(Arg::with_name("INPUT")
+                .required(true)
+                .help("Set input file"))
+            .arg(Arg::with_name("OUTPUT")
+                .help("Set output file")))
+        .subcommand(SubCommand::with_name("execute")
+            .about("Execute compiled Cythan file | Support raw and compressed format (.rct and .cct)")
+            .version("1.0")
+            .author("Laurent Gaucheron <gaucheron.laurent@gmail.com>")
+            .arg(Arg::with_name("INPUT")
+                .required(true)
+                .help("Set input file"))
+            .arg(Arg::with_name("ITERATIONS")
+                .required(true)
+                .help("Number of iterations to compute"))
+            .arg(Arg::with_name("OUTPUT")
+                .help("Set output file if none will print to the console the result")))
+        .get_matches();
+    if let Some(matches) = matches.subcommand_matches("compile") {
+        let output = matches.value_of("OUTPUT").unwrap_or("compiled.cct");
+        let input = matches.value_of("INPUT").unwrap();
+        let instant = std::time::Instant::now();
+        compiler::compile(input, output).unwrap();
+        println!(
+            "Compiled `{}` to `{}` in {}",
+            input,
+            output,
+            ms_to_str(instant.elapsed().as_millis())
+        );
+    } else if let Some(matches) = matches.subcommand_matches("execute") {
+        let output = matches.value_of("OUTPUT");
+        let input = matches.value_of("INPUT").unwrap();
+        let iterations: usize = matches
+            .value_of("ITERATIONS")
+            .map(|x| x.parse().ok())
+            .flatten()
+            .expect("<ITERATIONS> must be a positive integer");
+
+        let instant = std::time::Instant::now();
+        execute::execute(input, iterations, output.map(|x| x.to_owned())).unwrap();
+        if let Some(e) = output {
+            println!(
+                "Executed `{}` and written the result to `{}` in {}",
+                input,
+                e,
+                ms_to_str(instant.elapsed().as_millis())
+            );
+        } else {
+            println!(
+                "Executed `{}` in {}",
+                input,
+                ms_to_str(instant.elapsed().as_millis())
+            );
+        }
+    } else if let Some(matches) = matches.subcommand_matches("decompile") {
+        let output = matches.value_of("OUTPUT").unwrap_or("decompiled.rct");
+        let input = matches.value_of("INPUT").unwrap();
+
+        let instant = std::time::Instant::now();
+        decompiler::decompile(input, output);
+        println!(
+            "Decompiled `{}` to `{}` in {}",
+            input,
+            output,
+            ms_to_str(instant.elapsed().as_millis())
+        );
+    } else {
+        println!("Invalid use: cythan-cli compile <FILE> [OUTPUT]")
+    }
+}
+
+fn ms_to_str(ms: u128) -> String {
+    if ms < 100 {
+        format!("{}ms", ms)
+    } else if ms < 60_000 {
+        format!("{}s", (ms / 100) as f32 / 10.0)
+    } else {
+        format!(
+            "{}m {}s",
+            (ms / 60_000) as f32,
+            ((ms % 60_000) / 100) as f32 / 10.0
+        )
+    }
+}