#ifndef _KJS_PROTECT_H_
#define _KJS_PROTECT_H_
#include "object.h"
#include "reference.h"
#include "value.h"
#include "protected_values.h"
#include "interpreter.h"
namespace KJS {
inline void gcProtect(ValueImp *val)
{
#if TEST_CONSERVATIVE_GC | USE_CONSERVATIVE_GC
ProtectedValues::increaseProtectCount(val);
#endif
}
inline void gcUnprotect(ValueImp *val)
{
#if TEST_CONSERVATIVE_GC | USE_CONSERVATIVE_GC
ProtectedValues::decreaseProtectCount(val);
#endif
}
inline void gcProtectNullTolerant(ValueImp *val)
{
if (val) gcProtect(val);
}
inline void gcUnprotectNullTolerant(ValueImp *val)
{
if (val) gcUnprotect(val);
}
class ProtectedValue : public Value {
public:
ProtectedValue() : Value() {}
ProtectedValue(const Value&v)
: Value(v)
{
InterpreterLock lock;
gcProtectNullTolerant(v.imp());
}
ProtectedValue(const ProtectedValue&v)
: Value(v)
{
InterpreterLock lock;
gcProtectNullTolerant(v.imp());
}
~ProtectedValue()
{
InterpreterLock lock;
gcUnprotectNullTolerant(imp());
}
ProtectedValue& operator=(const Value &v)
{
InterpreterLock lock;
ValueImp *old = imp();
Value::operator=(v);
gcProtectNullTolerant(v.imp());
gcUnprotectNullTolerant(old);
return *this;
}
ProtectedValue& operator=(const ProtectedValue &v)
{
InterpreterLock lock;
ValueImp *old = imp();
Value::operator=(v);
gcProtectNullTolerant(v.imp());
gcUnprotectNullTolerant(old);
return *this;
}
private:
explicit ProtectedValue(ValueImp *v);
};
class ProtectedObject : public Object {
public:
ProtectedObject() : Object() {}
ProtectedObject(const Object &o)
: Object(o)
{
InterpreterLock lock;
gcProtectNullTolerant(o.imp());
}
ProtectedObject(const ProtectedObject &o)
: Object(o)
{
InterpreterLock lock;
gcProtectNullTolerant(o.imp());
}
~ProtectedObject()
{
InterpreterLock lock;
gcUnprotectNullTolerant(imp());
}
ProtectedObject& operator=(const Object &o)
{
InterpreterLock lock;
ValueImp *old = imp();
Object::operator=(o);
gcProtectNullTolerant(o.imp());
gcUnprotectNullTolerant(old);
return *this;
}
ProtectedObject& operator=(const ProtectedObject &o)
{
InterpreterLock lock;
ValueImp *old = imp();
Object::operator=(o);
gcProtectNullTolerant(o.imp());
gcUnprotectNullTolerant(old);
return *this;
}
private:
explicit ProtectedObject(ObjectImp *o);
};
class ProtectedReference : public Reference {
public:
ProtectedReference(const Reference&r)
: Reference(r)
{
InterpreterLock lock;
gcProtectNullTolerant(r.base.imp());
}
~ProtectedReference()
{
InterpreterLock lock;
gcUnprotectNullTolerant(base.imp());
}
ProtectedReference& operator=(const Reference &r)
{
InterpreterLock lock;
ValueImp *old = base.imp();
Reference::operator=(r);
gcProtectNullTolerant(r.base.imp());
gcUnprotectNullTolerant(old);
return *this;
}
private:
ProtectedReference();
ProtectedReference(const Object& b, const Identifier& p);
ProtectedReference(const Object& b, unsigned p);
ProtectedReference(ObjectImp *b, const Identifier& p);
ProtectedReference(ObjectImp *b, unsigned p);
ProtectedReference(const Null& b, const Identifier& p);
ProtectedReference(const Null& b, unsigned p);
};
}
#endif