Start on a Rust implementation

Author: ararslan

Makefile

@@ -1,9 +1,32 @@
-CC=g++
-SOURCES=./src/qqq.cpp
-EXECUTABLE=./bin/qqq
+OS ?= $(shell uname)
 
-all:
-	$(CC) $(SOURCES) -o $(EXECUTABLE) -Wall -O0
+# Assume Visual C++ on Windows
+# Environments like Cygwin will hopefully fall through and pick up the
+# appropriate Unix-like options
+ifeq ($(OS),Windows_NT)
+EXE := bin\qqq.exe
+OUT := /out:$(EXE)
+CXX := cl
+CXXFLAGS := /EHsc /W4
+else
+EXE := bin/qqq
+OUT := -o $(EXE)
+CXXFLAGS := -Wall -O0
+ifneq (,$(findstring $(OS),Darwin FreeBSD))
+CXX := clang++
+else
+CXX := g++
+endif # macOS or FreeBSD
+endif # Windows
+
+setup:
+	-mkdir bin
+
+cpp: setup
+	$(CXX) cpp/qqq.cpp $(OUT) $(CXXFLAGS)
+
+rust: setup
+	rustc rust/main.rs $(OUT)
 
 clean:
-	rm $(EXECUTABLE)
+	-rm $(EXE)

bin/.gitkeep

@@ -0,0 +1,96 @@
+use std::io::{stdin, stdout, Read, Write};
+
+fn parse_instructions(code: String) -> Vec<char> {
+    let mut instructions = Vec::new();
+    let mut is_open = true;
+    let mut bracket_depth = 0;
+    while let Some(c) = code.chars().next() {
+        match c {
+            '!' | '?' | '.' | ',' | '-' | ';' => instructions.push(c),
+            '\'' => {
+                is_open = !is_open;
+            },
+            '"' if is_open => {
+                bracket_depth += 1;
+                instructions.push('[');
+            },
+            '"' if !is_open => {
+                bracket_depth -= 1;
+                instructions.push(']');
+            },
+            _ => continue,
+        }
+    }
+    if bracket_depth != 0 {
+        panic!("Unmatched quotes detected!")
+    }
+    instructions
+}
+
+fn evaluate(instructions: Vec<char>) {
+    if instructions.is_empty() {
+        return;
+    }
+    let mut tape = vec![0x00];
+    let mut ins_ptr = 0; // instruction pointer: index in `instructions` of current instruction
+    let mut mem_ptr = 0; // memory pointer: index in `tape` of current memory cell
+    while ins_ptr != instructions.len() - 1 {
+        match instructions[ins_ptr] {
+            '-' => {
+                // can't travel left of the starting cell
+                if mem_ptr != 0 { mem_ptr -= 1 }
+            },
+            ';' => {
+                mem_ptr += 1;
+                // lazily grow the tape as needed
+                if mem_ptr > tape.len() - 1 { tape.resize(mem_ptr + 1, 0x00) }
+            },
+            '.' => {
+                tape[mem_ptr] += 0x01;
+            },
+            ',' => {
+                tape[mem_ptr] -= 0x01;
+            },
+            '?' => {
+                let input: Option<u8> = io::stdin().bytes()
+                                                   .next()
+                                                   .map(|b| b as u8)
+                                                   .expect("No input received");
+                tape[mem_ptr] = input.unwrap();
+            },
+            '!' => {
+                // print as char if printable ASCII, otherwise print raw
+                if tape[mem_ptr] >= 0x20 && tape[mem_ptr] <= 0x7e {
+                    print!("{}", tape[mem_ptr] as char)
+                } else {
+                    print!("{}", tape[mem_ptr])
+                }
+                io::stdout().flush().unwrap();
+            },
+            '[' => {
+                if tape[mem_ptr] == 0x00 {
+                    // advance to matching close bracket
+                    while instructions[ins_ptr] != ']' {
+                        ins_ptr += 1
+                    }
+                }
+                continue
+            },
+            ']' => {
+                if tape[mem_ptr] == 0x00 {
+                    // move back to just before the matching open bracket
+                    while instructions[ins_ptr] != '[' {
+                        ins_ptr -= 1
+                    }
+                    ins_ptr -= 1
+                }
+                continue
+            }
+        }
+        ins_ptr += 1
+    }
+}
+
+fn main() {
+    // TODO
+}