Access to external functions from expressions

Author: mdecimus

examples/filter.rs

@@ -83,11 +83,6 @@ So if you could go ahead and try to remember to do that from now on, that'd be g
                     // Set to true if the ID is duplicate
                     input = false.into();
                 }
-                Event::Plugin { id, arguments } => {
-                    println!("Script executed plugin {id} with parameters {arguments:?}");
-                    // Set to true if the script succeeded
-                    input = false.into();
-                }
                 Event::SetEnvelope { envelope, value } => {
                     println!("Set envelope {envelope:?} to {value:?}");
                     input = true.into();
@@ -157,6 +152,13 @@ So if you could go ahead and try to remember to do that from now on, that'd be g
                     messages.push(String::from_utf8(message).unwrap());
                     input = true.into();
                 }
+                Event::Function { id, arguments } => {
+                    println!(
+                        "Script executed external function {id} with parameters {arguments:?}"
+                    );
+                    // Return variable result back to interpreter
+                    input = Input::result("hello world".into());
+                }
 
                 #[cfg(test)]
                 _ => unreachable!(),

src/compiler/grammar/actions/action_set.rs

@@ -25,7 +25,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     compiler::{
-        grammar::instruction::{CompilerState, Instruction},
+        grammar::{
+            expr::Expression,
+            instruction::{CompilerState, Instruction},
+        },
         lexer::{tokenizer::TokenInfo, word::Word, Token},
         CompileError, ErrorType, Value, VariableType,
     },
@@ -68,6 +71,12 @@ pub(crate) struct Set {
     pub value: Value,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub(crate) struct Let {
+    pub name: VariableType,
+    pub expr: Vec<Expression>,
+}
+
 impl<'x> CompilerState<'x> {
     pub(crate) fn parse_set(&mut self) -> Result<(), CompileError> {
         let mut modifiers = Vec::new();
@@ -125,6 +134,15 @@ impl<'x> CompilerState<'x> {
         Ok(())
     }
 
+    pub(crate) fn parse_let(&mut self) -> Result<(), CompileError> {
+        let name = self.tokens.unwrap_next()?;
+        let name = self.parse_variable_name(name, false)?;
+        let expr = self.parse_expr()?;
+
+        self.instructions.push(Instruction::Let(Let { name, expr }));
+        Ok(())
+    }
+
     pub(crate) fn parse_variable_name(
         &mut self,
         token_info: TokenInfo,

src/compiler/grammar/expr/mod.rs

@@ -37,14 +37,14 @@ pub(crate) enum Expression {
     JmpIf { val: bool, pos: u32 },
     Function { id: u32, num_args: u32 },
     ArrayAccess,
+    ArrayBuild(u32),
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub(crate) enum Constant {
     Integer(i64),
     Float(f64),
     String(String),
-    Array(Vec<Constant>),
 }
 
 impl Eq for Constant {}
@@ -64,12 +64,6 @@ impl From<String> for Constant {
     }
 }
 
-impl From<Vec<Constant>> for Constant {
-    fn from(value: Vec<Constant>) -> Self {
-        Constant::Array(value)
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
 pub(crate) enum BinaryOperator {
     Add,

src/compiler/grammar/expr/parser.rs

@@ -33,6 +33,10 @@ where
     arg_count: Vec<i32>,
 }
 
+pub(crate) const ID_ARRAY_ACCESS: u32 = u32::MAX;
+pub(crate) const ID_ARRAY_BUILD: u32 = u32::MAX - 1;
+pub(crate) const ID_EXTERNAL: u32 = u32::MAX - 2;
+
 impl<'x, F> ExpressionParser<'x, F>
 where
     F: Fn(&str, bool) -> Result<Token, String>,
@@ -106,13 +110,13 @@ where
                             });
                         }
 
-                        let expr = if *id != u32::MAX {
-                            Expression::Function {
-                                id: *id,
+                        let expr = match *id {
+                            ID_ARRAY_ACCESS => Expression::ArrayAccess,
+                            ID_ARRAY_BUILD => Expression::ArrayBuild(*num_args),
+                            id => Expression::Function {
+                                id,
                                 num_args: *num_args,
-                            }
-                        } else {
-                            Expression::ArrayAccess
+                            },
                         };
 
                         self.operator_stack.pop();
@@ -168,50 +172,23 @@ where
                         .push((Token::Function { id, name, num_args }, None))
                 }
                 Token::OpenBracket => {
-                    if last_is_var_or_fnc {
-                        // Array access
-                        self.arg_count.push(1);
-                        self.operator_stack.push((
-                            Token::Function {
-                                id: u32::MAX,
-                                name: "[".to_string(),
-                                num_args: 2,
-                            },
-                            None,
-                        ));
-                        self.operator_stack.push((token, None))
+                    // Array functions
+                    let (id, num_args, arg_count) = if last_is_var_or_fnc {
+                        (ID_ARRAY_ACCESS, 2, 1)
                     } else {
-                        // Array literal
-                        let mut array = Vec::new();
-
-                        loop {
-                            match self.tokenizer.next()? {
-                                Some(Token::Number(n)) => array.push(n.into()),
-                                Some(Token::String(s)) => array.push(s.into()),
-                                Some(Token::CloseBracket) => break,
-                                _ => {
-                                    return Err(format!(
-                                        "Invalid token {:?} in array literal",
-                                        token
-                                    ))
-                                }
-                            }
-
-                            match self.tokenizer.next()? {
-                                Some(Token::Comma) => {}
-                                Some(Token::CloseBracket) => break,
-                                _ => {
-                                    return Err(format!(
-                                        "Invalid token {:?} in array literal",
-                                        token
-                                    ))
-                                }
-                            }
-                        }
-
                         self.inc_arg_count();
-                        self.output.push(Expression::Constant(array.into()))
-                    }
+                        (ID_ARRAY_BUILD, 0, 0)
+                    };
+                    self.arg_count.push(arg_count);
+                    self.operator_stack.push((
+                        Token::Function {
+                            id,
+                            name: String::from("array"),
+                            num_args,
+                        },
+                        None,
+                    ));
+                    self.operator_stack.push((token, None));
                 }
                 Token::Comma => {
                     while let Some((token, jmp_pos)) = self.operator_stack.last() {
@@ -253,6 +230,13 @@ where
     fn inc_arg_count(&mut self) {
         if let Some(x) = self.arg_count.last_mut() {
             *x = x.saturating_add(1);
+            let op_pos = self.operator_stack.len() - 2;
+            match self.operator_stack.get_mut(op_pos) {
+                Some((Token::Function { num_args, id, .. }, _)) if *id == ID_ARRAY_BUILD => {
+                    *num_args += 1;
+                }
+                _ => {}
+            }
         }
     }
 

src/compiler/grammar/expr/tokenizer.rs

@@ -223,7 +223,10 @@ where
                             return Err(format!("Invalid character {:?}", char::from(ch),));
                         }
                     };
-                    self.is_start = ch == b'(';
+                    self.is_start = matches!(
+                        token,
+                        Token::OpenParen | Token::Comma | Token::BinaryOperator(_)
+                    );
 
                     return if prev_token.is_some() {
                         self.next_token.push(token);