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 <map>
   9 #include <string>
  10 #include <algorithm>
  11 #include <boost/variant.hpp>
  12 #include <boost/tr1/memory.hpp>
  13
  14 namespace Lisp
  15 {
  16
  17         typedef signed char s8;
  18         typedef signed short s16;
  19         typedef signed int s32;
  20         typedef signed long s64;
  21         typedef signed long long s128;
  22
  23         typedef unsigned char u8;
  24         typedef unsigned short u16;
  25         typedef unsigned int u32;
  26         typedef unsigned long u64;
  27         typedef unsigned long long u128;
  28
  29         typedef float f32;
  30         typedef double f64;
  31
  32
  33
  34 // placeholder type
  35         struct NullType {
  36         private:
  37                 const u32 dead_;
  38         public:
  39                 NullType() : dead_(0xDEADBEEF)
  40                 {
  41
  42                 }
  43         };
  44
  45
  46         template <typename T> class TUnboxedType
  47         {
  48         private:
  49                 T data_;
  50         public:
  51                 TUnboxedType() {
  52
  53                 }
  54
  55                 TUnboxedType(const TUnboxedType<T>& other) : data_(other.data_)
  56                 {
  57
  58                 }
  59
  60                 T& operator=(const TUnboxedType<T>& other)
  61                 {
  62                         data_ = other.data_;
  63                 }
  64
  65                 operator T()
  66                 {
  67                         return data_;
  68                 }
  69
  70                 const bool isBoxed() const
  71                 {
  72                         return false;
  73                 }
  74         };
  75
  76         class CharType : public TUnboxedType<u8>
  77         {
  78
  79         };
  80
  81         class FixnumType : public TUnboxedType<u32>
  82         {
  83         };
  84
  85         class FloatnumType : public TUnboxedType<f32>
  86         {
  87         };
  88
  89         template <typename T> class TBoxedType
  90         {
  91         private:
  92                 boost::shared_ptr<T> pointer_;
  93         public:
  94                 TBoxedType() : pointer_(new T)
  95                 {
  96                 }
  97
  98                 TBoxedType(const TUnboxedType<T>& other) : pointer_(other.pointer_)
  99                 {
 100                 }
 101
 102                 T& operator=(const TBoxedType<T>& other)
 103                 {
 104                         pointer_ = other.pointer_;
 105                 }
 106
 107                 T* operator->()
 108                 {
 109                         return pointer_.operator->();
 110                 }
 111
 112                 T& operator*()
 113                 {
 114                         return pointer_.operator*();
 115                 }
 116
 117                 const bool isBoxed() const
 118                 {
 119                         return true;
 120                 }
 121
 122         };
 123
 124 // Simple unboxable Lisp Value
 125         template <typename CharT,  typename FixnumT,  typename FloatnumT,  typename PrimT,  typename ObjRefT> class TLispValue
 126         {
 127         public:
 128                 typedef CharT LispCharT;
 129                 typedef FixnumT LispFixnumT;
 130                 typedef FloatnumT LispFloatnumT;
 131                 typedef PrimT LispPrimT;
 132                 typedef ObjRefT LispObjRefT;
 133
 134                 boost::variant<  CharT,  FixnumT,  FloatnumT,  PrimT,  ObjRefT> value_;
 135
 136                 CharT getChar() {
 137                         return boost::get< CharT>(value_);
 138                 }
 139
 140                 FixnumT getFixnum() {
 141                         return boost::get< FixnumT>(value_);
 142                 }
 143
 144                 FloatnumT getFloatNum() {
 145                         return boost::get< FloatnumT>(value_);
 146                 }
 147
 148                 PrimT getPrim() {
 149                         return boost::get< PrimT>(value_);
 150                 }
 151         };
 152
 153 // instantiate lisp value
 154         struct LispValue : public TLispValue<u8, u32, f32, NullType, boost::shared_ptr<void*> >
 155         {
 156         };
 157
 158 // Compound lisp object
 159         template <typename ListT, typename MapT, typename ArrayT> class TLispObj
 160                 : public boost::variant<ListT, MapT, ArrayT>
 161         {
 162         public:
 163                 const bool isCompound() const {
 164                         return true;
 165                 }
 166         };
 167
 168
 169         struct LispObject : public TLispObj<std::list<LispValue>, std::map<std::string, LispValue>, std::vector<LispValue> >
 170         {
 171
 172         };
 173
 174         class IsRefCompoundVisitor : public boost::static_visitor<>
 175         {
 176                 bool isCompound_;
 177
 178                 template <typename T>
 179                 void operator()(T& operand)
 180                 {
 181                         isCompound_ = operand->isCompound();
 182                 }
 183         };
 184
 185
 186 // reference to a lisp object: can either contain the value itself or a pointer to a compound value
 187         template <typename LispValueT, typename LispObjT> class LispObjRefT :   public boost::variant< LispValueT, boost::shared_ptr<LispObjT> >
 188         {
 189         public:
 190
 191                 const bool isCompoundRef() const {
 192                         IsRefCompoundVisitor visitor;
 193                         boost::apply_visitor(this);
 194                         return visitor.isCompound_;
 195                 }
 196         };
 197
 198         class LispObjRef : public LispObjRefT< LispValue, LispObject >
 199         {
 200
 201         };
 202
 203
 204
 205 // This is our container primitive, the equivalent of a cons cell structured list
 206         template <typename D, template <typename> class C>
 207         class TLispObjContainer
 208         {
 209         public:
 210
 211                 typedef D ValueType;
 212                 typedef C<D> ValueContainerType;
 213
 214                 typename D::LispCharT getChar(std::size_t i)
 215                 {
 216                         return values[i].getChar();
 217                 }
 218
 219                 typename D::LispFixnumT getFixnum(std::size_t i)
 220                 {
 221                         return values[i].getFixnum();
 222                 }
 223
 224                 typename D::LispFloatnumT getFloatNum(std::size_t i)
 225                 {
 226                         return values[i].getFloatNum();
 227                 }
 228
 229                 typename D::LispObjRefT getObjRef(std::size_t i)
 230                 {
 231                         return values[i].getObjRef();
 232                 }
 233
 234                 ValueContainerType values;
 235
 236                 // container must have capacity
 237                 void resize(std::size_t s)
 238                 {
 239                         values.reserve(s);
 240                         values.resize(s);
 241                 }
 242
 243                 // must be able to tell what that capacity is
 244                 std::size_t size() const
 245                 {
 246                         return values.size();
 247                 }
 248
 249         };
 250
 251         struct LispObjContainer {
 252                 TLispObjContainer<LispValue, std::vector>  objects;
 253         };
 254
 255 } // end namespace lisp
 256
 257
 258 #endif
 259
 260