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         // TO DO : ADD SYMBOL, FIXNUM, FLOATNUM
  15         enum kind {
  16                 e_ATOM = 0,
  17                 e_CONS,
  18                 e_FUNC,
  19                 e_LAMBDA,
  20                 e_SYMBOL
  21         };
  22
  23         struct atom {
  24                 std::string name;
  25
  26                 atom(const std::string& n) : name(n) {
  27                 }
  28         };
  29
  30         struct cons {
  31                 boost::shared_ptr<object> car;
  32                 boost::shared_ptr<object> cdr;
  33
  34                 cons(boost::shared_ptr<object> first, boost::shared_ptr<object> second) : car(first), cdr(second) {
  35
  36                 }
  37         };
  38
  39         typedef boost::function< boost::shared_ptr<object> (boost::shared_ptr<object>,boost::shared_ptr<object>) > lisp_func;
  40
  41         struct func {
  42                 lisp_func fn;
  43
  44                 func(const lisp_func& f) : fn(f) {
  45
  46                 }
  47         };
  48
  49         struct lambda {
  50                 boost::shared_ptr<object> args;
  51                 boost::shared_ptr<object> sexp;
  52
  53                 lambda(boost::shared_ptr<object> a, boost::shared_ptr<object> s) : args(a), sexp(s) {
  54
  55                 }
  56         };
  57
  58         struct symbol {
  59                 boost::shared_ptr<object> value;
  60
  61                 symbol(boost::shared_ptr<object> v) : value(v) {
  62                 }
  63         };
  64
  65         typedef boost::variant< atom, cons, func, lambda, symbol > base_object;
  66
  67         struct object : public base_object {
  68
  69                 object(const base_object&b) : base_object(b) {
  70
  71                 }
  72
  73                 object(const std::string&s) : base_object(atom(s)) {
  74
  75                 }
  76
  77         };
  78
  79         extern boost::shared_ptr<object> tee;
  80         extern boost::shared_ptr<object> nil;
  81
  82 };
  83
  84 #endif