glowdust 0.0.1

A DBMS with a data model based on functions and pattern matching
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::compiler::parser::ast::{FunctionDefinition, Stmt, TypeDefinition};
use crate::compiler::parser::CompileError;
use crate::compiler::value::parameters::Variable;
use crate::compiler::value::values::Value;
use std::collections::HashMap;
use tracing::trace;

#[derive(Default, Debug)]
pub struct Symbols {
    pub constants: Vec<Value>,
    pub variables: Vec<Variable>,
}

#[derive(Default, Debug)]
pub struct FunctionContext {
    pub name: String,
    pub symbols: Symbols,
}

impl FunctionContext {
    fn new(name: String) -> Self {
        FunctionContext {
            name,
            symbols: Symbols::default(),
        }
    }
}

#[derive(Default, Debug)]
pub struct ParseState {
    current_function: Option<FunctionContext>,
    current_query_block: Option<Symbols>,

    pub(crate) function_definitions: HashMap<String, Vec<(FunctionDefinition, FunctionContext)>>,
    pub(crate) type_definitions: Vec<TypeDefinition>,

    pub script_symbols: Symbols,
    pub(crate) statements: Vec<Stmt>,

    pub errors: Box<Vec<CompileError>>,
}

impl ParseState {
    pub(crate) fn declare_variable(&mut self, var_name: String) -> u8 {
        let variables;
        if let Some(current_function) = self.current_function.as_mut() {
            variables = &mut current_function.symbols.variables
        } else if let Some(symbols) = self.current_query_block.as_mut() {
            variables = &mut symbols.variables
        } else {
            variables = &mut self.script_symbols.variables;
        }
        let var_index = variables.len();
        variables.push(Variable {
            index: var_index,
            name: var_name,
            initialized: false,
        });
        var_index as u8
    }

    pub fn reset(&mut self) {
        self.current_function = None;
        self.current_query_block = None;
        self.function_definitions.clear();
        self.script_symbols.constants.clear();
        self.script_symbols.variables.clear();
        self.statements.clear();
        self.errors.clear();
        self.type_definitions.clear();
    }

    fn find_variable<'a>(variable_list: &'a [Variable], name: &str) -> Option<&'a Variable> {
        variable_list.iter().find(|var| &var.name == name)
    }

    pub(crate) fn get_variable(&self, key: &str) -> Option<&Variable> {
        if let Some(current_function) = self.current_function.as_ref() {
            return Self::find_variable(&current_function.symbols.variables, key);
        }
        if let Some(symbols) = self.current_query_block.as_ref() {
            Self::find_variable(&symbols.variables, key)
        } else {
            Self::find_variable(&self.script_symbols.variables, key)
        }
    }

    pub(crate) fn add_value_constant(&mut self, value: Value) -> u8 {
        let new_index;
        if let Some(current_function) = self.current_function.as_mut() {
            new_index = current_function.symbols.constants.len();
            // trace!(
            //     "Added constant {:?} to function, index is {}",
            //     &value,
            //     new_index,
            // );
            current_function.symbols.constants.push(value);
        } else {
            for (index, var) in self.script_symbols.constants.iter().enumerate() {
                if value.eq(var) {
                    return index as u8;
                }
            }
            new_index = self.script_symbols.constants.len();
            self.script_symbols.constants.push(value);
        }
        new_index as u8
    }

    pub(crate) fn start_query_block(&mut self) {
        if self.current_query_block.is_some() {
            panic!("Cannot handle nested query blocks");
        }
        self.current_query_block = Some(Symbols::default());
    }

    pub(crate) fn end_query_block(&mut self) {
        match &self.current_query_block {
            None => {
                panic!("Cannot end query block when one hasn't been opened yet.");
            }
            Some(_) => {
                self.current_query_block.take();
            }
        }
    }

    pub(crate) fn start_function_definition(&mut self, name: String) {
        if self.current_function.is_some() {
            panic!("Cannot handle nested function definitions");
        }
        self.current_function = Some(FunctionContext::new(name));
    }

    pub(crate) fn end_function_definition(&mut self, function: FunctionDefinition) {
        match &self.current_function {
            None => {
                panic!("Cannot end function definition when there isn't one open.");
            }
            Some(def) => match self.function_definitions.get_mut(&def.name) {
                None => {
                    self.function_definitions.insert(
                        def.name.clone(),
                        vec![(function, self.current_function.take().unwrap())],
                    );
                }
                Some(existing) => existing.push((function, self.current_function.take().unwrap())),
            },
        }
    }
}