lisp.h

   1 #ifndef LISP_H_INCLUDED
   2 #define LISP_H_INCLUDED
   3
   4 namespace lisp {
   5
   6         /* We begin by defining four types of objects we will be
   7          * using. CONS is what we use to hold lists, ATOMs are letters or
   8          * digits anything that is not used by LISP, a FUNC holds a
   9          * reference to a C function and a LAMBDA holds a lambda
  10          * expression. */
  11
  12         struct object;
  13
  14         enum kind {
  15                 e_ATOM = 0,
  16                 e_CONS,
  17                 e_FUNC,
  18                 e_LAMBDA
  19         };
  20
  21         struct atom {
  22                 std::string name;
  23
  24                 atom(const std::string& n) : name(n) {
  25                 }
  26         };
  27
  28         struct cons {
  29                 boost::shared_ptr<object> car;
  30                 boost::shared_ptr<object> cdr;
  31
  32                 cons(boost::shared_ptr<object> first, boost::shared_ptr<object> second) : car(first), cdr(second) {
  33
  34                 }
  35         };
  36
  37         typedef boost::function< boost::shared_ptr<object> (boost::shared_ptr<object>,boost::shared_ptr<object>) > lisp_func;
  38
  39         struct func {
  40                 lisp_func fn;
  41
  42                 func(const lisp_func& f) : fn(f) {
  43
  44                 }
  45         };
  46
  47         struct lambda {
  48                 boost::shared_ptr<object> args;
  49                 boost::shared_ptr<object> sexp;
  50
  51                 lambda(boost::shared_ptr<object> a, boost::shared_ptr<object> s) : args(a), sexp(s) {
  52
  53                 }
  54         };
  55
  56         typedef boost::variant< atom, cons, func, lambda > base_object;
  57
  58         struct object : public base_object {
  59                 object(base_object&b) : base_object(b) {
  60
  61                 }
  62                 object(const std::string&s) : base_object(atom(s)) {
  63
  64                 }
  65                 object(const lisp::cons& c) : base_object(c) {
  66
  67                 }
  68                 object(const lisp::lambda& l) : base_object(l) {
  69
  70                 }
  71                 object(const lisp::lisp_func& f) : base_object(f) {
  72
  73                 }
  74         };
  75
  76 };
  77
  78 #endif