updates

Author: simontran7

Cargo.lock

@@ -1,7 +1,8 @@
 [package]
 name = "crawfish"
-version = "0.1.0"
+version = "0.0.1"
 edition = "2024"
 
 [dependencies]
 ariadne = "0.4"
+inkwell = { version = "0.8.0", features = ["llvm20-1"] }

Cargo.toml

@@ -7,29 +7,42 @@
 > [!CAUTION]
 > The compiler can't compile crawfish programs yet.
 
-## Installation (building from source)
+## Installation (Building from Source)
 
-### Requirements
+### Dependencies
 
-- [Rust Compiler](https://www.rust-lang.org/)
-- [LLVM](https://llvm.org/)
+- Rust Compiler
+- LLVM
 
 ### Steps
 
-1. Git clone the repository
+1. Install Rust
+```sh
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+2. Install `llvm-config-20` and `libpolly-20-dev`
+```sh
+wget https://apt.llvm.org/llvm.sh
+chmod +x llvm.sh
+sudo ./llvm.sh 20
+sudo apt install libpolly-20-dev
+```
+
+3. Git clone the repository
 
 ```sh
 git clone https://github.com/simontran7/crawfish.git
 ```
 
-2. `cd` into the `crawfish/` directory, then build the project with GNU Make
+4. `cd` into the `crawfish/` directory, then build the project with GNU Make
 
 ```sh
 cd crawfish/
-make
+cargo build --release
 ```
 
-4. Move the `build/crawfish` compiler binary to a desired location (e.g. in `/Users/<your name>`), then add it to your `PATH` by adding the following line to your `.bashrc` file
+5. Move the `target/release/crawfish` binary to a desired location (e.g. in `/Users/<your name>`), then add it to your `PATH` by adding the following line to your `.bashrc` file
 
 ```sh
 # in your .bashrc
@@ -38,4 +51,18 @@ export PATH=$PATH:<path to the crawfish compiler executable>
 
 ## Usage
 
+```
+Crawfish compiler
+
+Usage:
+    crawfish [OPTIONS] <COMMAND> [ARGS...]
+
+Command:
+    compile <file>.crw            compile the current file
+
+Options:
+    -h, --help                    print possible commands
+    -v, --version                 print compiler version
+```
+
 See `docs/tour-of-crawfish.md` for a tour of the language.

README.md

@@ -158,9 +158,9 @@ fn bar() {
 fn baz() { ... }  // this still parses fine!
 ```
 
-### Lexer
+### Tokenizer
 
-The lexer is hand-written, and conceptually a deterministic finite automaton (DFA) that recognizes a regular language. Lexer generators or regular expressions are convenient, but don't offer as much flexibility as a hand-written lexer. It's also another dependency to maintain.
+The tokenizer is hand-written, and conceptually a deterministic finite automaton (DFA) that recognizes a regular language. Lexer generators or regular expressions are convenient, but don't offer as much flexibility as a hand-written tokenizer. It's also another dependency to maintain.
 
 Structurally, the lexer is a simple struct with two fields:
 - `source`: a string slice of the user's source code, useful for accurate span tracking and error messages

docs/ARCHITECTURE.md

@@ -371,24 +371,6 @@ interface <interface name>[T] {
 | Math            | `ln()`     |
 | Math            | `pow_e()`  |
 
-### Containers and Algorithms
-
-- `ArrayList`: a list backed by a dynamic array
-- `SinglyLinkedList`: a list backed by a singly linked list
-- `DoublyLinkedList`: a list backed by a doubly linked list
-- `ArrayStack`: a stack backed by a dynamic array
-- `LinkedStack`: a stack backed by a singly linked list
-- `ArrayQueue`: a queue backed by a circular dynamic array
-- `LinkedQueue`: a queue backed by a singly linked list
-- `MinHeapPriorityQueue`: a priority queue backed by a min binary heap
-- `MaxHeapPriorityQueue`: a priority queue backed by a max binary heap
-- `HashMap`: a map backed by a hash table
-- `HashSet`: a set backed by a hash table
-- `RBTreeOrderedMap`: a ordered map backed by a Red-Black Tree
-- `RBTreeOrderedSet`: an ordered set backed by a Red-Black Tree
-- `sort`: driftsort stable sorting algorithm
-- `binary_search`: binary search algorithm
-
 ## Imports
 
 ```

docs/language-design.md

@@ -1,30 +1,30 @@
 use std::collections::HashMap;
 
-/// Interner Data Structure which interns literals and identifiers.
+/// Interner which interns literals and identifiers.
 pub struct Interner {
-    // string id -> string literal
+    // symbols -> string literal
     strings: Vec<String>,
-    // string literal -> string id
-    ids: HashMap<String, Symbol>,
+    // string literal -> symbols
+    symbols: HashMap<String, Symbol>,
 }
 
 impl Interner {
     /// Creates and returns an instance of `Interner`.
     pub fn new() -> Interner {
         Interner {
             strings: Vec::new(),
-            ids: HashMap::new(),
+            symbols: HashMap::new(),
         }
     }
 
     /// Interns `string` and returns a string id.
     pub fn intern(&mut self, string: &str) -> Symbol {
-        if let Some(&id) = self.ids.get(string) {
+        if let Some(&id) = self.symbols.get(string) {
             return id;
         }
         let id = Symbol(self.strings.len() as u32);
         self.strings.push(string.to_owned());
-        self.ids.insert(string.to_owned(), id);
+        self.symbols.insert(string.to_owned(), id);
         id
     }
 
@@ -49,8 +49,8 @@ mod tests {
     fn requirement_1() {
         let s = "foo";
         let mut interner = Interner::new();
-        let id = interner.intern(s);
-        assert_eq!(s, interner.resolve(id).unwrap());
+        let symbol = interner.intern(s);
+        assert_eq!(s, interner.resolve(symbol).unwrap());
     }
 
     // If two strings are equal, then they should have the same id.

src/driver/arg_parser.rs src/arg_parser.rssrc/driver/arg_parser.rs renamed to src/arg_parser.rs

@@ -1,3 +1,5 @@
+use core::fmt;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Span {
     start: u32,
@@ -23,3 +25,9 @@ impl From<&Span> for std::ops::Range<usize> {
         span.start as usize..span.end as usize
     }
 }
+
+impl fmt::Display for Span {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "[{}, {})", self.start, self.end)
+    }
+}