添加take时进行对约定的常量便捷的传参与忽略返回值的语法,

这让代码复用不再困难

Author: A4-Tacks

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mindustry_logic_bang_lang"
-version = "0.4.3"
+version = "0.5.0"
 edition = "2021"
 
 authors = ["A4-Tacks <wdsjxhno1001@163.com>"]

Cargo.toml

@@ -0,0 +1,97 @@
+#* 此篇使用的是v0.5.0的语法
+在这个版本为take语法进行了扩展
+这是一个让代码复用更加方便的版本
+首先, 允许`take F;`这种写法了, 这将等价于以前的`take __ = F;`
+    我们不再需要填写一个用不上的常量来符合语法了
+
+然后是一个重要的语法, `take[Value*]`, 你可以在左边take的右侧插入一个方括号
+    当你没有在里面写值时, 这等同于你不加这个方括号
+    如果你在里面写了1至若干个值,
+    那么take将不会被构建为一个Take, 而是一个Expand.
+    你可以将它理解成一个块, 常量的作用域就是来源于Expand
+    然后它会将你写在方括号内的`Value`按顺序在这个块内
+        `const _0 = V1;`
+        `const _1 = V2;`
+        `const _2 = V3;`
+    这种, 将你传入的顺序分配给`_0` `_1` `_2`名字的常量
+        注意, 这不会进行label收集, 它仅在语法层面的`const`被编写时有效
+        所以, 如果你想要在内部使用被跳转标签, 请老实的构建一个`const`再传入
+    然后是take的本身`Take`
+    接着, 如果你的take返回用常量没有缺省的话,
+        还会再加一行`ConstLeak`, 将这个你给出的返回常量泄露到外部一层块
+            因为这种形式的take建立了一个块, 不将其泄露到上一层块我们将无法再获取它
+        这个`ConstLeak`目前无法被手动编写, 防止滥用、作用域逃逸等不规范使用
+*#
+
+
+const DO = (
+    # 这是一个用来执行传入的第一个参数的const
+    print "enter";
+    take _0;
+    print "exit";
+);
+
+take[(
+    print "hello";
+)] DO;
+
+#* 以上代码会被编译为
+print "enter"
+print "hello"
+print "exit"
+*#
+# 可以看到, 我们使用take计算了这个`DO`, 然后它被展开
+# 但是根据上述介绍, 我们知道, 是先将_0被const到了我们传入的DExp中
+# 然后再进行take的
+# 所以take展开的内容中间才会正常获取_0得到我们的DExp
+
+
+const ADD = (
+    # 这是一个将传入值计算并加1再与之前的自身相乘的DExp
+    take N = _0; # 这里首先将传入的值计算出来, 避免如果是一个DExp反复计算
+    op $ N + 1;
+    op $ $ * N;
+);
+
+take[(op $ 3 + 4;)] RES = ADD;
+print RES;
+#* 以上代码会被编译为
+op add __1 3 4
+op add __0 __1 1
+op mul __0 __0 __1
+print __0
+*#
+# 首先ADD头部的take会先将传入的DExp计算出来
+# 然后再使用
+# 接着我们的RES被映射到了返回句柄__0, 接下来使用并将其打印了出来
+# 我们可以看看如果不使用`take N = _0`并且N换成_0直接使用会怎样
+# 以下为代码
+const ADD = (
+    # 这是一个将传入值计算并加1再与之前的自身相乘的DExp
+    op $ _0 + 1;
+    op $ $ * _0;
+);
+
+take[(op $ 3 + 4;)] RES = ADD;
+print RES;
+#* 以上代码会被编译为
+op add __1 3 4
+op add __0 __1 1
+op add __2 3 4
+op mul __0 __0 __2
+print __0
+*#
+# 我们可以看到, 3 + 4被重复计算了
+# 这就是先使用take计算出来的意义
+
+
+# 多个值的示例
+const PRINT2 = (
+    print _0 _1;
+);
+take[123 456] PRINT2;
+#* 以上代码会被编译为
+print 123
+print 456
+*#
+# 多个值传入也是可以的

examples/take2.mdtlbl

@@ -280,6 +280,14 @@ impl Meta {
     pub fn pop_label_scope(&mut self) -> Vec<Var> {
         self.defined_labels.pop().unwrap()
     }
+
+    /// 根据一系列构建一系列常量传参
+    pub fn build_arg_consts(&self, values: Vec<Value>, mut f: impl FnMut(Const)) {
+        for (i, value) in values.into_iter().enumerate() {
+            let name = format!("_{}", i);
+            f(Const(name, value, Vec::with_capacity(0)))
+        }
+    }
 }
 
 /// `jump`可用判断条件枚举
@@ -653,6 +661,7 @@ pub enum LogicLine {
     Ignore,
     Const(Const),
     Take(Take),
+    ConstLeak(Var),
 }
 impl Compile for LogicLine {
     fn compile(self, meta: &mut CompileMeta) {
@@ -678,6 +687,7 @@ impl Compile for LogicLine {
             Self::Ignore => (),
             Self::Const(r#const) => r#const.compile(meta),
             Self::Take(take) => take.compile(meta),
+            Self::ConstLeak(r#const) => meta.add_const_value_leak(r#const),
         }
     }
 }
@@ -807,9 +817,11 @@ pub struct CompileMeta {
     tag_count: usize,
     tag_codes: TagCodes,
     tmp_var_count: usize,
-    /// # 块中宏, 且带有展开次数与内部标记
-    /// `Vec<HashMap<name, (count, Vec<Label>, Value)>>`
-    const_var_namespace: Vec<HashMap<Var, (usize, Vec<Var>, Value)>>,
+    /// 块中常量, 且带有展开次数与内部标记
+    /// 并且存储了需要泄露的常量
+    ///
+    /// `Vec<(leaks, HashMap<name, (count, Vec<Label>, Value)>)>`
+    const_var_namespace: Vec<(Vec<Var>, HashMap<Var, (usize, Vec<Var>, Value)>)>,
     /// 每层DExp所使用的句柄, 末尾为当前层
     dexp_result_handles: Vec<Var>,
     tmp_tag_count: usize,
@@ -905,14 +917,39 @@ impl CompileMeta {
 
     /// 进入一个子块, 创建一个新的子命名空间
     pub fn block_enter(&mut self) {
-        self.const_var_namespace.push(HashMap::new())
+        self.const_var_namespace.push((Vec::new(), HashMap::new()))
     }
 
     /// 退出一个子块, 弹出最顶层命名空间
     /// 如果无物可弹说明逻辑出现了问题, 所以内部处理为unwrap
     /// 一个enter对应一个exit
     pub fn block_exit(&mut self) -> HashMap<Var, (usize, Vec<Var>, Value)> {
-        self.const_var_namespace.pop().unwrap()
+        // this is poped block
+        let (leaks, mut res)
+            = self.const_var_namespace.pop().unwrap();
+
+        // do leak
+        for leak_const_name in leaks {
+            let value
+                = res.remove(&leak_const_name).unwrap();
+
+            // insert to prev block
+            self.const_var_namespace
+                .last_mut()
+                .unwrap()
+                .1
+                .insert(leak_const_name, value);
+        }
+        res
+    }
+
+    /// 添加一个需泄露的const
+    pub fn add_const_value_leak(&mut self, name: Var) {
+        self.const_var_namespace
+            .last_mut()
+            .unwrap()
+            .0
+            .push(name)
     }
 
     /// 获取一个常量到值的使用次数与映射与其内部标记的引用,
@@ -921,7 +958,7 @@ impl CompileMeta {
         self.const_var_namespace
             .iter()
             .rev()
-            .find_map(|namespace| {
+            .find_map(|(_, namespace)| {
                 namespace.get(name)
             })
     }
@@ -933,7 +970,7 @@ impl CompileMeta {
         self.const_var_namespace
             .iter_mut()
             .rev()
-            .find_map(|namespace| {
+            .find_map(|(_, namespace)| {
                 namespace.get_mut(name)
             })
     }
@@ -961,6 +998,7 @@ impl CompileMeta {
         self.const_var_namespace
             .last_mut()
             .unwrap()
+            .1
             .insert(var, (0, labels, value))
     }
 
@@ -1784,4 +1822,151 @@ mod tests {
         let mut tag_codes = meta.compile(ast);
         let _logic_lines = tag_codes.compile().unwrap();
     }
+
+    #[test]
+    fn take_default_result_test() {
+        let parser = LogicLineParser::new();
+
+        let ast = parse!(parser, "take 2;").unwrap();
+        assert_eq!(ast, Take("__".into(), "2".into()).into());
+    }
+
+    #[test]
+    fn const_value_leak_test() {
+        let ast: Expand = vec![
+            Expand(vec![
+                LogicLine::Other(vec!["print".into(), "N".into()]),
+                Const("N".into(), "2".into(), Vec::new()).into(),
+                LogicLine::Other(vec!["print".into(), "N".into()]),
+            ]).into(),
+            LogicLine::Other(vec!["print".into(), "N".into()]),
+        ].into();
+        let meta = CompileMeta::new();
+        let mut tag_codes = meta.compile(ast);
+        let logic_lines = tag_codes.compile().unwrap();
+        assert_eq!(logic_lines, vec![
+                   "print N",
+                   "print 2",
+                   "print N",
+        ]);
+
+        let ast: Expand = vec![
+            Expand(vec![
+                LogicLine::Other(vec!["print".into(), "N".into()]),
+                Const("N".into(), "2".into(), Vec::new()).into(),
+                LogicLine::Other(vec!["print".into(), "N".into()]),
+                LogicLine::ConstLeak("N".into()),
+            ]).into(),
+            LogicLine::Other(vec!["print".into(), "N".into()]),
+        ].into();
+        let meta = CompileMeta::new();
+        let mut tag_codes = meta.compile(ast);
+        let logic_lines = tag_codes.compile().unwrap();
+        assert_eq!(logic_lines, vec![
+                   "print N",
+                   "print 2",
+                   "print 2",
+        ]);
+    }
+
+    #[test]
+    fn take_test2() {
+        let parser = LogicLineParser::new();
+
+        let ast = parse!(parser, "take X;").unwrap();
+        assert_eq!(ast, Take("__".into(), "X".into()).into());
+
+        let ast = parse!(parser, "take R = X;").unwrap();
+        assert_eq!(ast, Take("R".into(), "X".into()).into());
+
+        let ast = parse!(parser, "take[] X;").unwrap();
+        assert_eq!(ast, Take("__".into(), "X".into()).into());
+
+        let ast = parse!(parser, "take[] R = X;").unwrap();
+        assert_eq!(ast, Take("R".into(), "X".into()).into());
+
+        let ast = parse!(parser, "take[1 2] R = X;").unwrap();
+        assert_eq!(ast, Expand(vec![
+                Const::new("_0".into(), "1".into()).into(),
+                Const::new("_1".into(), "2".into()).into(),
+                Take("R".into(), "X".into()).into(),
+                LogicLine::ConstLeak("R".into()),
+        ]).into());
+
+        let ast = parse!(parser, "take[1 2] X;").unwrap();
+        assert_eq!(ast, Expand(vec![
+                Const::new("_0".into(), "1".into()).into(),
+                Const::new("_1".into(), "2".into()).into(),
+                Take("__".into(), "X".into()).into(),
+        ]).into());
+    }
+
+    #[test]
+    fn take_args_test() {
+        let parser = ExpandParser::new();
+
+        let ast = parse!(parser, r#"
+        const M = (
+            print _0 _1 _2;
+            set $ 3;
+        );
+        take[1 2 3] M;
+        take[4 5 6] R = M;
+        print R;
+        "#).unwrap();
+        let meta = CompileMeta::new();
+        let mut tag_codes = meta.compile(ast);
+        let logic_lines = tag_codes.compile().unwrap();
+        assert_eq!(logic_lines, vec![
+                   "print 1",
+                   "print 2",
+                   "print 3",
+                   "set __0 3",
+                   "print 4",
+                   "print 5",
+                   "print 6",
+                   "set __1 3",
+                   "print __1",
+        ]);
+
+        let ast = parse!(parser, r#"
+        const DO = (
+            print _0 "start";
+            take _1;
+            print _0 "start*2";
+            take _1;
+            printflush message1;
+        );
+        # 这里赋给一个常量再使用, 因为直接使用不会记录label, 无法重复被使用
+        # 而DO中, 会使用两次传入的参数1
+        const F = (
+            i = 0;
+            while i < 10 {
+                print i;
+                op i i + 1;
+            }
+        );
+        take["loop" F] DO;
+        "#).unwrap();
+        let meta = CompileMeta::new();
+        let mut tag_codes = meta.compile(ast);
+        let logic_lines = tag_codes.compile().unwrap();
+        assert_eq!(logic_lines, vec![
+                   r#"print "loop""#,
+                   r#"print "start""#,
+                   r#"set i 0"#,
+                   r#"jump 7 greaterThanEq i 10"#,
+                   r#"print i"#,
+                   r#"op add i i 1"#,
+                   r#"jump 4 lessThan i 10"#,
+                   r#"print "loop""#,
+                   r#"print "start*2""#,
+                   r#"set i 0"#,
+                   r#"jump 14 greaterThanEq i 10"#,
+                   r#"print i"#,
+                   r#"op add i i 1"#,
+                   r#"jump 11 lessThan i 10"#,
+                   r#"printflush message1"#,
+        ]);
+    }
 }