Remove the Rust version.

1 files changed, 0 insertions, 844 deletions

diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 8b9229e..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,844 +0,0 @@
-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,
-            status,
-        }) = command.run()
-        else {
-            eprintln!("unimplemented command: {}", line);
-            continue;
-        };
-
-        // print stdout, stderr interleaved until 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 command_result = status
-            .recv()
-            .expect("failed to receive exit status from command");
-
-        match command_result {
-            CommandStatus::ExitShell => break,
-            CommandStatus::Code(_) => {}
-        }
-    }
-
-    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 RedirectType {
-    OutputOverwrite,  // >
-    OutputAppend,     // >>
-    InputFrom,        // <
-}
-
-#[derive(Debug)]
-struct Redirect {
-    redirect_type: RedirectType,
-    target: FileSpec,
-}
-
-#[derive(Debug)]
-enum Command {
-    Pipe {
-        left: Box<Command>,
-        right: Box<Command>,
-    },
-    Redirect {
-        command: Box<Command>,
-        redirects: Vec<Redirect>,
-    },
-    External {
-        program: String,
-        args: Vec<String>,
-    },
-    Builtin(BuiltinCommand),
-    Empty,
-}
-
-#[derive(Debug)]
-enum CommandStatus {
-    Code(u16),
-    ExitShell,
-}
-
-struct CommandReceivers {
-    stdout: Receiver<Vec<u8>>,
-    stderr: Receiver<Vec<u8>>,
-    status: Receiver<CommandStatus>,
-}
-
-struct CommandSenders {
-    stdout: SyncSender<Vec<u8>>,
-    stderr: SyncSender<Vec<u8>>,
-    status: SyncSender<CommandStatus>,
-}
-
-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,
-                status: sexit,
-            },
-            receivers: CommandReceivers {
-                stdout: rout,
-                stderr: rerr,
-                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::*;
-        use crate::CommandStatus::*;
-
-        let (senders, receivers) = CommandContext::new().split();
-        let CommandSenders {
-            stdout,
-            stderr,
-            status: status,
-        } = senders;
-
-        match self {
-            Empty => {
-                status.send(Code(0))?;
-            }
-
-            Builtin(EchoText { message }) => {
-                stdout.send(message.bytes().collect())?;
-                stdout.send(b"\n".into())?;
-                status.send(Code(0))?;
-            }
-
-            Builtin(Cls) => {
-                let mut stdout_handle = io::stdout();
-                execute!(stdout_handle, terminal::Clear(terminal::ClearType::All))?;
-                execute!(stdout_handle, cursor::MoveTo(0, 0))?;
-                status.send(Code(0))?;
-            }
-
-            Builtin(Exit) => {
-                status.send(ExitShell)?;
-            }
-
-            _ => 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,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-enum Token {
-    Word(String),
-    Pipe,
-    RedirectOut,        // >
-    RedirectAppend,     // >>
-    RedirectIn,         // <
-    Newline,
-    Eof,
-}
-
-struct Lexer {
-    input: Vec<char>,
-    position: usize,
-    current_char: Option<char>,
-}
-
-impl Lexer {
-    fn new(input: &str) -> Self {
-        let chars: Vec<char> = input.chars().collect();
-        let current_char = chars.get(0).copied();
-
-        Self {
-            input: chars,
-            position: 0,
-            current_char,
-        }
-    }
-
-    fn advance(&mut self) {
-        self.position += 1;
-        self.current_char = self.input.get(self.position).copied();
-    }
-
-    fn peek(&self) -> Option<char> {
-        self.input.get(self.position + 1).copied()
-    }
-
-    fn skip_whitespace(&mut self) {
-        while let Some(ch) = self.current_char {
-            if ch.is_whitespace() && ch != '\n' {
-                self.advance();
-            } else {
-                break;
-            }
-        }
-    }
-
-    fn read_word(&mut self) -> String {
-        let mut word = String::new();
-        let mut in_quotes = false;
-        let mut quote_char = '"';
-
-        while let Some(ch) = self.current_char {
-            match ch {
-                // Handle quotes
-                '"' | '\'' if !in_quotes => {
-                    in_quotes = true;
-                    quote_char = ch;
-                    self.advance();
-                },
-                ch if in_quotes && ch == quote_char => {
-                    in_quotes = false;
-                    self.advance();
-                },
-                // Stop at special characters when not in quotes
-                '|' | '>' | '<' | '\n' if !in_quotes => {
-                    break;
-                },
-                // Stop at whitespace when not in quotes
-                ch if !in_quotes && ch.is_whitespace() => {
-                    break;
-                },
-                // Regular character
-                _ => {
-                    word.push(ch);
-                    self.advance();
-                }
-            }
-        }
-
-        word
-    }
-
-    fn next_token(&mut self) -> Token {
-        loop {
-            match self.current_char {
-                None => return Token::Eof,
-
-                Some('\n') => {
-                    self.advance();
-                    return Token::Newline;
-                },
-
-                Some(ch) if ch.is_whitespace() => {
-                    self.skip_whitespace();
-                    continue;
-                },
-
-                Some('|') => {
-                    self.advance();
-                    return Token::Pipe;
-                },
-
-                Some('>') => {
-                    self.advance();
-                    if self.current_char == Some('>') {
-                        self.advance();
-                        return Token::RedirectAppend;
-                    } else {
-                        return Token::RedirectOut;
-                    }
-                },
-
-                Some('<') => {
-                    self.advance();
-                    return Token::RedirectIn;
-                },
-
-                Some(_) => {
-                    let word = self.read_word();
-                    if word.is_empty() {
-                        // This shouldn't happen, but just in case
-                        self.advance();
-                        continue;
-                    }
-                    return Token::Word(word);
-                }
-            }
-        }
-    }
-
-    fn tokenize(&mut self) -> Vec<Token> {
-        let mut tokens = Vec::new();
-
-        loop {
-            let token = self.next_token();
-            let is_eof = matches!(token, Token::Eof);
-            tokens.push(token);
-            if is_eof {
-                break;
-            }
-        }
-
-        tokens
-    }
-}
-
-struct Parser {
-    tokens: Vec<Token>,
-    position: usize,
-}
-
-impl Parser {
-    fn new(tokens: Vec<Token>) -> Self {
-        Self {
-            tokens,
-            position: 0,
-        }
-    }
-
-    fn current_token(&self) -> &Token {
-        self.tokens.get(self.position).unwrap_or(&Token::Eof)
-    }
-
-    fn advance(&mut self) {
-        if self.position < self.tokens.len() {
-            self.position += 1;
-        }
-    }
-
-    fn expect_word(&mut self) -> Result<String> {
-        match self.current_token() {
-            Token::Word(word) => {
-                let result = word.clone();
-                self.advance();
-                Ok(result)
-            },
-            token => Err(eyre::eyre!("Expected word, found {:?}", token)),
-        }
-    }
-
-    fn parse_command(&mut self) -> Result<Command> {
-        self.parse_pipeline()
-    }
-
-    fn parse_pipeline(&mut self) -> Result<Command> {
-        let mut left = self.parse_redirected_command()?;
-
-        while matches!(self.current_token(), Token::Pipe) {
-            self.advance(); // consume |
-            let right = self.parse_redirected_command()?;
-            left = Command::Pipe {
-                left: Box::new(left),
-                right: Box::new(right),
-            };
-        }
-
-        Ok(left)
-    }
-
-    fn parse_redirected_command(&mut self) -> Result<Command> {
-        let mut command = self.parse_simple_command()?;
-        let mut redirects = Vec::new();
-
-        while matches!(self.current_token(), Token::RedirectOut | Token::RedirectAppend | Token::RedirectIn) {
-            let redirect_type = match self.current_token() {
-                Token::RedirectOut => RedirectType::OutputOverwrite,
-                Token::RedirectAppend => RedirectType::OutputAppend,
-                Token::RedirectIn => RedirectType::InputFrom,
-                _ => unreachable!(),
-            };
-
-            self.advance(); // consume redirect token
-
-            let target_str = self.expect_word()?;
-            let target = parse_filespec(&target_str);
-
-            redirects.push(Redirect {
-                redirect_type,
-                target,
-            });
-        }
-
-        if redirects.is_empty() {
-            Ok(command)
-        } else {
-            Ok(Command::Redirect {
-                command: Box::new(command),
-                redirects,
-            })
-        }
-    }
-
-    fn parse_simple_command(&mut self) -> Result<Command> {
-        use BuiltinCommand::*;
-        use Command::*;
-
-        if matches!(self.current_token(), Token::Eof | Token::Newline) {
-            return Ok(Empty);
-        }
-
-        let command_name = self.expect_word()?;
-        let mut args = Vec::new();
-
-        // Collect arguments until we hit a special token
-        while matches!(self.current_token(), Token::Word(_)) {
-            if let Token::Word(arg) = self.current_token() {
-                args.push(arg.clone());
-                self.advance();
-            }
-        }
-
-        match command_name.to_uppercase().as_str() {
-            "ECHO" => {
-                if args.is_empty() {
-                    Ok(Builtin(EchoPlain))
-                } else {
-                    match args[0].to_uppercase().as_str() {
-                        "ON" if args.len() == 1 => Ok(Builtin(EchoOn)),
-                        "OFF" if args.len() == 1 => Ok(Builtin(EchoOff)),
-                        _ => Ok(Builtin(EchoText {
-                            message: args.join(" "),
-                        })),
-                    }
-                }
-            },
-
-            "CLS" => Ok(Builtin(Cls)),
-
-            "EXIT" => Ok(Builtin(Exit)),
-
-            "MORE" => Ok(Builtin(More)),
-
-            "VERIFY" => Ok(Builtin(Verify)),
-
-            // File-oriented commands
-            "COPY" => {
-                if args.len() >= 2 {
-                    Ok(Builtin(Copy {
-                        from: parse_filespec(&args[0]),
-                        to: parse_filespec(&args[1]),
-                    }))
-                } else {
-                    Err(eyre::eyre!("COPY requires source and destination"))
-                }
-            },
-
-            "DIR" => Ok(Builtin(Dir {
-                path: if args.is_empty() {
-                    PathBuf::from(".")
-                } else {
-                    PathBuf::from(&args[0])
-                },
-            })),
-
-            "TYPE" => {
-                if args.is_empty() {
-                    Err(eyre::eyre!("TYPE requires a filename"))
-                } else {
-                    Ok(Builtin(Type {
-                        file: parse_filespec(&args[0]),
-                    }))
-                }
-            },
-
-            "CD" | "CHDIR" => Ok(Builtin(Chdir {
-                path: if args.is_empty() {
-                    std::env::current_dir()?
-                } else {
-                    PathBuf::from(&args[0])
-                },
-            })),
-
-            "MKDIR" | "MD" => {
-                if args.is_empty() {
-                    Err(eyre::eyre!("MKDIR requires a directory name"))
-                } else {
-                    Ok(Builtin(Mkdir {
-                        path: PathBuf::from(&args[0]),
-                    }))
-                }
-            },
-
-            "RMDIR" | "RD" => {
-                if args.is_empty() {
-                    Err(eyre::eyre!("RMDIR requires a directory name"))
-                } else {
-                    Ok(Builtin(Rmdir {
-                        path: PathBuf::from(&args[0]),
-                    }))
-                }
-            },
-
-            "DEL" | "ERASE" => {
-                if args.is_empty() {
-                    Err(eyre::eyre!("DEL requires a filename"))
-                } else {
-                    Ok(Builtin(Remove {
-                        path: PathBuf::from(&args[0]),
-                    }))
-                }
-            },
-
-            "REM" => Ok(Builtin(Rem {
-                message: args.join(" "),
-            })),
-
-            "VER" => Ok(Builtin(Ver)),
-
-            "DATE" => Ok(Builtin(Date)),
-
-            "TIME" => Ok(Builtin(Time)),
-
-            "PATH" => {
-                if args.is_empty() {
-                    Ok(Builtin(PathGet))
-                } else {
-                    Ok(Builtin(PathSet {
-                        value: args.join(" "),
-                    }))
-                }
-            },
-
-            "SET" => {
-                if args.is_empty() {
-                    Err(eyre::eyre!("SET requires variable name"))
-                } else {
-                    let full_arg = args.join(" ");
-                    if let Some(eq_pos) = full_arg.find('=') {
-                        let name = full_arg[..eq_pos].trim().to_string();
-                        let value = full_arg[eq_pos + 1..].trim().to_string();
-                        Ok(Builtin(Set { name, value }))
-                    } else {
-                        Err(eyre::eyre!("SET requires variable=value format"))
-                    }
-                }
-            },
-
-            // Drive change (like C:, D:, etc.)
-            _ if command_name.len() == 2 && command_name.ends_with(':') => Ok(Empty),
-
-            // External command
-            _ => Ok(External {
-                program: command_name,
-                args,
-            }),
-        }
-    }
-}
-
-fn parse_filespec(p0: &str) -> FileSpec {
-    match p0 {
-        "CON" => FileSpec::Con,
-        "LPT1" => FileSpec::Lpt1,
-        "LPT2" => FileSpec::Lpt2,
-        "LPT3" => FileSpec::Lpt3,
-        "PRN" => FileSpec::Prn,
-        _ => FileSpec::Path(PathBuf::from(p0)),
-    }
-}
-
-impl Command {
-    fn parse(input: &str) -> Result<Command> {
-        let trimmed = input.trim();
-        if trimmed.is_empty() {
-            return Ok(Command::Empty);
-        }
-
-        let mut lexer = Lexer::new(trimmed);
-        let tokens = lexer.tokenize();
-
-        let mut parser = Parser::new(tokens);
-        parser.parse_command()
-    }
-}