Evaluate memory region expressions using definitions

src/eval.rs

@@ -0,0 +1,178 @@
+use crate::expressions::{BinaryOperator, Expression};
+
+use crate::script::PARSE_STATE;
+
+fn _evaluate_expression(expr: &Expression) -> Result<u64, String> {
+    Ok(match expr {
+        Expression::Number(n) => *n,
+        Expression::Ident(s) => {
+            return PARSE_STATE.with_borrow(|state| {
+                for item in &state.items {
+                    if let crate::RootItem::Statement(stmt) = item {
+                        if let crate::Statement::Assign {
+                            name, expression, ..
+                        } = stmt
+                        {
+                            if name == s {
+                                return _evaluate_expression(&**expression);
+                            }
+                        }
+                    }
+                }
+                Err(format!("Variable {:?} not found", s))
+            });
+        }
+        Expression::Call {
+            function,
+            arguments,
+        } => {
+            return match function.as_str() {
+                "ORIGIN" | "LENGTH" => {
+                    if arguments.len() != 1 {
+                        return Err(format!("function {:?} only support 1 argument", function));
+                    }
+                    if let Expression::Ident(s) = &arguments[0] {
+                        return PARSE_STATE.with_borrow(|state| {
+                            for item in &state.items {
+                                if let crate::RootItem::Memory { regions } = item {
+                                    for region in regions {
+                                        if region.name == *s {
+                                            return Ok(match function.as_str() {
+                                                "ORIGIN" => region.origin,
+                                                "LENGTH" => region.length,
+                                                _ => unreachable!(),
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            Err(format!("Variable {:?} not found", s))
+                        });
+                    } else {
+                        return Err(format!("function {:?} argument must be string", function));
+                    }
+                }
+                _ => Err(format!("function {:?} not supported", function)),
+            }
+        }
+        Expression::BinaryOp {
+            left,
+            operator,
+            right,
+        } => {
+            let left = _evaluate_expression(&**left)?;
+            let right = _evaluate_expression(&**right)?;
+            match operator {
+                BinaryOperator::Plus => left.wrapping_add(right),
+                BinaryOperator::Minus => left.wrapping_sub(right),
+                BinaryOperator::Multiply => left.wrapping_mul(right),
+                BinaryOperator::Divide => left.wrapping_div(right),
+                _ => return Err(format!("Binary operator {:?} not supported", operator)),
+            }
+        }
+        _ => return Err(format!("Expression {:?} not supported", expr)),
+    })
+}
+
+pub fn evaluate_expression(expr: Expression) -> Result<u64, String> {
+    _evaluate_expression(&expr)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{script::clear_state, AssignOperator, Region, RootItem, Statement};
+
+    use super::*;
+    use nom::combinator::map_res;
+    use BinaryOperator::*;
+
+    #[test]
+    fn test_evaluate_expression() {
+        assert_eq!(evaluate_expression(Expression::Number(42)), Ok(42));
+
+        assert_eq!(
+            evaluate_expression(Expression::BinaryOp {
+                left: Box::new(Expression::Number(42)),
+                operator: Plus,
+                right: Box::new(Expression::Number(42))
+            }),
+            Ok(84)
+        );
+        assert_eq!(
+            evaluate_expression(Expression::BinaryOp {
+                left: Box::new(Expression::Number(42)),
+                operator: Minus,
+                right: Box::new(Expression::Number(42))
+            }),
+            Ok(0)
+        );
+        assert_eq!(
+            evaluate_expression(Expression::BinaryOp {
+                left: Box::new(Expression::Number(42)),
+                operator: Multiply,
+                right: Box::new(Expression::Number(42))
+            }),
+            Ok(1764)
+        );
+        assert_eq!(
+            evaluate_expression(Expression::BinaryOp {
+                left: Box::new(Expression::Number(42)),
+                operator: Divide,
+                right: Box::new(Expression::Number(42))
+            }),
+            Ok(1)
+        );
+    }
+
+    fn expr_result(input: &str, expected: u64) {
+        assert_done!(
+            map_res(crate::expressions::expression, evaluate_expression)(input),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_parsed_expressions() {
+        expr_result("42 - (20 + 21)", 1);
+        expr_result("42 - (4 * 8)", 10);
+        expr_result("42", 42);
+        expr_result("42 + 42", 84);
+        expr_result("42 - 42", 0);
+        expr_result("42 * 42", 1764);
+        expr_result("42 / 42", 1);
+        expr_result("0x2000000 + (4k * 4)", 0x2000000 + (4 * 1024 * 4));
+
+        clear_state();
+        PARSE_STATE.with_borrow_mut(|state| {
+            state.items.push(RootItem::Statement(Statement::Assign {
+                name: "A".into(),
+                operator: AssignOperator::Equals,
+                expression: Box::new(Expression::Number(11)),
+            }));
+        });
+        expr_result("A * 2", 22);
+        PARSE_STATE.with_borrow_mut(|state| {
+            state.items.push(RootItem::Statement(Statement::Assign {
+                name: "B".into(),
+                operator: AssignOperator::Equals,
+                expression: Box::new(Expression::BinaryOp {
+                    left: Box::new(Expression::Number(2)),
+                    operator: BinaryOperator::Plus,
+                    right: Box::new(Expression::Number(4)),
+                }),
+            }));
+        });
+        expr_result("A * B", 66);
+        PARSE_STATE.with_borrow_mut(|state| {
+            state.items.push(RootItem::Memory {
+                regions: vec![Region {
+                    name: String::from("AA"),
+                    origin: 66,
+                    length: 12,
+                }],
+            });
+        });
+        expr_result("ORIGIN(AA)", 66);
+        expr_result("LENGTH(AA)", 12);
+    }
+}

src/lib.rs

@@ -29,6 +29,7 @@ mod utils;
 #[macro_use]
 mod whitespace;
 mod commands;
+mod eval;
 mod expressions;
 mod idents;
 mod memory;

src/memory.rs

@@ -2,13 +2,14 @@ use idents::symbol;
 use nom::{
     branch::alt,
     bytes::complete::{tag, take_until},
-    combinator::opt,
+    combinator::{map_res, opt},
     sequence::{delimited, tuple},
     IResult,
 };
-use numbers::number;
 use whitespace::opt_space;
 
+use crate::{eval::evaluate_expression, expressions::expression};
+
 #[derive(Debug, PartialEq)]
 pub struct Region {
     pub name: String,
@@ -37,15 +38,15 @@ pub fn region(input: &str) -> IResult<&str, Region> {
         origin,
         wsc!(tag("=")),
     ))(input)?;
-    let (input, org) = number(input)?;
+    let (input, origin) = map_res(expression, evaluate_expression)(input)?;
     let (input, _) = tuple((wsc!(tag(",")), length, wsc!(tag("="))))(input)?;
-    let (input, len) = number(input)?;
+    let (input, length) = map_res(expression, evaluate_expression)(input)?;
     Ok((
         input,
         Region {
             name: name.into(),
-            origin: org,
-            length: len,
+            origin,
+            length,
         },
     ))
 }
@@ -54,6 +55,11 @@ pub fn region(input: &str) -> IResult<&str, Region> {
 mod tests {
     use memory::*;
 
+    use crate::{
+        script::{clear_state, PARSE_STATE},
+        AssignOperator, Expression, RootItem, Statement,
+    };
+
     #[test]
     fn test_region() {
         assert_done!(
@@ -73,4 +79,105 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_region_expr() {
+        assert_done!(
+            region("FLASH : ORIGIN = 0x08000000, LENGTH = 8K"),
+            Region {
+                name: "FLASH".into(),
+                origin: 0x08000000,
+                length: 8 * 1024,
+            }
+        );
+
+        assert_done!(
+            region("RAM : ORIGIN = 0x20000000 + 8K, LENGTH = 640K"),
+            Region {
+                name: "RAM".into(),
+                origin: 0x20000000 + 8 * 1024,
+                length: 640 * 1024,
+            }
+        );
+
+        assert_done!(
+            region("RAM : ORIGIN = 0x20000000, LENGTH = 640K - 8K"),
+            Region {
+                name: "RAM".into(),
+                origin: 0x20000000,
+                length: 640 * 1024 - 8 * 1024,
+            }
+        );
+
+        assert_done!(
+            region("RAM : ORIGIN = 0x20000000 + 8K - 4K, LENGTH = 640K - 8K + 4K"),
+            Region {
+                name: "RAM".into(),
+                origin: 0x20000000 + 4 * 1024,
+                length: 640 * 1024 - 4 * 1024,
+            }
+        );
+
+        assert_done!(
+            region("RAM: ORIGIN = 0x20000000 + 8K - 4K, LENGTH = 640K - 8K + 4K"),
+            Region {
+                name: "RAM".into(),
+                origin: 0x20000000 + 4 * 1024,
+                length: 640 * 1024 - 4 * 1024,
+            }
+        );
+
+        clear_state();
+        PARSE_STATE.with_borrow_mut(|state| {
+            state.items.push(RootItem::Statement(Statement::Assign {
+                name: "A".into(),
+                operator: AssignOperator::Equals,
+                expression: Box::new(Expression::Number(11)),
+            }));
+        });
+
+        assert_done!(
+            region("rom (rx)  : ORIGIN = 0, LENGTH = A"),
+            Region {
+                name: "rom".into(),
+                origin: 0,
+                length: 11,
+            }
+        );
+
+        PARSE_STATE.with_borrow_mut(|state| {
+            state.items.push(RootItem::Memory {
+                regions: vec![Region {
+                    name: String::from("FLASH"),
+                    origin: 0x08000000,
+                    length: 256 * 1024,
+                }],
+            });
+        });
+
+        PARSE_STATE.with_borrow_mut(|state| {
+            state.items.push(RootItem::Statement(Statement::Assign {
+                name: "FLASH_SIZE".into(),
+                operator: AssignOperator::Equals,
+                expression: Box::new(Expression::Number(256 * 1024)),
+            }));
+        });
+
+        PARSE_STATE.with_borrow_mut(|state| {
+            state.items.push(RootItem::Statement(Statement::Assign {
+                name: "EEPROM_SIZE".into(),
+                operator: AssignOperator::Equals,
+                expression: Box::new(Expression::Number(4 * 1024)),
+            }));
+        });
+
+        assert_done!(
+            region("EEPROM_FLASH  (r)  : ORIGIN = ORIGIN(FLASH) + FLASH_SIZE - EEPROM_SIZE, LENGTH = EEPROM_SIZE"),
+            Region {
+                name: "EEPROM_FLASH".into(),
+                origin: 0x803F000,
+                length: 4 * 1024,
+            }
+        );
+    }
 }