path: root/src/main.rs

use crossterm::{cursor, execute, terminal};
use eyre::{Result, bail};
use regex::Regex;
use rustyline::DefaultEditor;
use rustyline::error::ReadlineError;
use std::collections::{LinkedList, VecDeque};
use std::io;
use std::io::Write;
use std::path::{Component, Path, PathBuf};
use std::sync::mpsc::{Receiver, SyncSender, sync_channel};
use std::thread::spawn;

const STDOUT_BUFFER_SIZE: usize = 1024;
const STDERR_BUFFER_SIZE: usize = 1024;

fn main() -> Result<()> {
    color_eyre::install()?;

    let mut line_editor = DefaultEditor::new()?;
    let mut prompt_spec = "$p$g";

    loop {
        let cwd = std::env::current_dir()?;
        let full_cwd = format_path(&cwd);
        let mut interpolated_prompt = prompt_spec.replace("$p", &full_cwd).replace("$g", ">");
        interpolated_prompt.push_str(" ");

        let line = match line_editor.readline(&interpolated_prompt) {
            Ok(line) => line,
            Err(ReadlineError::Eof) => break,
            Err(err) => return Err(err.into()),
        };

        let Ok(command) = Command::parse(&line) else {
            eprintln!("unrecognized command: {}", line);
            continue;
        };

        line_editor.add_history_entry(&line)?;
        let Ok(CommandReceivers {
            stdout,
            stderr,
            exit_status,
        }) = command.run()
        else {
            eprintln!("unimplemented command: {}", line);
            continue;
        };

        // print stdout, stderr interleaved until exit_status produces something
        let stdout_writer = spawn(move || {
            loop {
                let Ok(bytes) = stdout.recv() else {
                    break;
                };
                let mut out = io::stderr();
                out.write_all(bytes.as_slice())
                    .expect("stdout write failed");
                out.flush().expect("stdout flush failed");
            }
        });

        let stderr_writer = spawn(move || {
            loop {
                let Ok(bytes) = stderr.recv() else {
                    break;
                };
                let mut out = io::stderr();
                out.write_all(bytes.as_slice())
                    .expect("stderr write failed");
                out.flush().expect("stdout flush failed");
            }
        });

        stdout_writer.join().expect("stdout writer thread failed");
        stderr_writer.join().expect("stderr writer thread failed");

        let _exit_status = exit_status
            .recv()
            .expect("failed to receive exit status from command");
    }

    Ok(())
}

/// Turns "/home/mulk/foo/longfilenames/excellent.text" into "C:\\HOME\\MULK\\FOO\\LONGFILE~1\\EXCELL~1.TEX"
fn format_path(p: &Path) -> String {
    use std::path::Component::*;

    let mut prefix: Option<String> = None;
    let mut components = Vec::new();

    for component in p.components() {
        match component {
            Normal(c) => {
                let s = c.to_string_lossy().to_uppercase();
                let s_parts: Vec<&str> = s.splitn(2, '.').collect();

                let mut name: String;
                let mut ext: Option<String>;
                if s_parts.len() == 1 {
                    name = s.clone();
                    ext = None;
                } else {
                    name = s_parts[0].into();
                    ext = Some(s_parts[1].into());
                }

                let mut result = String::new();

                if name.len() > 8 || ext.as_ref().map_or(false, |e| e.len() > 3) {
                    name = name.chars().take(6).collect::<String>();
                    name.push_str("~1");
                }
                result.push_str(&name.to_uppercase());

                if let Some(mut e) = ext {
                    if e.len() > 3 {
                        e = e.chars().take(3).collect::<String>();
                    }
                    result.push_str(".");
                    result.push_str(&e.to_uppercase());
                }

                components.push(result);
            }

            Prefix(c) => prefix = Some(component.as_os_str().to_string_lossy().to_uppercase()),

            RootDir => {
                if prefix.is_none() {
                    prefix = Some("C:".into())
                }
                components.push("".into());
            }

            CurDir => components.push(".".into()),

            ParentDir => components.push("..".into()),
        }
    }

    let mut result = String::new();
    if let Some(p) = prefix {
        result.push_str(&p)
    };
    result.push_str(&components.join("\\"));
    result
}

#[derive(Debug)]
enum FileSpec {
    Con,
    Lpt1,
    Lpt2,
    Lpt3,
    Prn,
    Path(PathBuf),
}

#[derive(Debug)]
enum Command {
    Pipe {
        left: Box<Command>,
        right: Box<Command>,
    },
    Redirect {
        command: Box<Command>,
        target: FileSpec,
    },
    External {
        program: String,
        args: Vec<String>,
    },
    Builtin(BuiltinCommand),
    Empty,
}

struct CommandReceivers {
    stdout: Receiver<Vec<u8>>,
    stderr: Receiver<Vec<u8>>,
    exit_status: Receiver<u16>,
}

struct CommandSenders {
    stdout: SyncSender<Vec<u8>>,
    stderr: SyncSender<Vec<u8>>,
    exit_status: SyncSender<u16>,
}

struct CommandContext {
    senders: CommandSenders,
    receivers: CommandReceivers,
}

impl CommandContext {
    fn new() -> Self {
        let (sout, rout) = sync_channel(STDOUT_BUFFER_SIZE);
        let (serr, rerr) = sync_channel(STDERR_BUFFER_SIZE);
        let (sexit, rexit) = sync_channel(1);

        Self {
            senders: CommandSenders {
                stdout: sout,
                stderr: serr,
                exit_status: sexit,
            },
            receivers: CommandReceivers {
                stdout: rout,
                stderr: rerr,
                exit_status: rexit,
            },
        }
    }

    fn split(self) -> (CommandSenders, CommandReceivers) {
        (self.senders, self.receivers)
    }
}

impl Command {
    pub(crate) fn run(&self) -> Result<CommandReceivers> {
        use crate::BuiltinCommand::*;
        use crate::Command::*;

        let (senders, receivers) = CommandContext::new().split();
        let CommandSenders {
            stdout,
            stderr,
            exit_status,
        } = senders;

        match self {
            Empty => {
                exit_status.send(0)?;
            }

            Builtin(EchoText { message }) => {
                stdout.send(message.bytes().collect())?;
                stdout.send(b"\n".into())?;
                exit_status.send(0)?;
            }

            Builtin(Cls) => {
                let mut stdout_handle = io::stdout();
                execute!(stdout_handle, terminal::Clear(terminal::ClearType::All))?;
                execute!(stdout_handle, cursor::MoveTo(0, 0))?;
                exit_status.send(0)?;
            }

            _ => bail!("Command::run not implemented for {:?}", self),
        }

        Ok(receivers)
    }
}

#[derive(Debug)]
enum BuiltinCommand {
    // File-oriented
    Copy {
        from: FileSpec,
        to: FileSpec,
    },
    Deltree {
        path: PathBuf,
    },
    Dir {
        path: PathBuf,
    },
    Fc,
    Find,
    Mkdir {
        path: PathBuf,
    },
    Move,
    Remove {
        path: PathBuf,
    },
    Rename {
        from: FileSpec,
        to: FileSpec,
    },
    Replace,
    Rmdir {
        path: PathBuf,
    },
    Sort,
    Tree {
        path: PathBuf,
    },
    Type {
        file: FileSpec,
    },
    Xcopy {
        from: FileSpec,
        to: FileSpec,
        recursive: bool,
    },

    // Shell-oriented
    Append,
    Chdir {
        path: PathBuf,
    },
    EchoOff,
    EchoOn,
    EchoPlain,
    EchoText {
        message: String,
    },
    Exit,
    PathGet,
    PathSet {
        value: String,
    },
    PromptGet,
    PromptSet {
        message: String,
    },
    Set {
        name: String,
        value: String,
    },
    Setver,
    Ver,

    // Utilities
    Date,
    Time,

    // Screen-oriented
    Cls,
    More,

    // Dummies
    Verify,
    Fastopen,
    Smartdrv,
    Sizer,

    // For later
    Assign,
    Attrib,
    Chkdsk,
    Doskey,
    Dosshell,
    Edit,
    Fasthelp,
    Help,
    Join,
    Mem,
    Power,
    Subst,
    Truename,

    // For much later, if ever
    Break,
    Chcp,
    Ctty,
    Defrag,
    Diskcopy,
    Emm386,
    Fdisk,
    Format,
    Interlnk,
    Keyb,
    Label,
    Mode,
    Msav,
    Msbackup,
    Mscdex,
    Msd,
    Print,
    Qbasic,
    Restore,
    Scandisk,
    Share,
    Sys,
    Undelete,
    Unformat,
    Vol,
    Vsafe,

    // Scripting
    Call,
    Choice,
    Echo,
    For,
    Goto,
    If,
    Pause,
    Prompt,
    Rem {
        message: String,
    },
    Shift,
}

impl Command {
    fn parse(input: &str) -> Result<Command> {
        use BuiltinCommand::*;
        use Command::*;

        let whitespace = Regex::new(r"\s+")?;
        let mut split_input = whitespace.splitn(input, 2);
        let Some(name) = split_input.next() else {
            return Ok(Empty);
        };
        let args = split_input.next().unwrap_or("");

        match name.to_uppercase().as_str() {
            "" => Ok(Empty),

            "ECHO" => Ok(Builtin(match args.to_uppercase().as_str() {
                "ON" => EchoOn,
                "OFF" => EchoOff,
                "" => EchoPlain,
                _ => EchoText {
                    message: args.to_string(),
                },
            })),

            "CLS" => Ok(Builtin(Cls)),

            _ => Err(eyre::eyre!("parse not implemented for {:?}", input)),
        }
    }
}