vm/tagged.hpp

   1 namespace factor {
   2
   3 template <typename Type> cell tag(Type* value) {
   4   return RETAG(value, Type::type_number);
   5 }
   6
   7 inline static cell tag_dynamic(object* value) {
   8   return RETAG(value, value->type());
   9 }
  10
  11 template <typename Type> struct tagged {
  12   cell value_;
  13
  14   cell type() const { return TAG(value_); }
  15
  16   bool type_p() const {
  17     if (Type::type_number == TYPE_COUNT)
  18       return true;
  19     return type() == Type::type_number;
  20   }
  21
  22   cell value() const {
  23     FACTOR_ASSERT(type_p());
  24     return value_;
  25   }
  26
  27   Type* untagged() const {
  28     FACTOR_ASSERT(type_p());
  29     return (Type*)(UNTAG(value_));
  30   }
  31
  32   explicit tagged(cell tagged) : value_(tagged) {}
  33   explicit tagged(Type* untagged) : value_(factor::tag(untagged)) {}
  34
  35   Type* operator->() const { return untagged(); }
  36   cell* operator&() const { return &value_; }
  37
  38   const tagged<Type>& operator=(const Type* x) {
  39     value_ = tag(x);
  40     return *this;
  41   }
  42   const tagged<Type>& operator=(const cell& x) {
  43     value_ = x;
  44     return *this;
  45   }
  46
  47   bool operator==(const tagged<Type>& x) { return value_ == x.value_; }
  48   bool operator!=(const tagged<Type>& x) { return value_ != x.value_; }
  49
  50   template <typename NewType> tagged<NewType> as() {
  51     return tagged<NewType>(value_);
  52   }
  53 };
  54
  55 template <typename Type> Type* untag(cell value) {
  56   return tagged<Type>(value).untagged();
  57 }
  58
  59 }