psi-lang 0.3.0

A language for configuration and extension
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

use crate::{Action, Expr};
use rustc_hash::FxHashMap as HashMap;
use smartstring::alias::String;

const LOOP: [&str; 3] = ["loop", "for", "while"];

#[derive(Debug, Clone)]
pub enum Symbol {
    Function(Vec<String>, Vec<Action>),
    Expr(Expr),
}

#[derive(Debug)]
pub struct Namespace<'a> {
    env: Vec<(&'a str, HashMap<String, Symbol>)>,
}

impl<'a> Namespace<'a> {
    pub fn new() -> Self {
        Self {
            env: vec![("*", HashMap::default())],
        }
    }

    pub fn enter(&mut self, name: &'a str) {
        self.env.push((name, HashMap::default()));
    }

    pub fn leave(&mut self) {
        self.env.pop();
    }

    pub fn raw_expr(&mut self, id: &str, expr: &Expr) {
        let build = Symbol::Expr(expr.to_owned());
        let last = self.env.len() - 1;
        self.env.get_mut(last).unwrap().1.insert(id.into(), build);
    }

    pub fn insert_expr(&mut self, id: &str, expr: &Expr) {
        let build = Symbol::Expr(expr.to_owned());
        let mut banks = self.env.iter_mut();
        while let Some((name, contents)) = banks.next_back() {
            if ["*", "function"].contains(name) {
                contents.insert(id.into(), build);
                break;
            }
        }
    }

    pub fn insert_fn(&mut self, id: &str, args: &[String], block: &[Action]) {
        let build = Symbol::Function(args.to_owned(), block.to_owned());
        let mut banks = self.env.iter_mut();
        while let Some((name, contents)) = banks.next_back() {
            if ["*", "function"].contains(name) {
                contents.insert(id.into(), build);
                break;
            }
        }
    }

    pub fn get_expr(&mut self, id: &str) -> Option<Expr> {
        let mut banks = self.env.iter_mut();
        while let Some((name, contents)) = banks.next_back() {
            if let Some(Symbol::Expr(e)) = contents.get(id) {
                return Some(e.clone());
            }
            if name == &"function" {
                break;
            }
        }
        None
    }

    pub fn get_fn(&mut self, id: &str) -> Option<(Vec<String>, Vec<Action>)> {
        let mut banks = self.env.iter_mut();
        while let Some((_, contents)) = banks.next_back() {
            if let Some(Symbol::Function(a, b)) = contents.get(id) {
                return Some((a.clone(), b.clone()));
            }
        }
        None
    }

    pub fn in_function(&self) -> bool {
        self.env.iter().any(|(k, _)| k == &"function")
    }

    pub fn in_loop(&self) -> bool {
        self.env.iter().any(|(k, _)| LOOP.contains(k))
    }
}

impl<'a> Default for Namespace<'a> {
    fn default() -> Self {
        Self::new()
    }
}