LispObj.h

   1
   2 #ifndef H_LISP_OBJ
   3 #define H_LISP_OBJ
   4
   5 #include <cassert>
   6 #include <ostream>
   7 #include <vector>
   8 #include <string>
   9
  10 namespace Lisp
  11 {
  12
  13     class Obj;
  14     class NIL;
  15     class Cons;
  16     class String;
  17     class Fixnum;
  18     class Floatnum;
  19     class Symbol;
  20     class Package;
  21     class Func;
  22
  23
  24     class Obj
  25     {
  26         public:
  27
  28             enum eObjectType
  29             {
  30                 eBaseObj  = 0,
  31                 eNullObj,
  32                 eStringObj,
  33                 eConsObj,
  34                 eFixnumObj,
  35                 eFloatnumObj,
  36                 eSymbolObj,
  37                 ePackageObj,
  38                 eFunctionObj
  39             };
  40
  41             /* api any lispobj must implement */
  42             virtual eObjectType getObjectType() const = 0;
  43
  44             /* create a fresh one */
  45             virtual Obj* create(void) const = 0;
  46
  47             /* make a copy */
  48             virtual Obj* clone(void) const = 0;
  49
  50             /* print to stream */
  51             virtual void print(std::ostream& out) const = 0;
  52
  53             /* check a string to see if it represents this kind of object */
  54             //virtual bool identify(std::string in) const = 0;
  55
  56             /* compare by value */
  57             virtual bool operator==(const Obj* other) = 0;
  58
  59             inline bool hasRef() {
  60                 return (references_ != 0);
  61             }
  62
  63             inline void incRef() {
  64                 references_++;
  65             }
  66
  67             inline void decRef() {
  68                 assert(references_ != 0);
  69                 references_--;
  70             }
  71
  72
  73         protected:
  74             Obj() {};
  75             Obj(const Obj& other) {};
  76             Obj& operator=(const Obj& other) {};
  77
  78             std::size_t references_;
  79
  80     }; /* class Obj */
  81
  82         typedef long FixnumValue;
  83         typedef double FloatnumValue;
  84         typedef std::string StringValue;
  85
  86     class Env;
  87
  88 /** The lisp environment: an associative container that associates symbols
  89     with their properties **/
  90
  91     class Env {
  92
  93         private:
  94
  95             /** parent namespace **/
  96             Env *parent_;
  97
  98             // to do -- this needs to be a hash table or something
  99             // with faster lookup.
 100             typedef std::pair<Obj*,Obj*> Binding;
 101
 102             std::vector<Binding> env_;
 103
 104             /**
 105              * detect if a symbol is bound
 106              */
 107             class IsBound
 108             {
 109                 private:
 110                     Obj* bound_;
 111                 public:
 112                     IsBound(Obj* bound) :
 113                         bound_(bound)
 114                     {}
 115
 116                     bool operator()(const Env::Binding& binding) {
 117                         return (bound_ == binding.first);
 118                     }
 119             }; /* class IsBound */
 120
 121             class DecBindingRef
 122             {
 123                 public:
 124                     DecBindingRef() {};
 125                     void operator()(const Env::Binding& binding) {
 126                         binding.first->decRef();
 127                         binding.second->decRef();
 128                         if (!binding.first->hasRef())
 129                             delete binding.first;
 130                         if (!binding.second->hasRef())
 131                             delete binding.second;
 132                     }
 133             };
 134
 135
 136             static Env *root_environment;
 137             static Env *current_environment;
 138
 139         public:
 140
 141
 142             Env() :
 143                 parent_(NULL)
 144             {
 145                 root_environment = this;
 146                 current_environment = this;
 147             };
 148
 149             Env(Env* parent) :
 150                 parent_(parent)
 151             {
 152             }
 153
 154             std::size_t add(Obj* obj)
 155             {
 156                 Binding bind(obj, NULL);
 157                 obj->incRef();
 158                 std::size_t result = env_.size();
 159                 env_.push_back(bind);
 160                 return result;
 161             }
 162
 163             // test if object has been bound by value
 164             bool isBound(Obj* obj)
 165             {
 166                 std::vector<Binding>::iterator result = std::find_if(env_.begin(), env_.end(), IsBound(obj));
 167                 if ((result == env_.end()) && (parent_ != NULL))
 168                     return parent_->isBound(obj);
 169                 else
 170                     return (result != env_.end());
 171             }
 172
 173
 174             //! return pointer to bound object that has same value
 175             Obj* bound(Obj* obj)
 176             {
 177                 std::vector<Binding>::iterator result;
 178                 result = std::find_if(env_.begin(), env_.end(), IsBound(obj));
 179                 if (result == env_.end()) {
 180                     if (parent_ != NULL)
 181                     {
 182                         return parent_->bound(obj);
 183                     } else
 184                         return NULL;
 185                 } else {
 186                     return result->first;
 187                 }
 188             }
 189
 190             // return pointer to bound value
 191             Obj* boundto(Obj* obj)
 192             {
 193                 std::vector<Binding>::iterator result;
 194                 result = std::find_if(env_.begin(), env_.end(), IsBound(obj));
 195                 if (result == env_.end())
 196                     if (parent_ != NULL)
 197                         return parent_->boundto(obj);
 198                     else
 199                         return NULL;
 200                 else
 201                     return result->second;
 202             }
 203
 204
 205             std::size_t bind(Obj *value, Obj* binding)
 206             {
 207                 Obj *bindee = bound(value);
 208                 if (bindee == NULL)
 209                     bindee = value;
 210                 Binding bind(bindee, binding);
 211                 bindee->incRef();
 212                 binding->incRef();
 213                 std::size_t result = env_.size();
 214                 env_.push_back(bind);
 215                 return result;
 216             }
 217
 218             void unbind(Obj *value)
 219             {
 220                 std::vector<Binding>::iterator binder;
 221                 binder = std::find_if(env_.begin(), env_.end(), IsBound(value));
 222                 if (binder == env_.end()) {
 223                     if (parent_ != NULL)
 224                         parent_->unbind(value);
 225                     else
 226                         return;
 227                 }
 228                 else {
 229                     DecBindingRef finalizer;
 230                     finalizer(*binder);
 231                     env_.erase(binder);
 232                 }
 233                 return;
 234             }
 235
 236             Env *child(void)
 237             {
 238                 current_environment = new Env(this);
 239                 return current_environment;
 240             }
 241
 242             virtual ~Env()
 243             {
 244                 DecBindingRef finalizer;
 245                 for_each(env_.begin(), env_.end(), finalizer);
 246
 247                 assert(this == Env::current_environment);
 248                 Env::current_environment = parent_;
 249             }
 250
 251     };
 252
 253 }
 254
 255
 256 #endif
 257
 258