Changeset 1850 in webkit for trunk/JavaScriptCore/kjs/reference.cpp

Timestamp:

Aug 16, 2002, 12:07:48 PM (23 years ago)

Author:

mjs

Message:

Final step of the Reference change. Completely separate Reference
from Value, and eliminate ReferenceImp.

18% speedup on cvs-js-performance test.

• kjs/internal.cpp, kjs/internal.h: Remove ReferenceImp.
• kjs/nodes.cpp: (Node::evaluateReference): Use Reference::makeValueReference(), not ConstReference.
• kjs/reference.cpp: (Reference::Reference): New implementation, handles both regular and value references. (Reference::makeValueReference): Incorporate functionality of ConstReference into this class. (Reference::getBase): New implementation (incorporates error vase for value references). (Reference::getPropertyName): New implementation (incorporates error case for value references). (Reference::putValue): New implementation (incorporates error case for value references). (Reference::deleteValue): New implementation (incorporates error case for value references). (Reference::getValue): New implementation (incorporates special case for value references). (Reference::isMutable): New implementation.
• kjs/reference.h: New implementation that merges ReferenceImp into the stack object.
• kjs/value.h, kjs/value.cpp: Removed all reference-related method.

File:

• trunk/JavaScriptCore/kjs/reference.cpp (modified) (1 diff)

trunk/JavaScriptCore/kjs/reference.cpp

@@ -29 +29 @@
 
 Reference::Reference(const Object& b, const UString& p)
-  : Value(new ReferenceImp(b,p))
+  : base(b),
+    baseIsValue(false),
+    propertyNameIsNumber(false),
+    prop(p)
 {
 }
 
 Reference::Reference(const Object& b, unsigned p)
-  : Value(new ReferenceImp(b,p))
+  : base(b),
+    propertyNameAsNumber(p),
+    baseIsValue(false),
+    propertyNameIsNumber(true)
 {
 }
 
 Reference::Reference(const Null& b, const UString& p)
-  : Value(new ReferenceImp(b,p))
+  : base(b),
+    baseIsValue(false),
+    propertyNameIsNumber(false),
+    prop(p)
 {
 }
 
 Reference::Reference(const Null& b, unsigned p)
-  : Value(new ReferenceImp(b,p))
+  : base(b),
+    propertyNameAsNumber(p),
+    baseIsValue(false),
+    propertyNameIsNumber(true)
 {
 }
 
-Reference Reference::dynamicCast(const Value &v)
+Reference Reference::makeValueReference(const Value& v)
 {
-  if (v.isNull() || v.type() != ReferenceType)
-    return 0;
-
-  return static_cast<ReferenceImp*>(v.imp());
+  Reference valueRef;
+  valueRef.base = v;
+  valueRef.baseIsValue = true;
+  return valueRef;
 }
 
-ConstReference::ConstReference(ValueImp *v) : 
-  Reference((ReferenceImp *)v) 
+Reference::Reference()
 {
 }
+
+Value Reference::getBase(ExecState *exec) const
+{
+  if (baseIsValue) {
+    Object err = Error::create(exec, ReferenceError, I18N_NOOP("Invalid reference base"));
+    exec->setException(err);
+    return err;
+  }
+
+  return base;
+}
+
+UString Reference::getPropertyName(ExecState *exec) const
+{
+  if (baseIsValue) {
+    // the spec wants a runtime error here. But getValue() and putValue()
+    // will catch this case on their own earlier. When returning a Null
+    // string we should be on the safe side.
+    return UString();
+  }
+
+  if (propertyNameIsNumber && prop.isNull())
+    prop = UString::from(propertyNameAsNumber);
+  return prop;
+}
+
+Value Reference::getValue(ExecState *exec) const 
+{
+  if (baseIsValue) {
+    return base;
+  }
+
+  Value o = getBase(exec);
+
+  if (o.isNull() || o.type() == NullType) {
+    UString m = I18N_NOOP("Can't find variable: ") + getPropertyName(exec);
+    Object err = Error::create(exec, ReferenceError, m.ascii());
+    exec->setException(err);
+    return err;
+  }
+
+  if (o.type() != ObjectType) {
+    UString m = I18N_NOOP("Base is not an object");
+    Object err = Error::create(exec, ReferenceError, m.ascii());
+    exec->setException(err);
+    return err;
+  }
+
+  if (propertyNameIsNumber)
+    return static_cast<ObjectImp*>(o.imp())->get(exec,propertyNameAsNumber);
+  return static_cast<ObjectImp*>(o.imp())->get(exec,prop);
+}
+
+void Reference::putValue(ExecState *exec, const Value &w)
+{
+  if (baseIsValue) {
+    Object err = Error::create(exec,ReferenceError);
+    exec->setException(err);
+    return;
+  }
+
+#ifdef KJS_VERBOSE
+  printInfo(exec,(UString("setting property ")+getPropertyName(exec)).cstring().c_str(),w);
+#endif
+  Value o = getBase(exec);
+  if (o.type() == NullType)
+    o = exec->interpreter()->globalObject();
+
+  if (propertyNameIsNumber)
+    return static_cast<ObjectImp*>(o.imp())->put(exec,propertyNameAsNumber, w);
+  return static_cast<ObjectImp*>(o.imp())->put(exec,prop, w);
+}
+
+bool Reference::deleteValue(ExecState *exec)
+{
+  if (baseIsValue) {
+    Object err = Error::create(exec,ReferenceError);
+    exec->setException(err);
+    return false;
+  }
+
+  Value b = getBase(exec);
+
+  // The spec doesn't mention what to do if the base is null... just return true
+  if (b.type() != ObjectType) {
+    assert(b.type() == NullType);
+    return true;
+  }
+
+  if (propertyNameIsNumber)
+    return static_cast<ObjectImp*>(b.imp())->deleteProperty(exec,propertyNameAsNumber);
+  return static_cast<ObjectImp*>(b.imp())->deleteProperty(exec,prop);
+}
+
+bool Reference::isMutable()
+{ 
+  return !baseIsValue;
+}