Implements parsing a lisp program into an ast.

Initial commit for a lisp interpreter in modern c++.
Got parsing into an ast implemented. Next is evaluation.

I make heavy use of boost for its variant, string, and lexical_cast libraries.

Author: sdab

README.md

@@ -0,0 +1,5 @@
+
+
+Requirements:
+* gcc (TODO: version?)
+* boost (sudo apt-get install libboost-all-dev)

lisp++.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include "lisp++.h"
+#include "lispUtils.h"
+#include <boost/algorithm/string.hpp>
+
+// Tokenize the input string and fill tokens with it
+template<typename StrVec>
+void tokenize(StrVec& tokens, const std::string& inp) {
+  // copy tokenize string since we need to modify it
+  std::string str(inp);
+
+  // add space to parens
+  boost::replace_all(str,"("," ( ");
+  boost::replace_all(str,")"," ) ");
+  boost::trim(str);
+  
+  // split by space (compress extra spaces)
+  boost::split(tokens, 
+               str, 
+               boost::is_any_of(" "),
+               boost::token_compress_on);
+}
+
+Expression atom(const std::string& val) {
+  // attempts to parse as int
+  try
+  {
+    return boost::lexical_cast<int>(val);
+  }
+  catch(const boost::bad_lexical_cast &) {}
+
+  // attempts to parse as double
+  try
+  {
+    return boost::lexical_cast<double>(val);
+  }
+  catch(const boost::bad_lexical_cast &) {}
+
+  // just a string then
+  return val;
+}
+
+// Read the tokens into an ast
+template<typename InputIterator>
+Expression read_from_tokens(InputIterator& first, InputIterator& last) {
+  if (first == last) {
+    throw std::runtime_error("Syntax error: unexpected EOF while reading");
+  }
+
+  if ("(" == *first) {
+    List out;
+    while ( *(++first) != ")" ) {
+      out.push_back(read_from_tokens(first,last));
+    }
+    return out;
+  } else if (")" == *first) {
+    throw std::runtime_error("Syntax error: unexpected ')'");
+  }
+  else {
+    return atom(*first);
+  }
+}
+
+Expression parse(const std::string& program) {
+  std::vector<std::string> tokens;
+  tokenize(tokens, program);
+
+  // take copies of iterators so we can pass by reference
+  auto begin = tokens.begin();
+  auto end = tokens.end();
+  return read_from_tokens(begin,end);
+}
+
+
+int main() {
+
+  auto program = "(foo (bar baz) (print hello world) (+ 1 1.5))";
+  std::cout << "program:" << program << std::endl;
+
+  print_visitor visitor;
+  Expression ast = parse(program);
+  std::cout << "ast: " << ::apply_visitor(visitor,ast) << std::endl;
+
+  return 0;
+}

lisp++.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+#include <boost/variant.hpp>
+
+// define relevant types
+typedef boost::variant<int,double> Number;
+typedef std::string Symbol;
+
+
+typedef boost::make_recursive_variant<Number, Symbol, std::vector< boost::recursive_variant_ > >::type Expression;
+
+typedef std::vector<Expression> List;
+
+
+// forward declare functions
+Expression atom(const std::string& val);
+
+template<typename InputIterator>
+Expression read_from_tokens(InputIterator& first, InputIterator& last);
+
+template<typename StrVec>
+void tokenize(StrVec& tokens, const std::string& inp);
+
+Expression parse(const std::string& program);
+
+

lispUtils.h

@@ -0,0 +1,45 @@
+#include <boost/lexical_cast.hpp>
+
+// need this to use visitor on vector
+template<typename Visitor, typename Element>
+  typename Visitor::result_type
+  apply_visitor(const Visitor& visitor, const Element& operand) {
+  return visitor(operand);
+}
+
+class print_visitor
+: public boost::static_visitor<std::string>
+{
+public:
+
+  std::string operator()( const std::string& str ) const
+  {
+    return "'"+str+"'";
+  }
+
+  template<typename T>
+    std::string operator()( const T& val ) const
+  {
+    return boost::lexical_cast<std::string>(val);
+  }
+
+  std::string operator()( const Expression& val ) const
+  {
+    return boost::apply_visitor(*this,val);
+  }
+
+  template<typename T>
+    std::string operator()( const std::vector<T>& list ) const
+  {
+    std::string out;
+    out += "(";
+    for (auto elem : list) {
+      out += " "+::apply_visitor(*this,elem);
+    }
+    out += ")";
+
+    return out;
+  }
+
+};
+

makefile

@@ -0,0 +1,19 @@
+CC      = g++
+CFLAGS  = -std=c++11 -g
+LDFLAGS = 
+
+all: lisp++ clean
+
+lisp++: lisp++.o
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+lisp++.o: lisp++.cpp
+	$(CC) -c $(CFLAGS) $<
+
+.PHONY: clean cleanest
+
+clean:
+	rm *.o
+
+cleanest: clean
+	rm lisp++