Initial commit

1 files changed, 84 insertions, 0 deletions

diff --git a/src/stages/compiler.rs b/src/stages/compiler.rs
new file mode 100644
index 0000000..97bf20c
--- /dev/null
+++ b/src/stages/compiler.rs
@@ -0,0 +1,84 @@
+use crate::*;
+
+use assembler::SymbolRole::*;
+use assembler::DefinitionType::*;
+
+
+pub fn new_compiler() -> Compiler {
+    Compiler::new(parse_symbols, push_code)
+}
+
+
+/// Parse all symbols from a source code string.
+pub fn parse_symbols(source_code: &str, path: Option<&Path>) -> Option<Vec<Symbol>> {
+    let syntactic = match parse_syntactic(source_code, path) {
+        Ok(syntactic) => syntactic,
+        Err(_) => return None,
+    };
+    Some(SymbolParser::new().parse(&syntactic))
+}
+
+/// Push source code to a source compilation string.
+pub fn push_code(compilation: &mut String, source_file: &SourceFile) {
+    // Skip blank files.
+    let source_code = &source_file.source_code;
+    if source_code.chars().all(|c| c.is_whitespace()) { return; }
+    // Ensure that the previous section is followed by two newline characters.
+    if !compilation.is_empty() {
+        if !compilation.ends_with('\n') { compilation.push('\n'); }
+        if !compilation.ends_with("\n\n") { compilation.push('\n'); }
+    }
+    // Push a path comment and the source code.
+    let path_str = source_file.path.as_os_str().to_string_lossy();
+    let path_comment = format!("(: {path_str} )\n");
+    compilation.push_str(&path_comment);
+    compilation.push_str(&source_code);
+}
+
+
+// Extract symbol definitions from a list of syntactic tokens.
+pub struct SymbolParser {
+    pub symbols: Vec<Symbol>,
+}
+
+impl SymbolParser {
+    pub fn new() -> Self {
+        Self {
+            symbols: Vec::new(),
+        }
+    }
+
+    fn record_symbol(&mut self, name: &str, source: &SourceSpan, role: SymbolRole) {
+        let name = name.to_string();
+        let namespace = Vec::new();
+        let source = source.to_owned();
+        self.symbols.push(Symbol { name, namespace, source, role });
+    }
+
+    pub fn parse(mut self, syntactic: &[Tracked<SyntacticToken>]) -> Vec<Symbol> {
+        for token in syntactic {
+            match &token.value {
+                SyntacticToken::MacroDefinition(definition) => {
+                    self.record_symbol(
+                        &definition.name,
+                        &definition.name.source,
+                        Definition(MustPrecedeReference),
+                    );
+                    for token in &definition.body {
+                        if let SyntacticToken::Symbol(name) = &token.value {
+                            self.record_symbol(&name, &token.source, Reference);
+                        }
+                    }
+                }
+                SyntacticToken::LabelDefinition(name) => {
+                    self.record_symbol(&name, &token.source, Definition(CanFollowReference));
+                }
+                SyntacticToken::Symbol(name) => {
+                    self.record_symbol(&name, &token.source, Reference);
+                }
+                _ => (),
+            }
+        }
+        return self.symbols;
+    }
+}