feat: better execution utils + simplification

Author: CREAsTIVE

stack-control-shell/src/main.rs

@@ -1,15 +1,22 @@
 use itertools::Itertools;
 use prompted::input;
-use stack_control::{runtime::stack::Stack, utils::execution::{execute, ExecutionException}};
+use stack_control::{bytecode::commands::core::bind_default_commands, compiletime::{compiler::Scope, lexer::split_string_to_tokens}, runtime::stack::Stack, utils::execution::{execute_code, join, simplify, ExecutionException}};
 
 fn main() {
   loop {
     let input = input!("> ");
     if input == "exit" {break;}
 
+    let mut scope = Scope::new();
+    bind_default_commands(&mut scope.command_map);
+
     let mut stack = Stack::new();
 
-    match execute(&input, &mut stack) {
+    let tokens = split_string_to_tokens(&input);
+    println!("< {}", simplify(&tokens, &scope.command_map).map(|e| e.to_string()).join(""));
+    
+
+    match execute_code(&input, &mut stack) {
       Err(ExecutionException::Compilation(compile_error)) =>
         println!("Compilation error: {:?}", compile_error.to_string()),
       Err(ExecutionException::Runtime(runtime_error)) =>

stack-control/Cargo.toml

@@ -8,4 +8,4 @@ itertools = "0.14.0"
 unicode-segmentation = "1.10.1"
 indoc = "2"
 strum = "0.27"
-strum_macros = "0.27"
+strum_macros = "0.27"

stack-control/src/compiletime/compiler.rs

@@ -6,7 +6,7 @@ use crate::{bytecode::commands::{core::{ListGeneratorCommand, StackPusherCommand
 
 use super::{command_map::{CommandMap}, lexer::{CommandToken, Token}};
 
-pub struct CompileTime {
+pub struct Scope {
   pub command_map: CommandMap,
   list_opener: Arc<DescribedCommand>, // StackPusherCommand{value_to_push: Value::OpenListIdentifier}
   list_generator: Arc<DescribedCommand>,
@@ -16,7 +16,7 @@ pub struct CompileTime {
 pub enum CompilationException {
   UnexcpectedEndToken(String),
   FunctionTokenRequired,
-  CommandNotFound(char),
+  CommandNotFound(String),
   AliasNotFound(String),
 }
 
@@ -28,7 +28,7 @@ impl ToString for CompilationException {
       CompilationException::AliasNotFound(alias) =>
         format!("Alias {alias} not found"),
       CompilationException::CommandNotFound(cmd) => 
-        format!("Command {cmd} not found"),
+        format!("Command '{cmd}' not found"),
       CompilationException::FunctionTokenRequired =>
         format!("Function token required"),
       CompilationException::UnexcpectedEndToken(t) => 
@@ -37,9 +37,9 @@ impl ToString for CompilationException {
   }
 }
 
-impl CompileTime {
+impl Scope {
   pub fn new() -> Self {
-    CompileTime { 
+    Scope { 
       command_map: CommandMap::new(), 
 
       list_opener: Arc::new(DescribedCommand {
@@ -118,7 +118,7 @@ impl CompileTime {
 
       CommandToken::CommandOrAlias(alias) =>
         self.command_map.get(&alias)
-          .ok_or(CompilationException::CommandNotFound('0'))?,
+          .ok_or(CompilationException::CommandNotFound(alias.clone()))?,
 
       CommandToken::ListOpenBracket =>
         self.list_opener.clone(),

stack-control/src/compiletime/lexer.rs

@@ -6,6 +6,7 @@ Splits input string into separate tokens, no other logic involved
 
 use std::iter::Peekable;
 
+#[derive(Clone)]
 pub enum Token {
   FunctionOpenBracket,
   FunctionCloseBracket,
@@ -24,6 +25,7 @@ impl ToString for Token {
   }
 }
 
+#[derive(Clone)]
 pub enum CommandToken {
   CommandOrAlias(String),
   ListOpenBracket,

stack-control/src/utils/execution.rs

@@ -1,25 +1,44 @@
-use crate::{bytecode::commands::{core::bind_default_commands, RuntimeException}, compiletime::{compiler::{CompilationException, CompileTime}, lexer::split_string_to_tokens}, runtime::stack::Stack};
+use std::sync::Arc;
+
+use itertools::Itertools;
+
+use crate::{bytecode::commands::{core::bind_default_commands, DescribedCommand, RuntimeException}, compiletime::{command_map::{self, CommandMap}, compiler::{CompilationException, Scope}, lexer::{split_string_to_tokens, CommandToken, Token}}, runtime::stack::Stack};
 
 pub enum ExecutionException {
   Runtime(RuntimeException),
   Compilation(CompilationException)
 }
 
-pub fn execute(code: &str, stack: &mut Stack) -> Result<(), ExecutionException> {
+pub fn simplify(tokens: &Vec<Token>, map: &CommandMap) -> impl Iterator<Item = Token> {
+  tokens.iter().map(|e| match e {
+    Token::CommandToken(CommandToken::CommandOrAlias(e)) => 
+      Token::CommandToken(CommandToken::CommandOrAlias(String::from(map.get_by_alias(&e).unwrap_or(e)))),
+    any => any.clone()
+  })
+}
+
+pub fn join(tokens: impl Iterator<Item = Token>) -> String {
+  tokens
+    .map(|e| e.to_string())
+    .join(", ")
+}
+
+pub fn execute_commands(commands: Vec<Arc<DescribedCommand>>, stack: &mut Stack) -> Result<(), RuntimeException> {
+  for command in commands {
+    command.execution.execute(stack)?;
+  }
+  Ok(())
+}
+
+pub fn execute_code(code: &str, stack: &mut Stack) -> Result<(), ExecutionException> {
   let tokens = split_string_to_tokens(code);
-  let mut compiletime = CompileTime::new();
+  let mut compiletime = Scope::new();
 
   bind_default_commands(&mut compiletime.command_map);
 
   match compiletime.compile(tokens) {
-    Ok(commands) => {
-      commands
-        .iter()
-        .try_for_each(|command| { 
-          command.execution.execute(stack).or_else(|e| Err(ExecutionException::Runtime(e)))
-        })?;
-      Ok(())
-    },
+    Ok(commands) => 
+      execute_commands(commands, stack).or_else(|e| Err(ExecutionException::Runtime(e))),
 
     Err(err) => {
       Err(ExecutionException::Compilation(err))