wp-lang 0.3.0

WPL language crate with AST, parser, evaluator, builtins, and generators.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#[macro_export]
macro_rules! derive_base_prs {
    ($name:ident) => {
        #[derive(Debug, Default)]
        #[allow(dead_code)]
        pub struct $name {}
        /*
        impl $crate::engine::field::parse_def::FieldConfAble for $name
        where
            Self: $crate::engine::field::BaseAble,
        {
            fn meta(&self) -> wp_model_core::model::meta::Meta {
                self.base().field_conf.meta_type.clone()
            }
            fn conf(&self) -> &$crate::core::WPLField {
                &self.base().field_conf
            }
            fn use_conf(&mut self, conf: $crate::core::WPLField) {
                self.mut_base().field_conf = conf;
            }
        }

         */
    };

    ($name:ident, $patten_first: expr) => {
        #[derive(Debug)]
        #[allow(dead_code)]
        pub struct $name {
            base: $crate::engine::field::BasePRS,
        }

        impl $name {
            fn name_tag(&self) -> &str {
                stringify!($name)
            }
        }

        impl $crate::engine::field::BaseAble for $name {
            fn name(&self) -> &str {
                self.name_tag()
            }

            fn base(&self) -> &$crate::engine::field::BasePRS {
                &self.base
            }
            fn mut_base(&mut self) -> &mut $crate::engine::field::BasePRS {
                &mut self.base
            }
        }
        impl $crate::compat::New1<$crate::core::WPLField> for $name {
            fn new(mut conf: $crate::core::WPLField) -> Self {
                if conf.fmt_conf.patten_first.is_none() {
                    conf.fmt_conf.patten_first = Some($patten_first);
                };
                Self {
                    base: $crate::engine::field::BasePRS::new(conf),
                }
            }
        }
        /*
        impl $crate::engine::field::parse_def::FieldConfAble for $name
        where
            Self: $crate::engine::field::BaseAble,
        {
            fn meta(&self) -> wp_model_core::model::meta::Meta {
                self.base().field_conf.meta_type.clone()
            }
            fn conf(&self) -> &$crate::core::WPLField {
                &self.base().field_conf
            }
            fn use_conf(&mut self, conf: $crate::core::WPLField) {
                self.mut_base().field_conf = conf;
            }
        }

         */
    };
}

#[macro_export]
macro_rules! over_loop_check {
    ($var:expr,$max:expr) => {
        if $var > $max {
            break;
        }
        $var += 1;
    };
}
#[macro_export]
macro_rules! true_break {
    ($express:expr) => {
        if $express {
            break;
        }
    };
}
#[macro_export]
macro_rules! option_loop_break {
    ($cur_cnt :expr, $max_val: expr) => {
        if let Some(var) = $max_val {
            if $cur_cnt >= var {
                break;
            }
        }
    };
}

#[macro_export]
macro_rules! true_continue {
    ($express:expr) => {
        if $express {
            continue;
        }
    };
}