Basic REPL.

Author: Jason P. Barmparesos

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "rlisp"
-version = "0.1.0"
+name = "rscheme"
+version = "0.0.1"
 authors = ["Jason P. Barmparesos <[email protected]>"]
 
 [dependencies]

README.md

@@ -1,9 +1,5 @@
-# rlisp
-A simple Lisp interpreter written in Rust.
-
-## What dialect of Lisp does it recognize?
-This interpreter does not adhere to any specific Lisp-like specification. Nevertheless, its syntax closely resembles a 
-simplified version of the Scheme variant.
+# rscheme
+A simple Scheme interpreter written in Rust.
 
 ## Why?
 Why not? In all seriousness, this project is not destined to be a commercial intepreter. Instead it aims to be a
@@ -12,3 +8,15 @@ simple and modifiable piece of software to assist the teaching of compiler/inter
 ## How can I try it?
 Just clone the sources and type `cargo run` inside the repository folder. By default, the interpreter reads and executes
 `test-code.scm` but changing that should be trivial (simply edit `src/main.rs`).
+
+## Features
+- [x] Basic arithmetic operations.
+- [x] Variables.
+- [x] Lambda expressions.
+- [x] Recursion.
+- [ ] Scheme function declaration syntax.
+- [ ] REPL prompt.
+- [ ] `display` procedure.
+- [ ] Lists.
+- [ ] String manipulation procedures.
+- [ ] Foreign function calls.

src/expression.rs

@@ -43,18 +43,18 @@ impl fmt::Display for Procedure {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
             Procedure::UserDefined { arguments: _, body: _ } => {
-                write!(f, "#procedure:user-defined")
+                write!(f, "#<procedure>:user-defined")
             }
-            Procedure::Sum => write!(f, "#procedure:+"),
-            Procedure::Difference => write!(f, "#procedure:-"),
-            Procedure::Product => write!(f, "#procedure:*"),
-            Procedure::Division => write!(f, "#procedure:/"),
-            Procedure::Equal => write!(f, "#procedure:="),
-            Procedure::Less => write!(f, "#procedure:<"),
-            Procedure::Greater => write!(f, "#procedure:>"),
-            Procedure::And => write!(f, "#procedure:and"),
-            Procedure::Or => write!(f, "#procedure:or"),
-            Procedure::Not => write!(f, "#procedure:not"),
+            Procedure::Sum => write!(f, "#<procedure>:+"),
+            Procedure::Difference => write!(f, "#<procedure>:-"),
+            Procedure::Product => write!(f, "#<procedure>:*"),
+            Procedure::Division => write!(f, "#<procedure>:/"),
+            Procedure::Equal => write!(f, "#<procedure>:="),
+            Procedure::Less => write!(f, "#<procedure>:<"),
+            Procedure::Greater => write!(f, "#<procedure>:>"),
+            Procedure::And => write!(f, "#<procedure>:and"),
+            Procedure::Or => write!(f, "#<procedure>:or"),
+            Procedure::Not => write!(f, "#<procedure>:not"),
         }
     }
 }
@@ -71,7 +71,7 @@ impl fmt::Display for LResult {
         match *self {
             LResult::Value(ref v) => write!(f, "{}", v),
             LResult::Procedure(ref p) => write!(f, "{}", p),
-            LResult::Undefined => write!(f, "#undefined"),
+            LResult::Undefined => write!(f, "#<undefined>"),
         }
     }
 }

src/main.rs

@@ -6,16 +6,52 @@ mod program;
 
 use std::fs::File;
 use std::io::prelude::*;
-use list::*;
+use std::io;
+use std::env;
 use program::Program;
 
+fn get_file_list() -> Vec<String> {
+    let mut args = env::args();
+    args.next(); // Skip the program name.
+    let mut files:Vec<String> = Vec::new();
+    for arg in args {
+        files.push(arg.clone());
+    }
+    files
+}
+
 fn main() {
-    let mut source_file = File::open("test-code.scm").unwrap();
-    let mut code = String::new();
-    source_file.read_to_string(&mut code).unwrap();
-    let tokens = parser::parse_primitives(&code);
-    let mut token_iter = tokens.into_iter();
-    let list_tree = ListNode::from_primitive_tokens(&mut token_iter);
+    println!("rScheme - A minimal Scheme intepreter written in Rust (v0.0.1 Alpha)");
+    println!("Copyright (C) 2016 School of Engineering - Aristotle University of Thessaloniki");
+    println!("---------------");
+    println!("Type `exit` to quit the REPL environment. Statements can't span multiple lines.");
+    println!("Loading the standard library...");
+
     let mut program = Program::new();
-    program.run(&list_tree);
+    let mut files = vec!["stdlib.scm".to_string()];
+    files.append(&mut get_file_list());
+    for path in files {
+        match File::open(path.clone()) {
+            Ok(mut file) => {
+                let mut code = String::new();
+                file.read_to_string(&mut code).unwrap();
+                program.run_code(code, true);
+            }
+            Err(_) => println!("Failed to open file {}.", path)
+        }
+    }
+
+    println!("---------------");
+    loop {
+        print!("]=> ");
+        io::stdout().flush().unwrap();
+        let mut accum = String::new();
+        io::stdin().read_line(&mut accum).unwrap();
+        if accum.trim() == "exit" {
+            println!("Goodbye!");
+            break;
+        }
+        program.run_code(accum, false);
+        println!("");
+    }
 }

src/program.rs

@@ -1,5 +1,6 @@
 
 use std::collections::HashMap;
+use parser;
 use list::ListNode;
 use expression::*;
 use std::cmp::Ordering;
@@ -10,30 +11,22 @@ pub struct Program {
 
 impl Program {
     pub fn new() -> Program {
-        Program { stack: Vec::new() }
+        let mut p = Program { stack: Vec::new() };
+        p.initialize();
+        p
     }
 
-    pub fn run(&mut self, root: &ListNode) {
-        // Add the basic functions.
-        let mut basic_map: HashMap<String, LResult> = HashMap::new();
-        basic_map.insert("+".to_string(), LResult::Procedure(Procedure::Sum));
-        basic_map.insert("-".to_string(), LResult::Procedure(Procedure::Difference));
-        basic_map.insert("*".to_string(), LResult::Procedure(Procedure::Product));
-        basic_map.insert("/".to_string(), LResult::Procedure(Procedure::Division));
-        basic_map.insert("=".to_string(), LResult::Procedure(Procedure::Equal));
-        basic_map.insert("<".to_string(), LResult::Procedure(Procedure::Less));
-        basic_map.insert(">".to_string(), LResult::Procedure(Procedure::Greater));
-        basic_map.insert("and".to_string(), LResult::Procedure(Procedure::And));
-        basic_map.insert("or".to_string(), LResult::Procedure(Procedure::Or));
-        basic_map.insert("not".to_string(), LResult::Procedure(Procedure::Not));
-        self.stack.push(basic_map);
-        match *root {
+    pub fn run_code(&mut self, code: String, silent:bool) {
+        let tokens = parser::parse_primitives(&code);
+        let mut token_iter = tokens.into_iter();
+        let list_tree = ListNode::from_primitive_tokens(&mut token_iter);
+        match list_tree {
             ListNode::Node(ref v) => {
                 for e in v {
                     match Expression::from_list(e) {
                         Ok(res) => {
                             match self.evaluate_expression(&res) {
-                                Ok(result) => println!("{}", result),
+                                Ok(result) => if !silent { println!("{}", result) },
                                 Err(s) => println!("Runtime error: {}", s),
                             }
                         }
@@ -48,6 +41,22 @@ impl Program {
         }
     }
 
+    pub fn initialize(&mut self) {
+        // Add the basic functions.
+        let mut basic_map: HashMap<String, LResult> = HashMap::new();
+        basic_map.insert("+".to_string(), LResult::Procedure(Procedure::Sum));
+        basic_map.insert("-".to_string(), LResult::Procedure(Procedure::Difference));
+        basic_map.insert("*".to_string(), LResult::Procedure(Procedure::Product));
+        basic_map.insert("/".to_string(), LResult::Procedure(Procedure::Division));
+        basic_map.insert("=".to_string(), LResult::Procedure(Procedure::Equal));
+        basic_map.insert("<".to_string(), LResult::Procedure(Procedure::Less));
+        basic_map.insert(">".to_string(), LResult::Procedure(Procedure::Greater));
+        basic_map.insert("and".to_string(), LResult::Procedure(Procedure::And));
+        basic_map.insert("or".to_string(), LResult::Procedure(Procedure::Or));
+        basic_map.insert("not".to_string(), LResult::Procedure(Procedure::Not));
+        self.stack.push(basic_map);
+    }
+
     fn find_identifier(&self, name: &str) -> Option<&LResult> {
         let stack_ref = &self.stack;
         for name_stack in stack_ref.into_iter().rev() {

stdlib.scm

@@ -0,0 +1,12 @@
+; rScheme standard library.
+
+(define pi 3.14159)
+
+(define <= (lambda (a b)
+  (or (< a b) (= a b))))
+
+(define >= (lambda (a b)
+  (or (> a b) (= a b))))
+
+(define abs (lambda (x)
+  (if (< x 0) (- x) x)))