intermediate bytecode: mv intermediate value

Author: tcoratger

crates/leanVm/src/bytecode/operation.rs

@@ -2,7 +2,7 @@ use std::fmt;
 
 use p3_field::Field;
 
-use crate::constant::F;
+use crate::{constant::F, intermediate_bytecode::HighLevelOperation};
 
 /// The basic arithmetic operations supported by the VM's `Computation` instruction.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -58,6 +58,18 @@ impl Operation {
     }
 }
 
+impl TryFrom<HighLevelOperation> for Operation {
+    type Error = String;
+
+    fn try_from(value: HighLevelOperation) -> Result<Self, Self::Error> {
+        match value {
+            HighLevelOperation::Add => Ok(Self::Add),
+            HighLevelOperation::Mul => Ok(Self::Mul),
+            _ => Err(format!("Cannot convert {value:?} to +/x")),
+        }
+    }
+}
+
 impl fmt::Display for Operation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

crates/leanVm/src/intermediate_bytecode/intermediate_value.rs

@@ -0,0 +1,38 @@
+use std::fmt;
+
+use crate::lang::{ConstExpression, Label};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum IntermediateValue {
+    Constant(ConstExpression),
+    Fp,
+    MemoryAfterFp { offset: ConstExpression }, // m[fp + offset]
+}
+
+impl IntermediateValue {
+    #[must_use]
+    pub const fn label(label: Label) -> Self {
+        Self::Constant(ConstExpression::label(label))
+    }
+
+    #[must_use]
+    pub const fn is_constant(&self) -> bool {
+        matches!(self, Self::Constant(_))
+    }
+}
+
+impl From<ConstExpression> for IntermediateValue {
+    fn from(value: ConstExpression) -> Self {
+        Self::Constant(value)
+    }
+}
+
+impl fmt::Display for IntermediateValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Constant(value) => write!(f, "{value}"),
+            Self::Fp => write!(f, "fp"),
+            Self::MemoryAfterFp { offset } => write!(f, "m[fp + {offset}]"),
+        }
+    }
+}

…ates/leanVm/src/intermediate_bytecode.rs …/leanVm/src/intermediate_bytecode/mod.rscrates/leanVm/src/intermediate_bytecode.rs renamed to crates/leanVm/src/intermediate_bytecode/mod.rs crates/leanVm/src/intermediate_bytecode.rs renamed to crates/leanVm/src/intermediate_bytecode/mod.rs

@@ -8,55 +8,22 @@ use crate::{
     lang::{Label, const_expr::ConstExpression},
 };
 
+pub mod intermediate_value;
+pub use intermediate_value::*;
+
 #[derive(Debug, Clone)]
 pub struct IntermediateBytecode {
     pub bytecode: BTreeMap<Label, Vec<IntermediateInstruction>>,
     pub memory_size_per_function: BTreeMap<String, usize>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum IntermediateValue {
-    Constant(ConstExpression),
-    Fp,
-    MemoryAfterFp { offset: ConstExpression }, // m[fp + offset]
-}
-
-impl From<ConstExpression> for IntermediateValue {
-    fn from(value: ConstExpression) -> Self {
-        Self::Constant(value)
-    }
-}
-impl TryFrom<HighLevelOperation> for Operation {
-    type Error = String;
-
-    fn try_from(value: HighLevelOperation) -> Result<Self, Self::Error> {
-        match value {
-            HighLevelOperation::Add => Ok(Self::Add),
-            HighLevelOperation::Mul => Ok(Self::Mul),
-            _ => Err(format!("Cannot convert {value:?} to +/x")),
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum IntermediaryMemOrFpOrConstant {
     MemoryAfterFp { offset: ConstExpression }, // m[fp + offset]
     Fp,
     Constant(ConstExpression),
 }
 
-impl IntermediateValue {
-    #[must_use]
-    pub const fn label(label: Label) -> Self {
-        Self::Constant(ConstExpression::label(label))
-    }
-
-    #[must_use]
-    pub const fn is_constant(&self) -> bool {
-        matches!(self, Self::Constant(_))
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum HighLevelOperation {
     Add,
@@ -193,16 +160,6 @@ impl IntermediateInstruction {
     }
 }
 
-impl fmt::Display for IntermediateValue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Constant(value) => write!(f, "{value}"),
-            Self::Fp => write!(f, "fp"),
-            Self::MemoryAfterFp { offset } => write!(f, "m[fp + {offset}]"),
-        }
-    }
-}
-
 impl fmt::Display for IntermediaryMemOrFpOrConstant {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {