Add ability to jump

utxo/src/filter_expr/mod.rs

@@ -2,6 +2,7 @@
 
 #![allow(warnings)]
 
+mod expr;
 mod opcode;
 mod parser;
 mod program;
@@ -42,6 +43,9 @@ pub enum Error {
 
     #[error("Invalid order: {0}")]
     InvalidOrder(String),
+
+    #[error("Unknown label: {0}")]
+    UnknownLabel(usize),
 }
 
 use std::num::ParseIntError;

utxo/src/filter_expr/opcode.rs

@@ -1,34 +1,178 @@
 use super::{value::Value, Addr, Register};
 
 #[derive(Clone, Debug, PartialEq)]
+/// OpCode for a register based virtual machine
+///
+/// The OpCode is a simple enum that represents the operations that can be performed on the register
+/// based Virtual Machine.
 pub enum OpCode {
+    // Data Movement Instructions
     /// LOAD <destination> <value>
+    /// Load a value into a register.
     LOAD(Register, Value),
-    /// Copy the value from the source register to the destination register
+
+    /// Request an external source for a given information
+    /// LOAD <destination> <value>
+    /// Load the <value> variable name from an external source which is unknown at compile time.
+    /// The value is stored in the given register
+    LOAD_EXTERNAL(Register, Value),
+
     /// CPY <destination> <source>
+    /// Copy the value from the source register to the destination register.
     CPY(Register, Register),
-    /// Move the value from the source register to the destination register
+
     /// MOV <destination> <source>
+    /// Move the value from the source register to the destination register.
     MOV(Register, Register),
-    /// Compare two registers and store the result in the destination register
-    /// CMP <destination> <source1> <source2>
-    CMP(Register, Register, Register),
+
+    // Arithmetic Operations
     /// ADD <destination> <source1> <source2>
+    /// Add the values in source1 and source2, store the result in destination.
     ADD(Register, Register, Register),
-    /// ADD <destination> <source1> <source2>
+
+    /// SUB <destination> <source1> <source2>
+    /// Subtract the value in source2 from the value in source1, store the result in destination.
+    SUB(Register, Register, Register),
+
+    /// MUL <destination> <source1> <source2>
+    /// Multiply the values in source1 and source2, store the result in destination.
+    MUL(Register, Register, Register),
+
+    /// DIV <destination> <source1> <source2>
+    /// Divide the value in source1 by the value in source2, store the result in destination.
+    DIV(Register, Register, Register),
+
+    /// MOD <destination> <source1> <source2>
+    /// Calculate the remainder of source1 divided by source2, store the result in destination.
+    MOD(Register, Register, Register),
+
+    /// NEG <destination> <source>
+    /// Negate the value in the source register, store the result in destination.
+    NEG(Register, Register),
+
+    // Logical Operations
+    /// AND <destination> <source1> <source2>
+    /// Perform a bitwise AND on the values in source1 and source2, store the result in
+    /// destination.
     AND(Register, Register, Register),
+
+    /// OR <destination> <source1> <source2>
+    /// Perform a bitwise OR on the values in source1 and source2, store the result in destination.
     OR(Register, Register, Register),
+
+    /// XOR <destination> <source1> <source2>
+    /// Perform a bitwise XOR on the values in source1 and source2, store the result in
+    /// destination.
     XOR(Register, Register, Register),
+
+    /// NOT <destination> <source>
+    /// Perform a bitwise NOT on the value in the source register, store the result in destination.
     NOT(Register, Register),
+
+    /// SHL <destination> <source> <value>
+    /// Shift the value in the source register left by the specified number of bits, store the
+    /// result in destination.
+    SHL(Register, Register, Value),
+
+    /// SHR <destination> <source> <value>
+    /// Shift the value in the source register right by the specified number of bits, store the
+    /// result in destination.
+    SHR(Register, Register, Value),
+
+    /// EQ <destination> <source1> <source2>
+    /// Check if source1 is equal to source2, store the result in destination (1 if true, 0 if
+    /// false).
+    EQ(Register, Register, Register),
+
+    /// NE <destination> <source1> <source2>
+    /// Check if source1 is not equal to source2, store the result in destination (1 if true, 0 if
+    /// false).
+    NE(Register, Register, Register),
+
+    /// LT <destination> <source1> <source2>
+    /// Check if source1 is less than source2, store the result in destination (1 if true, 0 if
+    /// false).
+    LT(Register, Register, Register),
+
+    /// LE <destination> <source1> <source2>
+    /// Check if source1 is less than or equal to source2, store the result in destination (1 if
+    /// true, 0 if false).
+    LE(Register, Register, Register),
+
+    /// GT <destination> <source1> <source2>
+    /// Check if source1 is greater than source2, store the result in destination (1 if true, 0 if
+    /// false).
+    GT(Register, Register, Register),
+
+    /// GE <destination> <source1> <source2>
+    /// Check if source1 is greater than or equal to source2, store the result in destination (1 if
+    /// true, 0 if false).
+    GE(Register, Register, Register),
+
+    // Branching Operations
+    /// JLABEL <address>
+    /// Adds a label to the this part of the code
+    LABEL(Addr),
+
     /// JMP <address>
+    /// Jump to the specified address. Addresses are custom tags through a LABEL.
     JMP(Addr),
+
     /// JEQ <register> <address>
-    ///
-    /// Jumps if the value in the register is true
+    /// Jump to the address if the value in the register is true (non-zero).
     JEQ(Register, Addr),
+
     /// JNE <register> <address>
-    ///
-    /// Jumps if the value in the register is false
+    /// Jump to the address if the value in the register is false (zero).
     JNE(Register, Addr),
-    HLT,
+
+    // Stack Operations
+    /// PUSH <register>
+    /// Push the value in the register onto the stack.
+    PUSH(Register),
+
+    /// POP <register>
+    /// Pop the value from the stack into the register.
+    POP(Register),
+
+    // Control Operation
+    /// HLT
+    /// Halt the execution.
+    HLT(Register),
+}
+
+impl ToString for OpCode {
+    fn to_string(&self) -> String {
+        match self {
+            OpCode::LOAD(r, v) => format!("LOAD {} {:?}", r, v),
+            OpCode::LOAD_EXTERNAL(r, v) => format!("LOAD_EXTERNAL {} {:?}", r, v),
+            OpCode::CPY(r1, r2) => format!("CPY {} {}", r1, r2),
+            OpCode::MOV(r1, r2) => format!("MOV {} {}", r1, r2),
+            OpCode::ADD(r1, r2, r3) => format!("ADD {} {} {}", r1, r2, r3),
+            OpCode::SUB(r1, r2, r3) => format!("SUB {} {} {}", r1, r2, r3),
+            OpCode::MUL(r1, r2, r3) => format!("MUL {} {} {}", r1, r2, r3),
+            OpCode::DIV(r1, r2, r3) => format!("DIV {} {} {}", r1, r2, r3),
+            OpCode::MOD(r1, r2, r3) => format!("MOD {} {} {}", r1, r2, r3),
+            OpCode::NEG(r1, r2) => format!("NEG {} {}", r1, r2),
+            OpCode::AND(r1, r2, r3) => format!("AND {} {} {}", r1, r2, r3),
+            OpCode::OR(r1, r2, r3) => format!("OR {} {} {}", r1, r2, r3),
+            OpCode::XOR(r1, r2, r3) => format!("XOR {} {} {}", r1, r2, r3),
+            OpCode::NOT(r1, r2) => format!("NOT {} {}", r1, r2),
+            OpCode::SHL(r1, r2, v) => format!("SHL {} {} {:?}", r1, r2, v),
+            OpCode::SHR(r1, r2, v) => format!("SHR {} {} {:?}", r1, r2, v),
+            OpCode::EQ(r1, r2, r3) => format!("EQ {} {} {}", r1, r2, r3),
+            OpCode::NE(r1, r2, r3) => format!("NE {} {} {}", r1, r2, r3),
+            OpCode::LT(r1, r2, r3) => format!("LT {} {} {}", r1, r2, r3),
+            OpCode::LE(r1, r2, r3) => format!("LE {} {} {}", r1, r2, r3),
+            OpCode::GT(r1, r2, r3) => format!("GT {} {} {}", r1, r2, r3),
+            OpCode::GE(r1, r2, r3) => format!("GE {} {} {}", r1, r2, r3),
+            OpCode::LABEL(a) => format!("LABEL {}:", a),
+            OpCode::JMP(a) => format!("JMP {}", a),
+            OpCode::JEQ(r, a) => format!("JEQ {} {}", r, a),
+            OpCode::JNE(r, a) => format!("JNE {} {}", r, a),
+            OpCode::PUSH(r) => format!("PUSH {}", r),
+            OpCode::POP(r) => format!("POP {}", r),
+            OpCode::HLT(r) => format!("HLT {}", r),
+        }
+    }
 }

utxo/src/filter_expr/parser.rs

@@ -1,4 +1,7 @@
-use super::Error;
+use super::{
+    expr::{Expr, ExprOp, Order, Variable},
+    Error,
+};
 use pest::{Parser, Span};
 use pest_derive::Parser;
 use std::str::FromStr;
@@ -7,81 +10,11 @@ use std::str::FromStr;
 #[grammar = "src/filter_expr/expr.pest"] // relative path to your .pest file
 struct QueryParser;
 
-#[derive(Clone, PartialEq, Eq, Debug, Copy)]
-pub enum ExprOp {
-    And,
-    Or,
-    Not,
-    Eq,
-    NotEq,
-    Gt,
-    Gte,
-    Lt,
-    Lte,
-    Add,
-    Sub,
-    Mul,
-    Div,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Copy)]
-pub enum Order {
-    Ascending,
-    Descending,
-}
-
-impl FromStr for Order {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "asc" => Ok(Order::Ascending),
-            "desc" => Ok(Order::Descending),
-            s => Err(Error::InvalidOrder(s.to_owned())),
-        }
-    }
-}
-
-impl From<&str> for ExprOp {
-    fn from(s: &str) -> Self {
-        match s.to_lowercase().as_str() {
-            "+" => ExprOp::Add,
-            "-" => ExprOp::Sub,
-            "*" => ExprOp::Mul,
-            "/" => ExprOp::Div,
-            "&&" | "and" => ExprOp::And,
-            "||" | "or" => ExprOp::Or,
-            "!" | "not" => ExprOp::Not,
-            "==" | "=" => ExprOp::Eq,
-            "!=" => ExprOp::NotEq,
-            ">" => ExprOp::Gt,
-            ">=" => ExprOp::Gte,
-            "<" => ExprOp::Lt,
-            "<=" => ExprOp::Lte,
-            x => panic!("{} is not a valid Operation", x),
-        }
-    }
-}
-
-#[derive(Debug)]
-enum Expr {
-    Not(Box<Expr>),
-    Op {
-        op: ExprOp,
-        left: Box<Expr>,
-        right: Box<Expr>,
-    },
-    Variable(Vec<String>),
-    String(String),
-    Ident(String),
-    Number(i128),
-}
-
 #[derive(Debug)]
 pub struct Query {
-    where_clause: Option<Expr>,
-    limit_clause: Option<i128>,
-    order_by_clause: Option<(Expr, Order)>,
+    pub where_clause: Option<Expr>,
+    pub limit_clause: Option<i128>,
+    pub order_by_clause: Option<(Variable, Order)>,
 }
 
 /// Borrowed from https://github.com/pest-parser/pest/blob/master/meta/src/parser.rs#L687C2-L741C2
@@ -188,18 +121,19 @@ fn parse_expr(pair: pest::iterators::Pair<Rule>) -> Result<Expr, Error> {
         }
         Rule::variable => {
             let mut inner = pair.into_inner();
-            let mut first = vec![inner
+            let mut variable: Variable = vec![inner
                 .next()
                 .ok_or(Error::MissingNextRule)?
                 .as_str()
-                .to_owned()];
-            while let Some(Ok(Expr::Ident(ident))) = inner.next().map(parse_expr) {
-                first.push(ident);
+                .to_owned()]
+            .into();
+            while let Some(Ok(Expr::String(ident))) = inner.next().map(parse_expr) {
+                variable.add_part(ident);
             }
-            Expr::Variable(first)
+            Expr::Variable(variable)
         }
         Rule::number => Expr::Number(pair.as_str().parse()?),
-        Rule::ident => Expr::Ident(pair.as_str().to_owned()),
+        Rule::ident => Expr::String(pair.as_str().to_owned()),
         rule => return Err(Error::UnexpectedRule(rule)),
     })
 }
@@ -237,12 +171,17 @@ pub fn parse_query(query: &str) -> Result<Query, Error> {
             }
             Rule::order_by_clause => {
                 let mut iter = pair.into_inner();
-                let expr = iter
+                let expr = match iter
                     .next()
                     .map(parse_expr)
-                    .ok_or(Error::MissingNextRule)??;
+                    .ok_or(Error::MissingNextRule)??
+                {
+                    Expr::Variable(variable) => variable,
+                    _ => unreachable!(),
+                };
+
                 let order = if let Some(order_by_text) = iter.next() {
-                    order_by_text.as_str().to_lowercase().parse()?
+                    order_by_text.as_str().parse()?
                 } else {
                     Order::Ascending
                 };

utxo/src/filter_expr/program.rs

@@ -1,8 +1,19 @@
-use super::{opcode::OpCode, parser::parse_query, runtime::execute, value::Value, Addr, Error};
+use std::collections::HashMap;
+
+use super::{
+    expr::{Expr, ExprOp},
+    opcode::OpCode,
+    parser::parse_query,
+    runtime::execute,
+    value::Value,
+    Addr, Error, Register,
+};
 use crate::Transaction;
 
 #[derive(Debug, Clone)]
 pub struct Program {
+    /// Debug op-codes, with the unresolved labels.
+    dbg_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
@@ -14,13 +25,185 @@ pub struct Program {
     initial_register: Vec<Value>,
 }
 
+pub struct Compiler<'a> {
+    expr: &'a Expr,
+    current_register: Register,
+    labels: Addr,
+}
+
+impl<'a> Compiler<'a> {
+    pub fn new(expr: &'a Expr) -> Self {
+        Self {
+            expr,
+            current_register: 0,
+            labels: 0,
+        }
+    }
+
+    fn next_label(&mut self) -> Addr {
+        self.labels += 1;
+        self.labels
+    }
+
+    fn next_register(&mut self) -> usize {
+        self.current_register += 1;
+        self.current_register
+    }
+
+    fn compile_expr(&mut self, expr: &'a Expr, exit_label: Addr) -> (Vec<OpCode>, usize) {
+        let return_value = self.next_register();
+        match expr {
+            Expr::Variable(name) => (
+                vec![OpCode::LOAD_EXTERNAL(return_value, name.into())],
+                return_value,
+            ),
+            Expr::String(string) => (
+                vec![OpCode::LOAD(return_value, Value::String(string.clone()))],
+                return_value,
+            ),
+            Expr::Number(number) => (
+                vec![OpCode::LOAD(return_value, Value::Number(*number))],
+                return_value,
+            ),
+            Expr::Not(expr) => {
+                let (mut expr, prev_return_value) = self.compile_expr(expr, exit_label);
+                expr.push(OpCode::NOT(return_value, prev_return_value));
+                (expr, return_value)
+            }
+            Expr::Op { op, left, right } => {
+                let mut to_return = vec![];
+                let current_exit_label = self.next_label();
+                let (mut left, return_left) = self.compile_expr(left, current_exit_label);
+                let (mut right, return_right) = self.compile_expr(right, current_exit_label);
+
+                to_return.append(&mut left.clone());
+                to_return.append(&mut right.clone());
+
+                match op {
+                    ExprOp::Eq => {
+                        to_return.push(OpCode::EQ(return_value, return_left, return_right));
+                    }
+                    ExprOp::Add => {
+                        to_return.push(OpCode::ADD(return_value, return_left, return_right))
+                    }
+                    ExprOp::Or => {
+                        to_return = vec![OpCode::LOAD(return_value, Value::Bool(false))];
+                        to_return.append(&mut left);
+                        to_return.push(OpCode::MOV(return_value, return_left));
+                        to_return.push(OpCode::JEQ(return_value, exit_label));
+                        to_return.append(&mut right);
+                        to_return.push(OpCode::OR(return_value, return_left, return_right))
+                    }
+                    ExprOp::And => {
+                        to_return = vec![OpCode::LOAD(return_value, Value::Bool(false))];
+                        to_return.append(&mut left);
+                        to_return.push(OpCode::MOV(return_value, return_left));
+                        to_return.push(OpCode::JNE(return_value, exit_label));
+                        to_return.append(&mut right);
+                        to_return.push(OpCode::AND(return_value, return_left, return_right))
+                    }
+                    ExprOp::Mul => {
+                        to_return.push(OpCode::MUL(return_value, return_left, return_right))
+                    }
+                    ExprOp::Sub => {
+                        to_return.push(OpCode::SUB(return_value, return_left, return_right))
+                    }
+                    x => panic!("unimplemented {:#?}", x),
+                }
+
+                to_return.push(OpCode::LABEL(current_exit_label));
+                (to_return, return_value)
+            }
+        }
+    }
+
+    fn resolve_label_to_addr(opcodes: Vec<OpCode>) -> Result<Vec<OpCode>, Error> {
+        let mut pos = 0;
+        let used_labels = opcodes
+            .iter()
+            .map(|x| match x {
+                OpCode::LABEL(label) => (x, pos),
+                _ => {
+                    pos = pos + 1;
+                    (x, pos - 1)
+                }
+            })
+            .filter_map(|(opcode, pos)| match opcode {
+                OpCode::LABEL(id) => Some((*id, pos)),
+                _ => None,
+            })
+            .collect::<HashMap<_, _>>();
+
+        opcodes
+            .into_iter()
+            .filter(|opcode| !matches!(opcode, OpCode::LABEL(_)))
+            .map(|opcode| {
+                Ok(match opcode {
+                    OpCode::JMP(label) => {
+                        OpCode::JMP(*used_labels.get(&label).ok_or(Error::UnknownLabel(label))?)
+                    }
+                    OpCode::JEQ(register, label) => OpCode::JEQ(
+                        register,
+                        *used_labels.get(&label).ok_or(Error::UnknownLabel(label))?,
+                    ),
+                    OpCode::JNE(register, label) => OpCode::JNE(
+                        register,
+                        *used_labels.get(&label).ok_or(Error::UnknownLabel(label))?,
+                    ),
+                    x => x,
+                })
+            })
+            .collect()
+    }
+
+    pub fn compile(mut self) -> Vec<OpCode> {
+        let exit_point = self.next_label();
+        let (mut opcodes, return_value) = self.compile_expr(self.expr, exit_point);
+        opcodes.push(OpCode::LABEL(exit_point));
+        opcodes.push(OpCode::HLT(return_value));
+        opcodes
+    }
+}
+
 impl Program {
     pub fn new(code: &str) -> Result<Self, Error> {
-        let ast = parse_query(code);
-        panic!("{:#?}", ast);
-        todo!()
+        let ast = parse_query(code)?;
+
+        let opcodes = ast.where_clause.map_or_else(
+            || vec![OpCode::LOAD(0, true.into()), OpCode::HLT(0)],
+            |expr| Compiler::new(&expr).compile(),
+        );
+
+        Ok(Self {
+            dbg_opcodes: opcodes.clone(),
+            opcodes: Compiler::resolve_label_to_addr(opcodes)?,
+            start_at: 0,
+            initial_register: vec![],
+        })
+    }
+
+    /// Returns a human readable version of the compiled program (generated op-codes)
+    pub fn debug(&self) -> String {
+        self.dbg_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")
+    }
+
+    /// Returns the opcodes of the program expression and the usize of the register where the result
     /// Creates a program tailored for a transaction
     pub fn execute(&self, transaction: Option<&Transaction>) -> Result<Value, Error> {
         execute(
@@ -44,22 +227,25 @@ mod test {
             WHERE
                 $foo = 3
                 AND $bar = "bar"
+                AND ($a = $b OR $b = $c)
                 AND $foo = 1 + 2 + 3 +  ((1+ 2-3*4-5) * $bar.tx.lol)
             ORDER BY $bar DESC
         "#,
-        );
+        )
+        .unwrap();
+        panic!("{}\n\n{}", x.debug(), x.dump());
     }
 
     #[test]
     fn simple_program() {
         let program = Program {
+            dbg_opcodes: vec![],
             opcodes: vec![
                 OpCode::LOAD(1, 12.into()),
                 OpCode::LOAD(2, 13.into()),
                 OpCode::ADD(3, 1, 2),
                 OpCode::ADD(4, 0, 3),
-                OpCode::MOV(0, 4),
-                OpCode::HLT,
+                OpCode::HLT(4),
             ],
             start_at: 0,
             initial_register: vec![15.into()],

utxo/src/filter_expr/runtime.rs

@@ -99,11 +99,6 @@ pub fn execute(
                 let previous_value = std::mem::replace(&mut registers[*reg2], Value::Nil.into());
                 set!(registers, *dst, previous_value);
             }
-            OpCode::CMP(dst, reg2, reg3) => {
-                let new_value =
-                    Value::Bool(get!(registers, *reg2) == get!(registers, *reg3)).into();
-                set!(registers, *dst, new_value);
-            }
             OpCode::ADD(dst, a, b) => {
                 let new_value = get!(registers, *a)
                     .checked_add(get!(registers, *b))
@@ -144,14 +139,15 @@ pub fn execute(
                     continue;
                 }
             }
-            OpCode::HLT => break,
+            OpCode::HLT(return_register) => {
+                return registers
+                    .remove(*return_register)
+                    .map(|x| x.into())
+                    .ok_or(Error::EmptyRegisters)
+            }
+            _ => todo!(),
         }
 
         execution += 1;
     }
-
-    registers
-        .pop_front()
-        .map(|x| x.into())
-        .ok_or(Error::EmptyRegisters)
 }

utxo/src/filter_expr/value.rs

@@ -6,6 +6,8 @@ use chrono::{DateTime, Utc};
 use num::CheckedAdd;
 use std::ops::Add;
 
+use super::expr::{Expr, Variable};
+
 #[derive(Clone, Debug, PartialEq, PartialOrd)]
 pub enum Value {
     Nil,
@@ -24,6 +26,19 @@ pub enum Value {
     To(Vec<PaymentTo>),
     Tags(Vec<Tag>),
     Bool(bool),
+    Variable(Vec<String>),
+}
+
+impl From<&Variable> for Value {
+    fn from(value: &Variable) -> Self {
+        Self::Variable(value.to_vec())
+    }
+}
+
+impl From<bool> for Value {
+    fn from(x: bool) -> Self {
+        Value::Bool(x)
+    }
 }
 
 impl From<i128> for Value {