feat: command = command alias

Author: CREAsTIVE

stack-control-doc/src/main.rs

@@ -4,7 +4,7 @@ use stack_control::{bytecode::commands::core::bind_default_commands, compiletime
 
 #[derive(serde::Serialize)]
 struct CommandMeta<'m> {
-    key: char,
+    key: &'m str,
     aliases: &'m Vec<String>,
     description: &'m str,
 }
@@ -14,7 +14,7 @@ fn main() -> Result<(), i32> {
     bind_default_commands(&mut command_map);
     let metadata: Vec<CommandMeta> = command_map.collection.values()
         .map(|c| CommandMeta {
-            key: c.meta.key,
+            key: &c.meta.key,
             aliases: &c.meta.aliases,
             description: &c.meta.description.trim()
         }).collect();

stack-control/src/bytecode/commands.rs

@@ -23,15 +23,15 @@ pub struct DescribedCommand {
 }
 
 pub struct CommandMeta {
-  pub key: char,
+  pub key: String,
   pub aliases: Vec<String>,
   pub description: String
 }
 
 impl Default for CommandMeta {
   fn default() -> Self {
     CommandMeta {
-      key: 'd',
+      key: String::from('d'),
       aliases: vec![],
       description: String::from("No description provided")
     }

stack-control/src/bytecode/commands/core.rs

@@ -26,7 +26,7 @@ macro_rules! define_commands {
     $command_map.set($crate::bytecode::commands::DescribedCommand {
       execution: Box::new($name {}),
       meta: std::sync::Arc::new($crate::bytecode::commands::CommandMeta {
-        key: $key,
+        key: String::from($key),
         aliases: [$($alias),*].iter().map(|s: &&str| s.to_string()).collect::<Vec<String>>(),
         $($vkey : $value),+,
         ..core::default::Default::default()

stack-control/src/compiletime/command_map.rs

@@ -7,8 +7,8 @@ pub struct CommandMap {
   // BUT i waste like 2-3 days trying to do everything on lifetimes and pure references
   // Yeah, i m stupid, maybe later i will fix that
   // but for now i fcking tired, so forgive me once
-  pub collection: HashMap<char, Arc<DescribedCommand>>,
-  pub aliases_collection: HashMap<String, char>
+  pub collection: HashMap<String, Arc<DescribedCommand>>,
+  pub aliases_collection: HashMap<String, String>
 }
 
 impl CommandMap {
@@ -21,15 +21,19 @@ impl CommandMap {
 
   pub fn set(&mut self, command: DescribedCommand) {
     command.meta.aliases.iter()
-      .for_each(|e| { self.aliases_collection.insert(e.clone(), command.meta.key);});
-    self.collection.insert(command.meta.key, Arc::new(command));
+      .for_each(|e| { self.aliases_collection.insert(e.clone(), command.meta.key.clone());});
+    self.collection.insert(command.meta.key.clone(), Arc::new(command));
   }
 
-  pub fn get<'a>(&'a self, name: char) -> Option<Arc<DescribedCommand>> {
-    Some(self.collection.get(&name)?.clone())
+  pub fn get_by_name(&self, name: &str) -> Option<Arc<DescribedCommand>> {
+    Some(self.collection.get(name)?.clone())
   }
 
-  pub fn get_alias(&self, alias: &str) -> Option<char> {
-    self.aliases_collection.get(alias).copied()
+  pub fn get_by_alias(&self, alias: &str) -> Option<&str> {
+    self.aliases_collection.get(alias).map(|s| s.as_str())
+  }
+
+  pub fn get(&self, ident: &str) -> Option<Arc<DescribedCommand>> {
+    self.get_by_name(ident).or_else(|| self.get_by_name(self.get_by_alias(ident)?))
   }
 }

stack-control/src/compiletime/compiler.rs

@@ -20,17 +20,17 @@ pub enum CompilationException {
   AliasNotFound(String),
 }
 
+// TODO: Try macro?
+
 impl ToString for CompilationException {
   fn to_string(&self) -> String {
     match self {
       CompilationException::AliasNotFound(alias) =>
         format!("Alias {alias} not found"),
       CompilationException::CommandNotFound(cmd) => 
         format!("Command {cmd} not found"),
-      
       CompilationException::FunctionTokenRequired =>
         format!("Function token required"),
-
       CompilationException::UnexcpectedEndToken(t) => 
         format!("Unexcpected END token: {t}")
     }
@@ -47,7 +47,7 @@ impl CompileTime {
           value_to_push: Value::OpenListIdentifier
         }),
         meta: Arc::new(CommandMeta {
-          key: '[',
+          key: String::from('['),
           aliases: vec![
             String::from("listopen")
           ],
@@ -60,7 +60,7 @@ impl CompileTime {
       list_generator: Arc::new(DescribedCommand {
         execution: Box::new(ListGeneratorCommand {}),
         meta: Arc::new(CommandMeta {
-          key: ']',
+          key: String::from(']'),
           aliases: vec![
             String::from("listgen")
           ],
@@ -71,7 +71,7 @@ impl CompileTime {
       }),
 
       stack_pusher_meta: Arc::new(CommandMeta {
-        key: '↓',
+        key: String::from('↓'),
         aliases: vec![
           String::from("pushstack")
         ],
@@ -115,14 +115,10 @@ impl CompileTime {
           })
         } else {return Err(CompilationException::FunctionTokenRequired);} // TODO: Error
       },
-
-      CommandToken::Command(name) =>
-        self.command_map.get(name).ok_or(CompilationException::CommandNotFound(name))?,
 
       CommandToken::CommandOrAlias(alias) =>
-        self.command_map.get(
-          self.command_map.get_alias(&alias).ok_or(CompilationException::AliasNotFound(alias))?
-        ).ok_or(CompilationException::CommandNotFound('0'))?,
+        self.command_map.get(&alias)
+          .ok_or(CompilationException::CommandNotFound('0'))?,
 
       CommandToken::ListOpenBracket =>
         self.list_opener.clone(),

stack-control/src/compiletime/lexer.rs

@@ -25,7 +25,6 @@ impl ToString for Token {
 }
 
 pub enum CommandToken {
-  Command(char),
   CommandOrAlias(String),
   ListOpenBracket,
   ListCloseBracket,
@@ -36,7 +35,6 @@ pub enum CommandToken {
 impl ToString for CommandToken {
   fn to_string(&self) -> String {
     match self {
-      Self::Command(char) => String::from(*char),
       Self::CommandOrAlias(alias) => alias.clone(),
       Self::ListOpenBracket => String::from("["),
       Self::ListCloseBracket => String::from("]"),
@@ -63,20 +61,26 @@ pub fn split_string_to_tokens(string: &str) -> Vec<Token> {
 pub fn split_to_tokens<'a>(mut symbols: Peekable<impl Iterator<Item = char> + Clone>) -> Vec<Token> {
   let mut result: Vec<Token> = Vec::new();
 
+  let p = parse_special_symbol;
+
   while let Some(_) = symbols.peek() {
     result.push(
-      parse_number(&mut symbols)
-      .or_else(|| parse_special_symbol(&mut symbols, '[', Token::CommandToken(CommandToken::ListOpenBracket))) 
-      .or_else(|| parse_special_symbol(&mut symbols, ']', Token::CommandToken(CommandToken::ListCloseBracket)))
-      .or_else(|| parse_special_symbol(&mut symbols, '(', Token::FunctionOpenBracket))
-      .or_else(|| parse_special_symbol(&mut symbols, ')', Token::FunctionCloseBracket))
-      .or_else(|| parse_special_symbol(&mut symbols, '#', Token::CommandToken(CommandToken::Function)))
+      // if one of special symbols
+                  p(&mut symbols, '[', Token::CommandToken(CommandToken::ListOpenBracket))
+      .or_else(|| p(&mut symbols, ']', Token::CommandToken(CommandToken::ListCloseBracket)))
+      .or_else(|| p(&mut symbols, '(', Token::FunctionOpenBracket))
+      .or_else(|| p(&mut symbols, ')', Token::FunctionCloseBracket))
+      // TODO: Change # to CommandContainer symbol
+      .or_else(|| p(&mut symbols, '#', Token::CommandToken(CommandToken::Function)))
+
+      // Or whitespace
       .or_else(|| {
         if symbols.peek()?.is_whitespace() {return Some(Token::WhiteSpace(symbols.next()?))}
         None
       })
-      .or_else(|| parse_alias(&mut symbols))
-      .unwrap_or_else(|| Token::CommandToken(CommandToken::Command(symbols.next().expect("Unexcpected exception: peek is lier!"))))
+      // Or one of "complex" tokens
+      .or_else(|| parse_number(&mut symbols))
+      .unwrap_or_else(|| parse_command_or_alias(&mut symbols).expect("Internal exception!"))
     );
   };
 
@@ -88,11 +92,12 @@ fn parse_special_symbol(iter: &mut Peekable<impl Iterator<Item = char> + Clone>,
   return None
 }
 
-fn parse_alias<'a>(iter: &mut Peekable<impl Iterator<Item = char> + Clone>) -> Option<Token> {
-  if !iter.peek()?.is_alphabetic() {return None}
+fn parse_command_or_alias<'a>(iter: &mut Peekable<impl Iterator<Item = char> + Clone>) -> Option<Token> {
+  let p = *iter.peek()?;
+  if p.is_numeric() || p.is_whitespace() || p == '.' {return None}
   let mut result = String::new();
   while let Some(symbol) = iter.peek() {
-    if !symbol.is_alphanumeric() {break;}
+    if symbol.is_whitespace() {break;}
     result.push(*symbol);
     iter.next();
   };