Clean up public API

object-Object · object-Object · commit c2e843e2d7be · 2025-08-11T20:39:23.000-04:00
diff --git a/.cargo/config.toml b/.cargo/config.toml
@@ -4,3 +4,4 @@ rustflags = ["-C", "target-cpu=native"]
 [alias]
 mlog = "run --release --features mlog --bin mlog --"
 mlogv32 = "run --release --features mlogv32 --bin mlogv32 --"
+test-nostd = "test --no-default-features --features no_std,serde_alloc"
diff --git a/src/bin/mlog.rs b/src/bin/mlog.rs
@@ -5,8 +5,11 @@ use clap_stdin::FileOrStdin;
 use mindustry_rs::{
     types::{Object, ProcessorConfig, ProcessorLinkConfig},
     vm::{
-        Building, BuildingData, HYPER_PROCESSOR, LOGIC_PROCESSOR, LogicVMBuilder, MEMORY_BANK,
-        MEMORY_CELL, MESSAGE, MICRO_PROCESSOR, WORLD_PROCESSOR,
+        Building, BuildingData, LogicVMBuilder,
+        buildings::{
+            HYPER_PROCESSOR, LOGIC_PROCESSOR, MEMORY_BANK, MEMORY_CELL, MESSAGE, MICRO_PROCESSOR,
+            WORLD_PROCESSOR,
+        },
     },
 };
 use strum_macros::EnumString;
diff --git a/src/bin/mlogv32.rs b/src/bin/mlogv32.rs
@@ -28,8 +28,8 @@ use itertools::Itertools;
 use mindustry_rs::{
     types::{Object, PackedPoint2, ProcessorConfig, Schematic},
     vm::{
-        Building, BuildingData, LObject, LValue, LVar, LogicVM, LogicVMBuilder, MEMORY_BANK,
-        MESSAGE, MICRO_PROCESSOR, SWITCH, WORLD_PROCESSOR,
+        Building, BuildingData, LObject, LValue, LVar, LogicVM, LogicVMBuilder,
+        buildings::{MEMORY_BANK, MESSAGE, MICRO_PROCESSOR, SWITCH, WORLD_PROCESSOR},
     },
 };
 use serde::Deserialize;
@@ -666,13 +666,13 @@ fn main() -> Result<(), Box<dyn Error>> {
                         VMCommand::SetBreakpoint(Some(value)) => {
                             config
                                 .state
-                                .set_variable(u16str!("BREAKPOINT_ADDRESS"), value.into())?;
+                                .set_variable(u16str!("BREAKPOINT_ADDRESS"), value.into());
                             tui_println!(debug, "Breakpoint set: {value:#010x}");
                         }
                         VMCommand::SetBreakpoint(None) => {
                             config
                                 .state
-                                .set_variable(u16str!("BREAKPOINT_ADDRESS"), LValue::NULL)?;
+                                .set_variable(u16str!("BREAKPOINT_ADDRESS"), LValue::NULL);
                             tui_println!(debug, "Breakpoint cleared.");
                         }
                         VMCommand::PrintVar(name, radix) => {
diff --git a/src/vm/buildings.rs b/src/vm/buildings.rs
@@ -6,8 +6,8 @@ use strum_macros::IntoStaticStr;
 use widestring::U16String;
 
 use super::{
-    LObject, LVar, LogicVM, LogicVMBuilder, Processor, ProcessorBuilder, ProcessorState,
-    VMLoadError, VMLoadResult, instructions::InstructionResult, variables::LValue,
+    InstructionResult, LObject, LValue, LVar, LogicVM, LogicVMBuilder, Processor, ProcessorBuilder,
+    ProcessorState, VMLoadError, VMLoadResult,
 };
 use crate::types::{
     LAccess, Object, PackedPoint2,
@@ -54,18 +54,11 @@ impl Building {
         Ok(Self::new(Self::get_block(name)?, position, data))
     }
 
-    fn get_block(name: &str) -> VMLoadResult<&'static Block> {
-        content::blocks::FROM_NAME
-            .get(name)
-            .copied()
-            .ok_or_else(|| VMLoadError::UnknownBlockType(name.to_string()))
-    }
-
     pub fn from_config(
         name: &str,
         position: PackedPoint2,
         config: &Object,
-        #[cfg_attr(not(feature = "std"), allow(unused_variables))] builder: &LogicVMBuilder,
+        _builder: &LogicVMBuilder,
     ) -> VMLoadResult<Self> {
         let data = match name {
             MICRO_PROCESSOR | LOGIC_PROCESSOR | HYPER_PROCESSOR | WORLD_PROCESSOR => {
@@ -74,7 +67,7 @@ impl Building {
                     name,
                     position,
                     &ProcessorConfig::parse(config)?,
-                    builder,
+                    _builder,
                 );
                 #[cfg(not(feature = "std"))]
                 panic!("processor config parsing is not supported on no_std");
@@ -199,6 +192,13 @@ impl Building {
     ) -> VMLoadResult<Self> {
         Self::from_config(name, *position, config, builder)
     }
+
+    fn get_block(name: &str) -> VMLoadResult<&'static Block> {
+        content::blocks::FROM_NAME
+            .get(name)
+            .copied()
+            .ok_or_else(|| VMLoadError::UnknownBlockType(name.to_string()))
+    }
 }
 
 impl PartialEq for Building {
diff --git a/src/vm/instructions.rs b/src/vm/instructions.rs
@@ -11,10 +11,11 @@ use num_traits::float::FloatCore;
 use widestring::{U16Str, u16str};
 
 use super::{
-    Constants, LObject, LogicVM, VMLoadError, VMLoadResult, borrow_data,
-    buildings::BuildingData,
-    processor::{MAX_TEXT_BUFFER, ProcessorState},
-    variables::{Content, F64_DEG_RAD, F64_RAD_DEG, LString, LValue, LVar, RAD_DEG},
+    BuildingData, Content, LObject, LString, LValue, LVar, LogicVM, ProcessorState, VMLoadError,
+    VMLoadResult,
+    buildings::borrow_data,
+    processor::MAX_TEXT_BUFFER,
+    variables::{Constants, F64_DEG_RAD, F64_RAD_DEG, RAD_DEG},
 };
 use crate::{
     parser::ast::{self, ConditionOp, LogicOp, TileLayer},
@@ -24,6 +25,7 @@ use crate::{
         content,
     },
     utils::{RapidHashMap, u16format},
+    vm::variables::VariableIndex,
 };
 
 const MAX_IPT: i32 = 1000;
@@ -127,11 +129,15 @@ impl InstructionBuilder {
                     .or_else(|| globals.get(&name))
                     .cloned()
                     // then see if there's already a variable with this name
-                    .or_else(|| variables.get_index_of(&name).map(LVar::Variable))
+                    .or_else(|| {
+                        variables
+                            .get_index_of(&name)
+                            .map(|i| LVar::Variable(VariableIndex(i)))
+                    })
                     // if none of those exist, create a new variable defaulting to null
                     .unwrap_or_else(|| {
                         let (i, _) = variables.insert_full(name, LValue::NULL);
-                        LVar::Variable(i)
+                        LVar::Variable(VariableIndex(i))
                     })
             }
             ast::Value::String(value) => LVar::Constant(value.into()),
diff --git a/src/vm/mod.rs b/src/vm/mod.rs
@@ -5,15 +5,21 @@ use std::time::Instant;
 
 use thiserror::Error;
 
-pub use self::{buildings::*, processor::*, variables::*};
+use self::variables::Constants;
+pub use self::{
+    buildings::{Building, BuildingData, CustomBuildingData},
+    instructions::InstructionResult,
+    processor::{InstructionHook, Processor, ProcessorBuilder, ProcessorState},
+    variables::{Content, LObject, LString, LValue, LVar},
+};
 #[cfg(feature = "std")]
 use crate::types::{Schematic, SchematicTile};
 use crate::{types::PackedPoint2, utils::RapidHashMap};
 
-mod buildings;
+pub mod buildings;
 pub mod instructions;
 mod processor;
-mod variables;
+pub mod variables;
 
 const MILLIS_PER_SEC: u64 = 1_000;
 const NANOS_PER_MILLI: u32 = 1_000_000;
@@ -50,6 +56,12 @@ impl LogicVM {
         builder.build()
     }
 
+    pub fn from_buildings(buildings: impl IntoIterator<Item = Building>) -> VMLoadResult<Self> {
+        let mut builder = LogicVMBuilder::new();
+        builder.add_buildings(buildings);
+        builder.build()
+    }
+
     pub fn building(&self, position: PackedPoint2) -> Option<&Building> {
         self.buildings_map
             .get(&position)
@@ -154,10 +166,7 @@ impl LogicVMBuilder {
         };
     }
 
-    pub fn add_buildings<T>(&mut self, buildings: T)
-    where
-        T: IntoIterator<Item = Building>,
-    {
+    pub fn add_buildings(&mut self, buildings: impl IntoIterator<Item = Building>) {
         for building in buildings.into_iter() {
             self.add_building(building);
         }
@@ -269,11 +278,10 @@ mod tests {
     use pretty_assertions::assert_eq;
     use widestring::u16str;
 
-    use super::LogicVMBuilder;
+    use super::*;
     use crate::{
         parser::ast,
         types::{PackedPoint2, content},
-        vm::{Building, BuildingData, LObject, LVar, processor::ProcessorBuilder},
     };
 
     #[test]
@@ -370,9 +378,12 @@ mod tests {
     use widestring::{U16Str, U16String, u16str};
 
     use super::{
-        buildings::{LOGIC_PROCESSOR, WORLD_PROCESSOR},
-        instructions::{Instruction, InstructionResult},
-        processor::Processor,
+        buildings::{
+            HYPER_PROCESSOR, LOGIC_PROCESSOR, MEMORY_BANK, MEMORY_CELL, MESSAGE, MICRO_PROCESSOR,
+            SWITCH, WORLD_CELL, WORLD_PROCESSOR,
+        },
+        instructions::Instruction,
+        variables::Constants,
         *,
     };
     use crate::{
@@ -381,13 +392,6 @@ mod tests {
             Team, colors::COLORS, content,
         },
         utils::u16format,
-        vm::{
-            buildings::{
-                HYPER_PROCESSOR, MEMORY_BANK, MEMORY_CELL, MESSAGE, MICRO_PROCESSOR, SWITCH,
-                WORLD_CELL,
-            },
-            variables::{Content, LValue, LVar},
-        },
     };
 
     fn single_processor_vm(name: &str, code: &str) -> LogicVM {
diff --git a/src/vm/processor.rs b/src/vm/processor.rs
@@ -13,14 +13,13 @@ use itertools::Itertools;
 #[allow(unused_imports)]
 use num_traits::float::FloatCore;
 use replace_with::replace_with_or_default_and_return;
-use thiserror::Error;
 use widestring::{U16Str, U16String};
 
 use super::{
-    BuildingData, Constants, LValue, LogicVM, LogicVMBuilder, VMLoadError, VMLoadResult,
-    buildings::Building,
-    instructions::{Instruction, InstructionBuilder, InstructionResult, InstructionTrait, Noop},
-    variables::{LVar, Variables},
+    Building, BuildingData, InstructionResult, LValue, LVar, LogicVM, LogicVMBuilder, VMLoadError,
+    VMLoadResult,
+    instructions::{Instruction, InstructionBuilder, InstructionTrait, Noop},
+    variables::{Constants, Variables},
 };
 #[cfg(feature = "std")]
 use crate::parser::LogicParser;
@@ -211,12 +210,6 @@ impl Processor {
     }
 }
 
-#[derive(Debug, Error)]
-pub enum SetVariableError {
-    #[error("Variable not found.")]
-    NotFound,
-}
-
 #[derive(Debug, Clone)]
 pub struct ProcessorState {
     enabled: bool,
@@ -241,7 +234,7 @@ pub struct ProcessorState {
     pub printbuffer: U16String,
 
     pub(super) locals: Constants,
-    pub variables: Variables,
+    pub(super) variables: Variables,
 }
 
 impl ProcessorState {
@@ -325,26 +318,21 @@ impl ProcessorState {
 
     // these aren't used internally, so don't bother inlining
 
-    /// Checks if a variable or local constant exists.
+    /// Checks if a variable exists in this processor.
     pub fn has_variable(&self, name: &U16Str) -> bool {
         self.variables.contains_key(name) || self.locals.contains_key(name)
     }
 
-    /// Looks up a variable or local constant by name.
+    /// Looks up a variable by name in this processor.
     pub fn variable<'a>(&'a self, name: &U16Str) -> Option<Cow<'a, LValue>> {
-        self.variables
-            .get(name)
-            .map(Cow::Borrowed)
-            .or_else(|| self.locals.get(name).map(|v| v.get(self)))
+        self.variables.get(name).map(Cow::Borrowed)
     }
 
-    pub fn set_variable(&mut self, name: &U16Str, value: LValue) -> Result<(), SetVariableError> {
-        if self.variables.contains_key(name) {
-            self.variables[name] = value;
-            Ok(())
-        } else {
-            Err(SetVariableError::NotFound)
-        }
+    /// Sets the value of an existing variable in this processor.
+    ///
+    /// ***Panics*** if the variable does not exist.
+    pub fn set_variable(&mut self, name: &U16Str, value: LValue) {
+        self.variables[name] = value;
     }
 }
 
diff --git a/src/vm/variables.rs b/src/vm/variables.rs
