Optimizations

utxo/src/filter_expr/compiler.rs

@@ -70,22 +70,25 @@ impl<'a> Compiler<'a> {
                         return_value = term_return_value;
                     }
                     ExprOp::Eq => {
-                        let last_value = self.next_register();
                         let mut iter = compiled_terms.into_iter();
-                        let (mut term_opcodes, return_from_expr) =
+                        let (mut term_opcodes, last_value) =
                             iter.next().ok_or(Error::MissingNextRule)?;
 
                         opcodes.append(&mut term_opcodes);
-                        opcodes.push(OpCode::MOV(last_value, return_from_expr));
-
-                        for (mut term_opcodes, term_return) in iter {
-                            opcodes.append(&mut term_opcodes);
-                            opcodes.push(OpCode::EQ(return_value, last_value, term_return));
-                            opcodes.push(OpCode::JNE(return_value, exit_label));
-                            opcodes.push(OpCode::MOV(last_value, term_return));
+                        if iter
+                            .map(|(mut term_codes, term_return)| {
+                                opcodes.append(&mut term_codes);
+                                opcodes.push(OpCode::EQ(return_value, last_value, term_return));
+                                opcodes.push(OpCode::JNE(return_value, exit_label));
+                                1
+                            })
+                            .sum::<usize>()
+                            == 0
+                        {
+                            return Err(Error::MissingNextRule);
                         }
 
-                        opcodes.push(OpCode::LOAD(return_value, true.into()));
+                        let _ = opcodes.pop();
                     }
                     ExprOp::Add | ExprOp::Mul | ExprOp::Div | ExprOp::Sub => {
                         let mut iter = compiled_terms.into_iter();

utxo/src/filter_expr/filter.rs

@@ -0,0 +1,133 @@
+use super::{
+    compiler::Compiler,
+    expr::{Expr, ExprOp, Variable},
+    opcode::OpCode,
+    parser::{parse_query, Query},
+    runtime::execute,
+    value::{Value, ValueOrRef},
+    Addr, Error, Register,
+};
+use crate::Transaction;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct Filter {
+    /// Query
+    query: Query,
+    /// List of external variables
+    variables: Vec<Variable>,
+    /// Debug op-codes, with the unresolved labels.
+    raw_opcodes: Vec<OpCode>,
+    /// The list of opcodes that make up the program
+    opcodes: Vec<OpCode>,
+    /// If the program has some boilerplate that can be skipped. This is non-zero when the initial
+    /// program has been executed at compile time, and the register has been populated to
+    /// `initial_register`. Everytime a new Runtime is created, instead of executing the program,
+    /// it can safely start-off a different Address, and clone the initial_register.
+    start_at: Addr,
+    /// The state of the register
+    initial_register: Vec<Value>,
+}
+
+impl Filter {
+    pub fn new(code: &str) -> Result<Self, Error> {
+        let query = parse_query(code)?;
+        let opcodes = query.where_clause.as_ref().map_or_else(
+            || {
+                Ok(vec![
+                    OpCode::LOAD(0.into(), true.into()),
+                    OpCode::HLT(0.into()),
+                ])
+            },
+            |expr| Compiler::new(expr).compile(),
+        )?;
+
+        Ok(Self {
+            query,
+            raw_opcodes: opcodes.clone(),
+            variables: opcodes
+                .iter()
+                .filter_map(|x| match x {
+                    OpCode::LOAD_EXTERNAL(_, name) => Some(name.clone()),
+                    _ => None,
+                })
+                .collect(),
+            opcodes: Compiler::resolve_label_to_addr(opcodes)?,
+            start_at: 0.into(),
+            initial_register: vec![],
+        })
+    }
+
+    /// Optimize the raw opcode to remove any unnecessary instructions
+    pub fn optimize(mut self) -> Self {
+        todo!()
+    }
+
+    /// Returns a human readable version of the compiled program (generated op-codes)
+    pub fn debug(&self) -> String {
+        self.raw_opcodes
+            .iter()
+            .map(|x| match x {
+                OpCode::HLT(_) | OpCode::LABEL(_) => x.to_string(),
+                x => format!("\t{}", x.to_string()),
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    pub fn dump(&self) -> String {
+        self.opcodes
+            .iter()
+            .enumerate()
+            .map(|(pos, opcode)| format!("{}: {}", pos, opcode.to_string()))
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    pub fn execute<'a>(
+        &'a self,
+        external_variables: &'a HashMap<Variable, ValueOrRef<'a>>,
+    ) -> Result<Value, Error> {
+        execute(
+            external_variables,
+            &self.opcodes,
+            self.initial_register.clone(),
+            self.start_at,
+        )
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Filter;
+    use crate::filter_expr::{
+        opcode::OpCode,
+        value::{Value, ValueOrRef},
+    };
+
+    #[test]
+    fn parse() {
+        let x = Filter::new(
+            r#"
+            WHERE
+                $foo = 3 + 2 * 3
+        "#,
+        )
+        .unwrap();
+        println!("{}", x.dump());
+
+        let external_variables_1 = vec![("foo".into(), ValueOrRef::Value(0.into()))]
+            .into_iter()
+            .collect();
+
+        let external_variables_2 = vec![("foo".into(), ValueOrRef::Value(9.into()))]
+            .into_iter()
+            .collect();
+
+        let value = x.execute(&external_variables_1).expect("valid execution");
+        assert!(matches!(value, Value::Bool(false)));
+
+        let value = x.execute(&external_variables_2).expect("valid execution");
+        assert!(matches!(value, Value::Bool(true)));
+    }
+}

utxo/src/filter_expr/parser.rs

@@ -137,6 +137,7 @@ fn parse_expr(pair: pest::iterators::Pair<Rule>) -> Result<Expr, Error> {
     })
 }
 
+/// Parses a string a returns a result wrappign a Query struct
 pub fn parse_query(query: &str) -> Result<Query, Error> {
     let pairs = QueryParser::parse(Rule::query, query)?;