Wire up the math functions to the renderer.

src/renderer/renderer.rs

@@ -1043,13 +1043,63 @@ impl<'a> DustRenderer<'a> {
                     .get_context_element_reference()
                     .math_add(r.get_context_element_reference()),
             },
-            "subtract" => todo!(),
+            "subtract" => match (left_side_ce, right_side_ce) {
-            "multiply" => todo!(),
+                (None, _) | (Some(Err(_)), _) | (_, None) | (_, Some(Err(_))) => None,
-            "divide" => todo!(),
+                (Some(Ok(None)), _) | (_, Some(Ok(None))) => Some(IceResult::from_owned(
-            "mod" => todo!(),
+                    OwnedLiteral::LString("NaN".to_owned()),
-            "abs" => todo!(),
+                )),
-            "floor" => todo!(),
+                (Some(Ok(Some(l))), Some(Ok(Some(r)))) => l
-            "ceil" => todo!(),
+                    .get_context_element_reference()
+                    .math_subtract(r.get_context_element_reference()),
+            },
+            "multiply" => match (left_side_ce, right_side_ce) {
+                (None, _) | (Some(Err(_)), _) | (_, None) | (_, Some(Err(_))) => None,
+                (Some(Ok(None)), _) | (_, Some(Ok(None))) => Some(IceResult::from_owned(
+                    OwnedLiteral::LString("NaN".to_owned()),
+                )),
+                (Some(Ok(Some(l))), Some(Ok(Some(r)))) => l
+                    .get_context_element_reference()
+                    .math_multiply(r.get_context_element_reference()),
+            },
+            "divide" => match (left_side_ce, right_side_ce) {
+                (None, _) | (Some(Err(_)), _) | (_, None) | (_, Some(Err(_))) => None,
+                (Some(Ok(None)), _) | (_, Some(Ok(None))) => Some(IceResult::from_owned(
+                    OwnedLiteral::LString("NaN".to_owned()),
+                )),
+                (Some(Ok(Some(l))), Some(Ok(Some(r)))) => l
+                    .get_context_element_reference()
+                    .math_divide(r.get_context_element_reference()),
+            },
+            "mod" => match (left_side_ce, right_side_ce) {
+                (None, _) | (Some(Err(_)), _) | (_, None) | (_, Some(Err(_))) => None,
+                (Some(Ok(None)), _) | (_, Some(Ok(None))) => Some(IceResult::from_owned(
+                    OwnedLiteral::LString("NaN".to_owned()),
+                )),
+                (Some(Ok(Some(l))), Some(Ok(Some(r)))) => l
+                    .get_context_element_reference()
+                    .math_modulus(r.get_context_element_reference()),
+            },
+            "abs" => match left_side_ce {
+                None | Some(Err(_)) => None,
+                Some(Ok(None)) => Some(IceResult::from_owned(OwnedLiteral::LString(
+                    "NaN".to_owned(),
+                ))),
+                Some(Ok(Some(num))) => num.get_context_element_reference().math_abs(),
+            },
+            "floor" => match left_side_ce {
+                None | Some(Err(_)) => None,
+                Some(Ok(None)) => Some(IceResult::from_owned(OwnedLiteral::LString(
+                    "NaN".to_owned(),
+                ))),
+                Some(Ok(Some(num))) => num.get_context_element_reference().math_floor(),
+            },
+            "ceil" => match left_side_ce {
+                None | Some(Err(_)) => None,
+                Some(Ok(None)) => Some(IceResult::from_owned(OwnedLiteral::LString(
+                    "NaN".to_owned(),
+                ))),
+                Some(Ok(Some(num))) => num.get_context_element_reference().math_ceil(),
+            },
             _ => None,
         };
     }