Fixed GOTO to use correct line index then added INPUT, APPEND_VALUE, CLEAR_VALUE, ADD, SUB, NL, CLS, and WAIT

Author: boyninja1555

Cargo.lock

@@ -2,7 +2,7 @@ cargo-features = ["edition2024"]
 
 [package]
 name = "floor-basic"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -2,6 +2,8 @@ use lazy_static::lazy_static;
 use std::collections::HashMap;
 use std::io::{self, Write};
 use std::sync::Mutex;
+use std::thread;
+use std::time::Duration;
 
 lazy_static! {
     static ref LATEST_STORED_VALUE: Mutex<String> = Mutex::new("undefined".to_string());
@@ -52,3 +54,79 @@ pub fn PX(_: &[&str]) {
 pub fn GOTO(_: &[&str]) {
     // This command is handled directly, as some values cannot be passed here.
 }
+
+// OPCODE: 0x05
+// Takes text-based input from the console, then assigns the value to the current value.
+pub fn INPUT(_: &[&str]) {
+    let mut stored_value = LATEST_STORED_VALUE.lock().unwrap();
+    let mut input: String = String::new();
+
+    print!("> ");
+    io::stdout().flush().unwrap();
+    io::stdin()
+        .read_line(&mut input)
+        .expect("Could not read your input!");
+    *stored_value = input.trim().to_string();
+}
+
+// OPCODE: 0x06
+// Appends a text-based value to the currently-stored value.
+pub fn APPEND_VALUE(args: &[&str]) {
+    let mut stored_value = LATEST_STORED_VALUE.lock().unwrap();
+    stored_value.push_str(&args.join(" "));
+}
+
+// OPCODE: 0x07
+// Clears the currently-stored value
+pub fn CLEAR_VALUE(_: &[&str]) {
+    let mut stored_value = LATEST_STORED_VALUE.lock().unwrap();
+    *stored_value = "undefined".to_string();
+}
+
+// OPCODE: 0x08
+// Adds a number-based value to the currently-stored value.
+pub fn ADD(args: &[&str]) {
+    if let Ok(addend) = args.join(" ").parse::<i32>() {
+        let mut stored_value = LATEST_STORED_VALUE.lock().unwrap();
+        if let Ok(current) = stored_value.parse::<i32>() {
+            *stored_value = (current + addend).to_string();
+        }
+    }
+}
+
+// OPCODE: 0x09
+// Subtracts a number-based value from the currently-stored value.
+pub fn SUB(args: &[&str]) {
+    if let Ok(subtrahend) = args.join(" ").parse::<i32>() {
+        let mut stored_value = LATEST_STORED_VALUE.lock().unwrap();
+        if let Ok(current) = stored_value.parse::<i32>() {
+            *stored_value = (current - subtrahend).to_string();
+        }
+    }
+}
+
+// OPCODE: 0x0A
+// Prints a new line to the console.
+pub fn NL(_: &[&str]) {
+    println!();
+}
+
+// OPCODE: 0x0B
+// Clears the console.
+pub fn CLS(_: &[&str]) {
+    print!("\x1B[2J\x1B[1;1H");
+    io::stdout().flush().unwrap();
+}
+
+// OPCODE: 0x0C
+// Waits/sleeps a specific amount of milliseconds, based on the currently-stored value.
+pub fn WAIT(_: &[&str]) {
+    let stored_value = LATEST_STORED_VALUE.lock().unwrap();
+    if let Ok(ms) = stored_value.parse::<u64>() {
+        thread::sleep(Duration::from_millis(ms));
+    } else {
+        println!(
+            "When running the wait command, the currently-stored value must be in milliseconds!"
+        );
+    }
+}

src/executor/commands.rs

@@ -9,6 +9,14 @@ pub fn execute(line: &str) {
     valid_commands.insert("SETVALUE", commands::SETVALUE);
     valid_commands.insert("PRINT", commands::PRINT);
     valid_commands.insert("PX", commands::PX);
+    valid_commands.insert("INPUT", commands::INPUT);
+    valid_commands.insert("APPEND_VALUE", commands::APPEND_VALUE);
+    valid_commands.insert("CLEAR_VALUE", commands::CLEAR_VALUE);
+    valid_commands.insert("ADD", commands::ADD);
+    valid_commands.insert("SUB", commands::SUB);
+    valid_commands.insert("NL", commands::NL);
+    valid_commands.insert("CLS", commands::CLS);
+    valid_commands.insert("WAIT", commands::WAIT);
 
     if let Some(action) = valid_commands.get(cmd) {
         action(&parts[1..]);

src/executor/mod.rs

@@ -51,15 +51,82 @@ fn handle_fbin(buffer: Vec<u8>) -> Result<()> {
                 let target: usize = buffer[i] as usize;
                 i += 1;
 
-                if target < buffer.len() {
-                    i = target;
+                let adjusted: usize = target.saturating_sub(1);
+
+                if adjusted < buffer.len() {
+                    i = adjusted;
                     continue;
                 } else {
                     println!("GOTO target {} out of bounds", target);
                     break;
                 }
             }
 
+            // INPUT
+            // Takes text-based input from the console, then assigns the value to the current value.
+            0x05 => executor::execute("INPUT"),
+
+            // APPEND_VALUE
+            // Appends a text-based value to the currently-stored value.
+            0x06 => {
+                let mut arg_bytes: Vec<u8> = Vec::new();
+                while i < buffer.len() && buffer[i] != 0x00 {
+                    arg_bytes.push(buffer[i]);
+                    i += 1;
+                }
+                i += 1;
+                if let Ok(arg_str) = String::from_utf8(arg_bytes) {
+                    executor::execute(&format!("APPEND_VALUE {}", arg_str));
+                }
+                continue;
+            }
+
+            // CLEAR_VALUE
+            // Clears the currently-stored value
+            0x07 => executor::execute("CLEAR_VALUE"),
+
+            // ADD
+            // Adds a number-based value to the currently-stored value.
+            0x08 => {
+                let mut arg_bytes: Vec<u8> = Vec::new();
+                while i < buffer.len() && buffer[i] != 0x00 {
+                    arg_bytes.push(buffer[i]);
+                    i += 1;
+                }
+                i += 1;
+                if let Ok(arg_str) = String::from_utf8(arg_bytes) {
+                    executor::execute(&format!("ADD {}", arg_str));
+                }
+                continue;
+            }
+
+            // SUB
+            // Subtracts a number-based value from the currently-stored value.
+            0x09 => {
+                let mut arg_bytes: Vec<u8> = Vec::new();
+                while i < buffer.len() && buffer[i] != 0x00 {
+                    arg_bytes.push(buffer[i]);
+                    i += 1;
+                }
+                i += 1;
+                if let Ok(arg_str) = String::from_utf8(arg_bytes) {
+                    executor::execute(&format!("SUB {}", arg_str));
+                }
+                continue;
+            }
+
+            // NL
+            // Prints a new line to the console.
+            0x0A => executor::execute("NL"),
+
+            // CLS
+            // Clears the console.
+            0x0B => executor::execute("CLS"),
+
+            // WAIT
+            // Waits/sleeps a specific amount of milliseconds, based on the currently-stored value.
+            0x0C => executor::execute("WAIT"),
+
             // Other(s)
             _ => {}
         }