-namespace factor
-{
+namespace factor {
-template<typename Type> cell tag(Type *value)
-{
- return RETAG(value,Type::type_number);
+template <typename Type> cell tag(Type* value) {
+ return RETAG(value, Type::type_number);
}
-inline static cell tag_dynamic(object *value)
-{
- return RETAG(value,value->type());
+inline static cell tag_dynamic(object* value) {
+ return RETAG(value, value->type());
}
-template<typename Type>
-struct tagged
-{
- cell value_;
-
- cell type() const
- {
- return TAG(value_);
- }
-
- bool type_p(cell type_) const
- {
- return type() == type_;
- }
-
- bool type_p() const
- {
- if(Type::type_number == TYPE_COUNT)
- return true;
- else
- return type_p(Type::type_number);
- }
-
- cell value() const
- {
-#ifdef FACTOR_DEBUG
- FACTOR_ASSERT(type_p());
-#endif
- return value_;
- }
-
- Type *untagged() const
- {
-#ifdef FACTOR_DEBUG
- FACTOR_ASSERT(type_p());
-#endif
- return (Type *)(UNTAG(value_));
- }
+template <typename Type> struct tagged {
+ cell value_;
- Type *untag_check(factor_vm *parent) const
- {
- if(!type_p())
- parent->type_error(Type::type_number,value_);
- return untagged();
- }
+ cell type() const { return TAG(value_); }
- explicit tagged(cell tagged) : value_(tagged) {}
- explicit tagged(Type *untagged) : value_(factor::tag(untagged)) {}
+ bool type_p(cell type_) const { return type() == type_; }
- Type *operator->() const { return untagged(); }
- cell *operator&() const { return &value_; }
+ bool type_p() const {
+ if (Type::type_number == TYPE_COUNT)
+ return true;
+ else
+ return type_p(Type::type_number);
+ }
- const tagged<Type> &operator=(const Type *x) { value_ = tag(x); return *this; }
- const tagged<Type> &operator=(const cell &x) { value_ = x; return *this; }
-
- bool operator==(const tagged<Type> &x) { return value_ == x.value_; }
- bool operator!=(const tagged<Type> &x) { return value_ != x.value_; }
+ cell value() const {
+#ifdef FACTOR_DEBUG
+ FACTOR_ASSERT(type_p());
+#endif
+ return value_;
+ }
- template<typename NewType> tagged<NewType> as() { return tagged<NewType>(value_); }
+ Type* untagged() const {
+#ifdef FACTOR_DEBUG
+ FACTOR_ASSERT(type_p());
+#endif
+ return (Type*)(UNTAG(value_));
+ }
+
+ Type* untag_check(factor_vm* parent) const {
+ if (!type_p())
+ parent->type_error(Type::type_number, value_);
+ return untagged();
+ }
+
+ explicit tagged(cell tagged) : value_(tagged) {}
+ explicit tagged(Type* untagged) : value_(factor::tag(untagged)) {}
+
+ Type* operator->() const { return untagged(); }
+ cell* operator&() const { return &value_; }
+
+ const tagged<Type>& operator=(const Type* x) {
+ value_ = tag(x);
+ return *this;
+ }
+ const tagged<Type>& operator=(const cell& x) {
+ value_ = x;
+ return *this;
+ }
+
+ bool operator==(const tagged<Type>& x) { return value_ == x.value_; }
+ bool operator!=(const tagged<Type>& x) { return value_ != x.value_; }
+
+ template <typename NewType> tagged<NewType> as() {
+ return tagged<NewType>(value_);
+ }
};
-template<typename Type> Type *factor_vm::untag_check(cell value)
-{
- return tagged<Type>(value).untag_check(this);
+template <typename Type> Type* factor_vm::untag_check(cell value) {
+ return tagged<Type>(value).untag_check(this);
}
-template<typename Type> Type *untag(cell value)
-{
- return tagged<Type>(value).untagged();
+template <typename Type> Type* untag(cell value) {
+ return tagged<Type>(value).untagged();
}
}