parse expressions, while blocks, conditionals

Author: Nikil-Shyamsunder

src/ir.rs

@@ -51,8 +51,8 @@ impl Transaction {
     }
 
     /// add a new statement to the transaction
-    pub fn s(&mut self, expr: Stmt) -> StmtId {
-        self.stmts.push(expr)
+    pub fn s(&mut self, stmt: Stmt) -> StmtId {
+        self.stmts.push(stmt)
     }
 
     pub fn expr_dont_care(&self) -> ExprId {
@@ -288,6 +288,16 @@ impl SymbolTable {
         id
     }
 
+    pub fn symbol_id_from_name(&self, name: &str) -> Option<SymbolId> {
+        self.entries.iter().find_map(|(id, entry)| {
+            if entry.name == name {
+                Some(id)
+            } else {
+                None
+            }
+        })
+    }
+
     pub fn add_with_parent(&mut self, name: String, parent: SymbolId) -> SymbolId {
         assert!(
             !name.contains('.'),

src/parser.rs

@@ -7,7 +7,7 @@ use pest::Parser;
 use pest_derive::Parser;
 use pest::pratt_parser::PrattParser;
 use pest::iterators::Pairs;
-use std::fmt;
+use std::{fmt, process::id, vec};
 use baa::BitVecValue;
 
 use crate::{ir::*};
@@ -29,41 +29,63 @@ lazy_static::lazy_static! {
     };
 }
 
-// pub fn parse_expr(pairs: Pairs<Rule>) ->  Expr {
-//     PRATT_PARSER
-//         .map_primary(|primary| match primary.as_rule() {
-//             Rule::integer => {
-//                 let int_str = primary.as_str();
-//                 let int_value = int_str.parse::<i32>().unwrap();
-//                 // FIXME: Is this the correct way to convert?
-//                 let bitvec = BitVecValue::from_u64(int_value as u64, 32);
-//                 Expr::Const(bitvec)
-//             }
-//             // if primary is an expression (due to parens), recursively parse its inner constituents
-//             Rule::expr => parse_expr(primary.into_inner()),
-//             rule => unreachable!("Expr::parse expected atom, found {:?}", rule)
-//         })
-//         .map_infix(|lhs, op, rhs| {
-//             let op = match op.as_rule() {
-//                 Rule::eq => BinOp::Equal,
-//                 Rule::log_and => BinOp::And,
-//                 rule => unreachable!("Expr::parse expected infix operation, found {:?}", rule),
-//             };
-//             Expr::Binary {
-//                 op,
-//                 lhs: lhs.
-//                 rhs: Box::new(rhs),
-//             }
-//         })
-//         .map_prefix(|op, arg| {
-//             let op = match op.as_rule() {
-//                 Rule::negate => UnaryOperator::Negate,
-//                 rule => unreachable!("Expr::parse expected prefix operation, found {:?}", rule),
-//             };
-//             Expr::UnaryOp {arg: Box::new(arg) , op: op }
-//         })
-//         .parse(pairs)
-// }
+pub fn parse_expr(pairs: Pairs<Rule>, tr: &mut Transaction, st : &mut SymbolTable) ->  ExprId {
+    PRATT_PARSER
+        .map_primary(|primary| match primary.as_rule() {
+
+            // parse integer literals
+            Rule::integer => {
+                let int_str = primary.as_str();
+                let int_value = int_str.parse::<i32>().unwrap();
+                // FIXME: Is this the correct way to convert?
+                let bitvec = BitVecValue::from_u64(int_value as u64, 32);
+                tr.e(Expr::Const(bitvec))
+            }
+
+            // parse path identifiers
+            Rule::path_id => {
+                let path_id = primary.as_str();
+                let symbol_id = SymbolTable::symbol_id_from_name(st, path_id);
+                match symbol_id {
+                    Some(id) => tr.e(Expr::Sym(id)),
+                    None => panic!("Referencing undefined symbol: {}", path_id),
+                }
+            }
+
+            // if primary is an expression (due to parens), recursively parse its inner constituents
+            Rule::expr => parse_expr(primary.into_inner(), tr, st),
+            rule => unreachable!("Expr::parse expected atom, found {:?}", rule)
+        })
+
+        // FIXME: two closures require unique access to `*tr` at the same time
+        // Parse binary expressions
+        .map_infix(|lhs, op, rhs| {
+            let op = match op.as_rule() {
+                Rule::eq => BinOp::Equal,
+                Rule::log_and => BinOp::And,
+                rule => unreachable!("Expr::parse expected infix operation, found {:?}", rule),
+            };
+            let bin_expression = Expr::Binary(
+                op,
+                lhs,
+                rhs
+            );
+            tr.e(bin_expression)
+        })
+
+        // Parse unary expressions
+        .map_prefix(|op, arg| {
+            let op = match op.as_rule() {
+                Rule::not => UnaryOp::Not,
+                rule => unreachable!("Expr::parse expected prefix operation, found {:?}", rule),
+            };
+            let unary_expression = Expr::Unary(op, arg);
+            tr.e(unary_expression)
+        })
+        .parse(pairs)
+}
+
+
 // fn build_ir(pair: pest::iterators::Pair<Rule>) -> (Transaction, SymbolTable) {
 //     match pair.as_rule() {
 //         Rule::file => {
@@ -93,25 +115,138 @@ lazy_static::lazy_static! {
 //     }
 // }
 
-fn build_transaction(pair: pest::iterators::Pair<Rule>, sym : &mut SymbolTable) -> Transaction {
+fn build_struct(pair : pest::iterators::Pair<Rule>, st : &mut SymbolTable) -> StructId {
+    let mut inner_rules = pair.into_inner();
+    let struct_id = inner_rules.next().unwrap().as_str();
+
+    let pins = build_fields(inner_rules.next().unwrap(), st);
+
+    st.add_struct(struct_id.to_string(), pins)
+}
+
+fn build_transaction(pair: pest::iterators::Pair<Rule>, st : &mut SymbolTable) -> Transaction {
     match pair.as_rule() {
         Rule::fun => {
             let mut inner_rules = pair.into_inner();
             let id_pair = inner_rules.next().unwrap();
             let id = id_pair.as_str();
-            let mut trans = Transaction::new(id.to_string());
-            trans.args = build_arglist(inner_rules.next().unwrap(), sym);
-            // Process the rest of the inner rules if needed
-            for inner_pair in inner_rules {
-                // Handle other inner pairs
+            let mut tr = Transaction::new(id.to_string());
+            tr.args = build_arglist(inner_rules.next().unwrap(), st);
+
+            // Process the body of statements, adding them to the block as we go
+            while let Some(inner_pair) = inner_rules.next() {
+                match inner_pair.as_rule() {
+                    Rule::assign => {
+                        let stmt = parse_assign(inner_pair, tr, st);
+                        tr.s(stmt);
+                    }
+                    Rule::cmd => {
+                        let stmt = parse_cmd(inner_pair, tr, st);
+                        tr.s(stmt);
+                    }
+                    Rule::while_loop => {
+                        let stmt = parse_while(inner_pair, tr, st);
+                        tr.s(stmt);
+                    }
+                    Rule::cond => {
+                        let stmt = parse_cond(inner_pair, tr, st);
+                        tr.s(stmt);
+                    }
+                    _ => panic!("Unexpected rule: {:?}", inner_pair.as_rule()),
+                }
             }
-            trans
+            println!("Transaction: {:?}", tr);
+            tr
         }
         _ => panic!("Unexpected rule: {:?}", pair.as_rule()),
     }
 }
 
-fn build_arglist(pair : pest::iterators::Pair<Rule>, sym : &mut SymbolTable) -> Vec<Arg> {
+fn parse_assign(pair: pest::iterators::Pair<Rule>, tr: &mut Transaction, st: &mut SymbolTable) -> Stmt {
+    let path_id_rule = pair.into_inner().next().unwrap();
+    let expr_rule = pair.into_inner().next().unwrap();
+
+    let path_id = path_id_rule.as_str();
+    // TODO: Error handling
+    let symbol_id = match st.symbol_id_from_name(path_id) {
+        Some(id) => id,
+        None => panic!("Assigning to undeclared symbol: {}", path_id),
+    };
+
+    let expr_id = parse_expr(expr_rule.into_inner(), tr, st);
+
+    // Dummy implementation
+    Stmt::Assign(symbol_id, expr_id)
+}
+
+fn parse_cmd(pair: pest::iterators::Pair<Rule>, st: &mut SymbolTable) -> Stmt {
+    let cmd=  pair.as_str();
+    match cmd {
+        "step" => Stmt::Step,
+        "fork" => Stmt::Fork,
+        _ => panic!("Unexpected command: {:?}", cmd),
+    }
+}
+
+fn parse_while(pair: pest::iterators::Pair<Rule>, tr: &mut Transaction, st: &mut SymbolTable) -> Stmt {
+    // Parse Expression
+    let mut inner_rules = pair.into_inner();
+    let expr_rule = inner_rules.next().unwrap();
+    let guard: ExprId = parse_expr(expr_rule.into_inner(), tr, st);
+
+    // Parse Statement Block
+    let body = parse_stmt_block(inner_rules, tr, st);
+
+    Stmt::While(guard, body)
+}
+
+fn parse_stmt_block(stmt_pairs: Pairs<Rule>, tr: &mut Transaction, st: &mut SymbolTable) -> StmtId {
+    // Parse Statement Block. FIXME: Duplicate code.
+    // Process the body of statements, adding them to the block as we go
+    let stmts = Vec::new();
+    while let Some(inner_pair) = stmt_pairs.next() {
+        match inner_pair.as_rule() {
+            Rule::assign => {
+                let stmt = parse_assign(inner_pair, tr, st);
+                stmts.push(tr.s(stmt));
+            }
+            Rule::cmd => {
+                let stmt = parse_cmd(inner_pair,tr, st);
+                stmts.push(tr.s(stmt));
+            }
+            Rule::while_loop => {
+                let stmt = parse_while(inner_pair,tr, st);
+                stmts.push(tr.s(stmt));
+            }
+            Rule::cond => {
+                let stmt = parse_cond(inner_pair, tr, st);
+                stmts.push(tr.s(stmt));
+            }
+            _ => panic!("Unexpected rule: {:?}", inner_pair.as_rule()),
+        }
+    }
+    tr.s(Stmt::Block(stmts))
+}
+
+fn parse_cond(pair: pest::iterators::Pair<Rule>, tr: &mut Transaction, st: &mut SymbolTable) -> Stmt {
+    // Dummy implementation
+    let mut inner_rules = pair.into_inner();
+
+    let if_rule = inner_rules.next().unwrap();
+    let inner_if = if_rule.into_inner();
+    let expr_rule = inner_if.next().unwrap();
+    let expr_id = parse_expr(expr_rule.into_inner(), tr, st);
+    let if_block = parse_stmt_block(inner_if, tr, st);
+
+    let else_rule = inner_rules.next().unwrap();
+    let inner_else = else_rule.into_inner();
+    let else_block = parse_stmt_block(inner_else, tr, st);
+
+    Stmt::IfElse(expr_id, if_block, else_block)
+    
+}
+
+fn build_arglist(pair : pest::iterators::Pair<Rule>, st : &mut SymbolTable) -> Vec<Arg> {
     let mut args = Vec::new();
     for inner_pair in pair.into_inner() {
         match inner_pair.as_rule() {
@@ -125,12 +260,12 @@ fn build_arglist(pair : pest::iterators::Pair<Rule>, sym : &mut SymbolTable) ->
                 let id = id_pair.as_str();
                 let tpe = parse_type(tpe_pair);
 
-                let symbol_id = sym.add_without_parent(id.to_string(), tpe);
+                let symbol_id = st.add_without_parent(id.to_string(), tpe);
                 let arg = Arg::new(symbol_id, dir);
                 args.push(arg);
             }
             Rule::arglist => {
-                let mut nested_args = build_arglist(inner_pair, sym);
+                let mut nested_args = build_arglist(inner_pair, st);
                 args.append(&mut nested_args);
             }
             _ => panic!("Unexpected rule: {:?}", inner_pair.as_rule()),
@@ -139,6 +274,33 @@ fn build_arglist(pair : pest::iterators::Pair<Rule>, sym : &mut SymbolTable) ->
     args
 }
 
+fn build_fields(pair : pest::iterators::Pair<Rule>, st : &mut SymbolTable) -> Vec<Field> {
+    let mut fields = Vec::new();
+    for inner_pair in pair.into_inner() {
+        match inner_pair.as_rule() {
+            Rule::arg => {
+                let mut arg_inner = inner_pair.into_inner();
+                let dir_pair = arg_inner.next().unwrap();
+                let id_pair = arg_inner.next().unwrap();
+                let tpe_pair = arg_inner.next().unwrap();
+
+                let dir = parse_dir(dir_pair);
+                let id = id_pair.as_str();
+                let tpe = parse_type(tpe_pair);
+
+                let field = Field::new(id.to_string(), dir, tpe);
+                fields.push(field);
+            }
+            Rule::arglist => {
+                let mut nested_fields = build_fields(inner_pair, st);
+                fields.append(&mut nested_fields);
+            }
+            _ => panic!("Unexpected rule: {:?}", inner_pair.as_rule()),
+        }
+    }
+    fields
+}
+
 fn parse_dir(pair : pest::iterators::Pair<Rule>) -> Dir {
     match pair.as_rule() {
         Rule::dir => {
@@ -223,11 +385,15 @@ mod tests {
         }
         // println!("Length of pairs: {}", pairs.clone().count());
         let inner = pairs.clone().next().unwrap().into_inner();
+        let mut st: &mut SymbolTable = &mut SymbolTable::default();
         for pair in inner {
-            if pair.as_rule() == Rule::fun {
-                let mut sym = &mut SymbolTable::default();
-                let mut transaction = build_transaction(pair, sym);
-                println!("Transaction: {:?}", transaction.name);
+            if pair.as_rule() == Rule::struct_def {
+                let _parsed_struct = build_struct(pair, st);
+                // println!("Struct: {:?}", struct.name);
+            }
+            else if pair.as_rule() == Rule::fun {
+                let _tr = build_transaction(pair, st);
+                // println!("Transaction: {:?}", transaction.name);
             }
         }
         // let pair = pairs.into_inner();

src/protocols.pest

@@ -19,10 +19,10 @@ atom = _{primary | unary_op? ~ primary}
 unary_op = _ { not }
     // negate = { "-" }
     not = { "!" }
-bin_op = _{ leq | eq | log_and }
+bin_op = _{ eq | log_and }
 // bin_op = _{ neq | leq | eq | log_and | log_or | shift_left | shift_right | add | subtract | multiply | divide | mod }
 //    neq = { "!=" }
-    leq = { "<= "}
+//   leq = { "<= "}
     eq = { "== "}
 //    add = { "+" }
     log_and = { "&&" }
@@ -41,23 +41,22 @@ path_id = @{ id ~ ("." ~ id)* }
 tpe = { "u32" | "u1" }
 assign = {path_id ~ ":=" ~ (expr | path_id) ~ ";" }
 cmd = { path_id ~ "(" ~ ")" ~ ";"}
-stmt = _{ (assign | cmd | while | cond) }
-dir = {"in" | "out" }
+stmt = _{ (assign | cmd | while_loop | cond) }
+dir = { "in" | "out" }
 arg = { dir ~ id ~ ":" ~ tpe }
 arglist = { (arg ~ "," ~ arglist) | arg ~ ","? }
 type_param = { "<" ~ id ~ ":" ~ id ~ ">" }
 
 // Loops
-while = { "while" ~ expr ~ "{" ~ stmt* ~ "}" }
+while_loop = { "while" ~ expr ~ "{" ~ stmt* ~ "}" }
 
 // Conditionals
 if = { "if" ~ expr ~ "{" ~ stmt* ~ "}" }
-else_if = { "else" ~ "if" ~ expr ~ "{" ~ stmt* ~ "}"}
 else = { "else" ~ "{" ~ stmt* ~ "}" }
-cond = { if ~ else_if* ~ else? }
+cond = { if ~ else? }
 
 // Structs
-struct = { "struct" ~ id ~ "{" ~ arglist? ~ "}" }
+struct_def = { "struct" ~ id ~ "{" ~ arglist? ~ "}" }
 
 fun = { "fn" ~ id ~ type_param? ~ "(" ~ arglist ~ ")" ~ "{" ~ stmt* ~ "}" }
-file = { SOI ~ (fun | struct)* ~ EOI }
+file = { SOI ~ (fun | struct_def)* ~ EOI }