added new keyword type

working on docs
removed a lot of the .uwnrap

Author: mendelsshop

README.md

@@ -14,6 +14,67 @@ Too see the understand the keywords and their meaning, refer to [this file](http
 <br>
 There is semi working vscode extension for UMPL, you can find it [here](https://github.com/mendelsshop/UMPL_VSCode_Extension)
 <br>
-At UMPL to fix the null problem, we have invented a new type called hempty, which is the same as null, but it sounds better, and it adds to the long list of\ null like types across all the proggraming languages.
+At UMPL to fix the null problem, we have invented a new type called hempty, which is the same as null, but it sounds better, and it adds to the long list of null like types across all the proggraming languages.
 <br> 
 All bug reports head straight to /dev/hempty
+
+# language-documentation
+## Declarations
+| name | description | usage | special keywords | special variables | example(s) |
+|:---:|:---:|:---:|:---:|:---:|:---|
+| create | creates a variable | create var-name with literal or expression| N/A | N/A| ```create num-var with 5``` <br> ```create str-var with ((input `>> `))>``` ```create var with str-var```|
+| list | creates a list | list var-name with [literal or expression literal or expression]| N/A | N/A| ```list num-list with [1 3]``` <br> ```list str-list with [8, ((input `>> `))]```|
+| potato | declares a function | potato emoji-name num-of-args ⧼code⧽| return literal-or-expression| for each argument you get `$argument-number` ie `$1` for the first one etc | ```potato 😀 2 ⧼return ((plus $1 $2))>⧽```|
+
+## Control Flow
+|name|description|usage|special keywords| example(s) |
+|:---:|:---:|:---:|:---:|:---|
+| if statement| if boolean is true do if code else do else code |if {boolean literal or expression} ⧼if code⧽ else ⧼else code⧽|N/A| ```if {true} ⧼(`true`)>⧽ else ⧼(`false`)>⧽``` <br>  ```if {not((true))>} ⧼(`true`)>⧽ else ⧼(`false`)>⧽``` <br>  ```if {boolean-var} ⧼if {true} ⧼(`true`)>⧽ else ⧼(`false`)>⧽ ⧽ else ⧼(`false`)>⧽```|
+| loop statement | loop until the code reaches break of continue |loop ⧼code⧽ |break, continue| ```loop ⧼ if {true} ⧼(`true`)> break ⧽ else ⧼(`false`)> continue ⧽⧽```
+
+## Keywords
+### To call a keyword you first need create an expression so ()> or ()>> or ()< and in the expression you put another pair of parentheses and the keyeword and its arguments.
+| name | description| paremeters | returns | example(s) |
+| :-: | :-: | :-: | :-: | :- |
+| plus | if the first argument is a number, returns the sum of all the arguments, if its a string, each argument after is conctenated to the string, anything else wont work | any*1: argument | any |
+| minus| sets the first parameter to the original value each next argument is subtract to it unless there is one argument in which case it is negated returning the negative value of it | number*1: argument | number |
+|multiply| if the first arguments is string, multiplies the string by the next argument, if its a number, sets the first parameter to the original value each next argument is multiplied to it, any other thing does not work | any*1: argument | any |
+|divide| sets the first argument to the original value each next argument is divided by the previous divisor | number*1: argument | number |
+|not| returns true if the value is false, false otherwise | [boolean: value] | boolean |
+|or| comapares value1 and value2 and returns true if either is true | [boolean: value1, boolean: value2] | boolean |
+|and| comapares value1 and value2 and returns true if both are true | [boolean: value1, boolean: value2] | boolean |
+|eq| compare two values if they are equal | [boolean: value1, boolean: value2] | boolean |
+|ne | compare two values if not equal | [boolean: value1, boolean: value2] |  boolean |
+|gt| checks if the number1 is greater than the number2 | [number: number1, number: number2] | boolean |
+|lt| check if the number1 is less than the number2 | [number: number1, number: number2] | boolean |
+|le| checks if the number1 is less than or equal to the right number2 | [number: number1, number: number2] | boolean |
+|ge| check if the number1 is greater than or equal to the number2 | [number: number1, number: number2] |   boolean |
+|addwith| adds value to variable in place, if the variable is a string anything can added to it, but if its a number only number can, anything cannot be added to |  [variable: variable, any: value] | number |
+|dividewith| divides value by variable in place | [variable: variable, number: value] | number |
+|subtractwith| subtracts value from variable in place | [variable: variable, number: value] | number |
+|multiplywith| multiplies value by variable in place, if variable is a string than the variable becomes the string value times, if the variable is a number we multiply the variable by the value, any other variable wont work | [variable: variable, number: value] | number |
+|input| input with message | [string: message] | string |
+|setwith| sets a variable to a value | [variable: variable , value*: any] | any |
+|exit| exits with number provided | [number: number] | hempty |
+|error| errors with error message provided |  [string: message] | hempty |
+|strtonum| converts string to number | [string: string] |   number |
+|strtobool| converts string to boolean | [string: string] | boolean |
+|strtohempty| converts string to hempty | [string: string] |    hempty |
+|runcommand| runs os command | [string: command] |  string |
+|open| opens file | [string: file] |  file |
+|close| closes file | [file: file] |    hempty |
+|write| writes message to file with mode | [file: file, string: message, string: mode] |    hempty |
+|writeline| writes message to file at line with mode | [file: file, string: message, number: line, string: mode] |  hempty |
+|read| reads from file | [file: file] |   string |
+|readline| reads the line specified from the file | [file: file, number: line] |  string |
+|delete| deletes variable | [variable: variable] |  hempty |
+|deletefile | deletes file | [file: file] |   hempty |
+|createfile| creates new file | [file: file] | file |
+|new| run custom function | function: name, arguments |  whatever the function returns | ```((new 😀 3 5))>``` |
+|type | returns the type of the value | [any: value] | string | ```((type 1))>```|
+
+`*`: 
+sometimes you can set a variable to two values for making list in lists
+<br>
+`*1`: 
+one or more arguments

keywords.md

@@ -78,7 +78,7 @@ pub fn get_dash_args(args: &[String], start_index: usize, args_struct: &mut Pars
                         file if file.is_empty() => 0,
                         file => file.len(),
                     };
-                    unsafe { TOGGLE_CASE = num.try_into().unwrap() }
+                    unsafe { TOGGLE_CASE = num as i32 };
                 } else if char_part_arg == 't' {
                     let number: i32 = match arg.split_once('=') {
                         Some(n) => match n.1.parse() {

src/cli.rs

@@ -381,7 +381,10 @@ impl Scope {
         }
     }
     pub fn drop_scope(&mut self) {
-        let p_scope: Self = *self.parent_scope.take().unwrap();
+        let p_scope: Self = match  self.parent_scope.take(){
+            Some(scope) => *scope,
+            None => error(0, "no parent scope"),
+        };
         *self = p_scope;
     }
 
@@ -687,6 +690,17 @@ impl Eval {
                         error(call.line, format!("Function {} is not defined", name));
                     }
                 }
+                TokenType::Type => {
+                    arg_error(1, call.arguments.len() as u32, &call.keyword, false, call.line);
+                    match self.find_pointer_in_stuff(&call.arguments[0]) {
+                        LiteralOrFile::Literal(a) => {
+                            LiteralOrFile::Literal(LiteralType::String(a.get_type()))
+                        }
+                        LiteralOrFile::File(_) => {
+                            LiteralOrFile::Literal(LiteralType::String("file".to_string()))
+                        }
+                    }
+                }
                 TokenType::Delete => {
                     if call.arguments.len() != 1 {
                         error(call.line, "delete takes one argument");
@@ -1330,7 +1344,7 @@ impl Eval {
 
 impl fmt::Debug for Eval {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "scope {:?}", self.scope).unwrap();
+        write!(f, "scope {:?}", self.scope)?;
         Ok(())
     }
 }

src/eval.rs

@@ -60,6 +60,7 @@ impl Keyword {
         keywords.insert("writeline".to_string(), TokenType::WriteLine);
         keywords.insert("createfile".to_string(), TokenType::CreateFile);
         keywords.insert("deletefile".to_string(), TokenType::DeleteFile);
+        keywords.insert("type".to_string(), TokenType::Type);
         if num != 0 {
             for (key, value) in &keywords.clone() {
                 keywords.remove(key);

src/keywords.rs

@@ -115,6 +115,7 @@ impl Lexer {
         false
     }
 
+    #[allow(clippy::too_many_lines)]
     fn string(&mut self) {
         while self.peek() != '`' && !self.is_at_end() {
             if self.peek() == '\n' {
@@ -168,17 +169,18 @@ impl Lexer {
                             y if y.is_ascii_hexdigit() => {
                                 self.insert_text(
                                     self.current,
-                                    u8::from_str_radix(format!("{x}{y}").as_str(), 16).unwrap()
-                                        as char,
+                                    u8::from_str_radix(format!("{x}{y}").as_str(), 16).unwrap_or_else(|_| {
+                                        error::error(self.line, "invalid hex escape sequence");
+                                    }) as char,
                                 );
                                 self.advance();
                             }
                             y => {
                                 self.insert_text(
                                     self.current,
-                                    u8::from_str_radix(format!("{x}").as_str(), 16).unwrap()
-                                        as char,
-                                );
+                                    u8::from_str_radix(format!("{x}").as_str(), 16).unwrap_or_else(|_| {
+                                        error::error(self.line, "invalid hex escape sequence");
+                                    }) as char);
                                 self.insert_text(self.current + 1, y);
                                 self.advance();
                             }
@@ -201,8 +203,11 @@ impl Lexer {
                     }
                     self.insert_text(
                         self.current,
-                        char::from_u32(u32::from_str_radix(hex_string.as_str(), 16).unwrap())
-                            .unwrap(),
+                        char::from_u32(u32::from_str_radix(hex_string.as_str(), 16).unwrap_or_else(|_| {
+                                error::error(self.line, "invalid unicode escape sequence");
+                            } ) ).unwrap_or_else(|| {
+                                error::error(self.line, "invalid unicode escape sequence");
+                            })
                     );
                     self.current += 1;
                 } else {

src/lexer.rs

@@ -16,7 +16,8 @@ fn main() {
         cli::get_dash_args(&args, index, &mut parsed_args);
     }
     if parsed_args.log {
-        log4rs::init_file("log.yaml", log4rs::config::Deserializers::default()).unwrap();
+        log4rs::init_file("log.yaml", log4rs::config::Deserializers::default())
+            .unwrap_or_else(|_| panic!("Failed to initialize log4rs"));
         info!("Starting up...");
     }
     let mut full_repl: Vec<String> = Vec::new(); // create a vector to hold the lines of the repl just in case we need to write it to a file
@@ -26,8 +27,8 @@ fn main() {
         'l: loop {
             let mut input = String::new();
             print!(">> "); // print the prompt
-            io::stdout().flush().unwrap();
-            io::stdin().read_line(&mut input).unwrap(); // read the input
+            io::stdout().flush().unwrap_or_else(|_| panic!("Failed to flush stdout"));
+            io::stdin().read_line(&mut input).unwrap_or_else(|_| panic!("Failed to read stdin"));
             if input.trim() == "exit" {
                 // if the input is exit, then exit
                 info!("Exiting...");
@@ -36,9 +37,9 @@ fn main() {
                     if Path::new(&parsed_args.file).exists() && !parsed_args.force {
                         // if the file exists and we are not forcing it to overwrite
                         print!("Do you want to overwrite the {}? (y/n): ", parsed_args.file); // ask the user if they want to overwrite the file
-                        io::stdout().flush().unwrap();
+                        io::stdout().flush().unwrap_or_else(|_| panic!("Failed to flush stdout"));
                         let mut y_or_n: String = String::new();
-                        io::stdin().read_line(&mut y_or_n).unwrap();
+                        io::stdin().read_line(&mut y_or_n).unwrap_or_else(|_| panic!("Failed to read stdin")); // read the input
                         if y_or_n == "n" {
                             // if the user does not want to overwrite the file exit
                             exit(0);
@@ -62,7 +63,11 @@ fn main() {
         }
     } else {
         // if we are not in repl mode ie we are reading a file
-        let mut file: File = File::open(&parsed_args.file).unwrap(); // open the file
+        let mut file: File = File::open(&parsed_args.file).unwrap_or_else(
+            |_| {
+                error::error(0, "Error encountered while opening file!");
+            },
+        ); // open the file
         let mut contents: String = String::new(); // create a string to hold the contents of the file
         match file.read_to_string(&mut contents) {
             Ok(contents) => contents,

src/main.rs

@@ -147,6 +147,15 @@ impl LiteralType {
             Self::Hempty => matches!(other, Self::Hempty),
         }
     }
+
+    pub fn get_type(&self) -> String  {
+        match self {
+            Self::Number(_) => "number".to_string(),
+            Self::String(_) => "string".to_string(),
+            Self::Boolean(_) => "boolean".to_string(),
+            Self::Hempty => "hempty".to_string(),
+        }
+    }
 }
 
 impl Display for LiteralType {
@@ -238,8 +247,7 @@ impl Display for Call {
                 } else {
                     ""
                 }
-            })
-            .unwrap();
+            })?
         }
         write!(f, "{:?}: [{}]", self.keyword, c)
     }