lang: reorg imports

Author: tcoratger

crates/leanVm/src/lang/const_expr.rs

@@ -4,7 +4,9 @@ use p3_field::PrimeCharacteristicRing;
 
 use crate::{
     Label,
-    lang::{ConstantValue, F, HighLevelOperation, SimpleExpr, expression::Expression},
+    constant::F,
+    intermediate_bytecode::HighLevelOperation,
+    lang::{constant_value::ConstantValue, expression::Expression, simple_expr::SimpleExpr},
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

crates/leanVm/src/lang/expression.rs

@@ -1,6 +1,10 @@
 use std::fmt;
 
-use crate::lang::{F, HighLevelOperation, SimpleExpr, Var};
+use crate::{
+    constant::F,
+    intermediate_bytecode::HighLevelOperation,
+    lang::{Var, simple_expr::SimpleExpr},
+};
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Expression {

crates/leanVm/src/lang/function.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::lang::{Line, Var};
+use crate::lang::{Var, line::Line};
 
 #[derive(Debug, Clone)]
 pub struct Function {

crates/leanVm/src/lang/line.rs

@@ -0,0 +1,212 @@
+use std::fmt;
+
+use crate::{
+    bytecode::precompiles::Precompile,
+    lang::{Var, boolean::Boolean, expression::Expression},
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Line {
+    Assignment {
+        var: Var,
+        value: Expression,
+    },
+    ArrayAssign {
+        // array[index] = value
+        array: Var,
+        index: Expression,
+        value: Expression,
+    },
+    Assert(Boolean),
+    IfCondition {
+        condition: Boolean,
+        then_branch: Vec<Self>,
+        else_branch: Vec<Self>,
+    },
+    ForLoop {
+        iterator: Var,
+        start: Expression,
+        end: Expression,
+        body: Vec<Self>,
+        unroll: bool,
+    },
+    FunctionCall {
+        function_name: String,
+        args: Vec<Expression>,
+        return_data: Vec<Var>,
+    },
+    FunctionRet {
+        return_data: Vec<Expression>,
+    },
+    Precompile {
+        precompile: Precompile,
+        args: Vec<Expression>,
+        res: Vec<Var>,
+    },
+    Break,
+    Panic,
+    // Hints:
+    Print {
+        line_info: String,
+        content: Vec<Expression>,
+    },
+    MAlloc {
+        var: Var,
+        size: Expression,
+        vectorized: bool,
+    },
+    DecomposeBits {
+        var: Var, // a pointer to 31 field elements, containing the bits of "to_decompose"
+        to_decompose: Expression,
+    },
+}
+
+impl Line {
+    #[allow(clippy::too_many_lines)]
+    pub(crate) fn to_string_with_indent(&self, indent: usize) -> String {
+        let spaces = "    ".repeat(indent);
+        let line_str = match self {
+            Self::Assignment { var, value } => {
+                format!("{var} = {value}")
+            }
+            Self::ArrayAssign {
+                array,
+                index,
+                value,
+            } => {
+                format!("{array}[{index}] = {value}")
+            }
+            Self::Assert(condition) => format!("assert {condition}"),
+            Self::IfCondition {
+                condition,
+                then_branch,
+                else_branch,
+            } => {
+                let then_str = then_branch
+                    .iter()
+                    .map(|line| line.to_string_with_indent(indent + 1))
+                    .collect::<Vec<_>>()
+                    .join("\n");
+
+                let else_str = else_branch
+                    .iter()
+                    .map(|line| line.to_string_with_indent(indent + 1))
+                    .collect::<Vec<_>>()
+                    .join("\n");
+
+                if else_branch.is_empty() {
+                    format!("if {condition} {{\n{then_str}\n{spaces}}}")
+                } else {
+                    format!(
+                        "if {condition} {{\n{then_str}\n{spaces}}} else {{\n{else_str}\n{spaces}}}"
+                    )
+                }
+            }
+            Self::ForLoop {
+                iterator,
+                start,
+                end,
+                body,
+                unroll,
+            } => {
+                let body_str = body
+                    .iter()
+                    .map(|line| line.to_string_with_indent(indent + 1))
+                    .collect::<Vec<_>>()
+                    .join("\n");
+                format!(
+                    "for {} in {}..{} {}{{\n{}\n{}}}",
+                    iterator,
+                    start,
+                    end,
+                    if *unroll { "unroll " } else { "" },
+                    body_str,
+                    spaces
+                )
+            }
+            Self::FunctionCall {
+                function_name,
+                args,
+                return_data,
+            } => {
+                let args_str = args
+                    .iter()
+                    .map(std::string::ToString::to_string)
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                let return_data_str = return_data
+                    .iter()
+                    .map(std::string::ToString::to_string)
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                if return_data.is_empty() {
+                    format!("{function_name}({args_str})")
+                } else {
+                    format!("{return_data_str} = {function_name}({args_str})")
+                }
+            }
+            Self::FunctionRet { return_data } => {
+                let return_data_str = return_data
+                    .iter()
+                    .map(std::string::ToString::to_string)
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("return {return_data_str}")
+            }
+            Self::Precompile {
+                precompile,
+                args,
+                res: return_data,
+            } => {
+                format!(
+                    "{} = {}({})",
+                    return_data
+                        .iter()
+                        .map(std::string::ToString::to_string)
+                        .collect::<Vec<_>>()
+                        .join(", "),
+                    precompile.name,
+                    args.iter()
+                        .map(std::string::ToString::to_string)
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Self::Print {
+                line_info: _,
+                content,
+            } => {
+                let content_str = content
+                    .iter()
+                    .map(std::string::ToString::to_string)
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("print({content_str})")
+            }
+            Self::MAlloc {
+                var,
+                size,
+                vectorized,
+            } => {
+                if *vectorized {
+                    format!("{var} = malloc_vectorized({size})")
+                } else {
+                    format!("{var} = malloc({size})")
+                }
+            }
+            Self::DecomposeBits { var, to_decompose } => {
+                format!("{var} = decompose_bits({to_decompose})")
+            }
+            Self::Break => "break".to_string(),
+            Self::Panic => "panic".to_string(),
+        };
+        format!("{spaces}{line_str}")
+    }
+}
+
+impl fmt::Display for Line {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.to_string_with_indent(0))
+    }
+}