Changeset 11527 in webkit for trunk/JavaScriptCore/kjs/nodes.cpp


Ignore:
Timestamp:
Dec 10, 2005, 6:06:17 PM (19 years ago)
Author:
darin
Message:

JavaScriptCore:

Rubber stamped by Maciej.

  • did long-promised KJS renaming:

ValueImp -> JSValue
ObjectImp -> JSObject
AllocatedValueImp -> JSCell

A renaming to get a class out of the way

KJS::Bindings::JSObject -> JavaJSObject

and some other "imp-reduction" renaming

*InstanceImp -> *Instance
*ProtoFuncImp -> *ProtoFunc
*PrototypeImp -> *Prototype
ArgumentsImp -> Arguments
RuntimeArrayImp -> RuntimeArray
RuntimeMethodImp -> RuntimeMethod

  • most files and functions

WebCore:

Rubber stamped by Maciej.

  • updated for KJS class renaming
  • many files and functions
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r11525 r11527  
    6161  if (exec->hadException()) { \
    6262    setExceptionDetailsIfNeeded(exec); \
    63     ValueImp *ex = exec->exception(); \
     63    JSValue *ex = exec->exception(); \
    6464    exec->clearException(); \
    6565    return Completion(Throw, ex); \
    … …  
    117117}
    118118
    119 ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg)
     119JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg)
    120120{
    121121    return KJS::throwError(exec, e, msg, lineNo(), sourceId(), &sourceURL);
    122122}
    123123
    124 ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *v, Node *expr)
     124JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *expr)
    125125{
    126126    UString message = msg;
    … …  
    131131
    132132
    133 ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg, const Identifier &label)
     133JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, const Identifier &label)
    134134{
    135135    UString message = msg;
    … …  
    138138}
    139139
    140 ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *v, Node *e1, Node *e2)
     140JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *e1, Node *e2)
    141141{
    142142    UString message = msg;
    … …  
    147147}
    148148
    149 ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *v, Node *expr, const Identifier &label)
     149JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *expr, const Identifier &label)
    150150{
    151151    UString message = msg;
    … …  
    156156}
    157157
    158 ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *v, const Identifier &label)
     158JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, const Identifier &label)
    159159{
    160160    UString message = msg;
    … …  
    164164}
    165165
    166 ValueImp *Node::throwUndefinedVariableError(ExecState *exec, const Identifier &ident)
     166JSValue *Node::throwUndefinedVariableError(ExecState *exec, const Identifier &ident)
    167167{
    168168    return throwError(exec, ReferenceError, "Can't find variable: %s", ident);
    … …  
    171171void Node::setExceptionDetailsIfNeeded(ExecState *exec)
    172172{
    173     ValueImp *exceptionValue = exec->exception();
     173    JSValue *exceptionValue = exec->exception();
    174174    if (exceptionValue->isObject()) {
    175         ObjectImp *exception = static_cast<ObjectImp *>(exceptionValue);
     175        JSObject *exception = static_cast<JSObject *>(exceptionValue);
    176176        if (!exception->hasProperty(exec, "line") && !exception->hasProperty(exec, "sourceURL")) {
    177177            exception->put(exec, "line", jsNumber(line));
    … …  
    215215// ------------------------------ NullNode -------------------------------------
    216216
    217 ValueImp *NullNode::evaluate(ExecState *)
     217JSValue *NullNode::evaluate(ExecState *)
    218218{
    219219  return jsNull();
    … …  
    222222// ------------------------------ BooleanNode ----------------------------------
    223223
    224 ValueImp *BooleanNode::evaluate(ExecState *)
     224JSValue *BooleanNode::evaluate(ExecState *)
    225225{
    226226  return jsBoolean(value);
    … …  
    229229// ------------------------------ NumberNode -----------------------------------
    230230
    231 ValueImp *NumberNode::evaluate(ExecState *)
     231JSValue *NumberNode::evaluate(ExecState *)
    232232{
    233233  return jsNumber(value);
    … …  
    236236// ------------------------------ StringNode -----------------------------------
    237237
    238 ValueImp *StringNode::evaluate(ExecState *)
     238JSValue *StringNode::evaluate(ExecState *)
    239239{
    240240  return jsString(value);
    … …  
    243243// ------------------------------ RegExpNode -----------------------------------
    244244
    245 ValueImp *RegExpNode::evaluate(ExecState *exec)
     245JSValue *RegExpNode::evaluate(ExecState *exec)
    246246{
    247247  List list;
    … …  
    249249  list.append(jsString(flags));
    250250
    251   ObjectImp *reg = exec->lexicalInterpreter()->imp()->builtinRegExp();
     251  JSObject *reg = exec->lexicalInterpreter()->imp()->builtinRegExp();
    252252  return reg->construct(exec,list);
    253253}
    … …  
    256256
    257257// ECMA 11.1.1
    258 ValueImp *ThisNode::evaluate(ExecState *exec)
     258JSValue *ThisNode::evaluate(ExecState *exec)
    259259{
    260260  return exec->context().imp()->thisValue();
    … …  
    264264
    265265// ECMA 11.1.2 & 10.1.4
    266 ValueImp *ResolveNode::evaluate(ExecState *exec)
     266JSValue *ResolveNode::evaluate(ExecState *exec)
    267267{
    268268  const ScopeChain& chain = exec->context().imp()->scopeChain();
    … …  
    275275  PropertySlot slot;
    276276  do {
    277     ObjectImp *o = *iter;
     277    JSObject *o = *iter;
    278278
    279279    if (o->getPropertySlot(exec, ident, slot))
    … …  
    289289
    290290// ECMA 11.1.6
    291 ValueImp *GroupNode::evaluate(ExecState *exec)
     291JSValue *GroupNode::evaluate(ExecState *exec)
    292292{
    293293  return group->evaluate(exec);
    … …  
    306306
    307307// ECMA 11.1.4
    308 ValueImp *ElementNode::evaluate(ExecState *exec)
    309 {
    310   ObjectImp *array = exec->lexicalInterpreter()->builtinArray()->construct(exec, List::empty());
     308JSValue *ElementNode::evaluate(ExecState *exec)
     309{
     310  JSObject *array = exec->lexicalInterpreter()->builtinArray()->construct(exec, List::empty());
    311311  int length = 0;
    312312  for (ElementNode *n = this; n; n = n->list.get()) {
    313     ValueImp *val = n->node->evaluate(exec);
     313    JSValue *val = n->node->evaluate(exec);
    314314    KJS_CHECKEXCEPTIONVALUE
    315315    length += n->elision;
    … …  
    322322
    323323// ECMA 11.1.4
    324 ValueImp *ArrayNode::evaluate(ExecState *exec)
    325 {
    326   ObjectImp *array;
     324JSValue *ArrayNode::evaluate(ExecState *exec)
     325{
     326  JSObject *array;
    327327  int length;
    328328
    329329  if (element) {
    330     array = static_cast<ObjectImp*>(element->evaluate(exec));
     330    array = static_cast<JSObject*>(element->evaluate(exec));
    331331    KJS_CHECKEXCEPTIONVALUE
    332332    length = opt ? array->get(exec,lengthPropertyName)->toInt32(exec) : 0;
    333333  } else {
    334     ValueImp *newArr = exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty());
    335     array = static_cast<ObjectImp*>(newArr);
     334    JSValue *newArr = exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty());
     335    array = static_cast<JSObject*>(newArr);
    336336    length = 0;
    337337  }
    … …  
    346346
    347347// ECMA 11.1.5
    348 ValueImp *ObjectLiteralNode::evaluate(ExecState *exec)
     348JSValue *ObjectLiteralNode::evaluate(ExecState *exec)
    349349{
    350350  if (list)
    … …  
    357357
    358358// ECMA 11.1.5
    359 ValueImp *PropertyValueNode::evaluate(ExecState *exec)
    360 {
    361   ObjectImp *obj = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
     359JSValue *PropertyValueNode::evaluate(ExecState *exec)
     360{
     361  JSObject *obj = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
    362362 
    363363  for (PropertyValueNode *p = this; p; p = p->list.get()) {
    364     ValueImp *n = p->name->evaluate(exec);
     364    JSValue *n = p->name->evaluate(exec);
    365365    KJS_CHECKEXCEPTIONVALUE
    366     ValueImp *v = p->assign->evaluate(exec);
     366    JSValue *v = p->assign->evaluate(exec);
    367367    KJS_CHECKEXCEPTIONVALUE
    368368
    … …  
    376376
    377377// ECMA 11.1.5
    378 ValueImp *PropertyNode::evaluate(ExecState *)
    379 {
    380   ValueImp *s;
     378JSValue *PropertyNode::evaluate(ExecState *)
     379{
     380  JSValue *s;
    381381
    382382  if (str.isNull()) {
    … …  
    392392
    393393// ECMA 11.2.1a
    394 ValueImp *BracketAccessorNode::evaluate(ExecState *exec)
    395 {
    396   ValueImp *v1 = expr1->evaluate(exec);
    397   KJS_CHECKEXCEPTIONVALUE
    398   ValueImp *v2 = expr2->evaluate(exec);
    399   KJS_CHECKEXCEPTIONVALUE
    400   ObjectImp *o = v1->toObject(exec);
     394JSValue *BracketAccessorNode::evaluate(ExecState *exec)
     395{
     396  JSValue *v1 = expr1->evaluate(exec);
     397  KJS_CHECKEXCEPTIONVALUE
     398  JSValue *v2 = expr2->evaluate(exec);
     399  KJS_CHECKEXCEPTIONVALUE
     400  JSObject *o = v1->toObject(exec);
    401401  uint32_t i;
    402402  if (v2->getUInt32(i))
    … …  
    408408
    409409// ECMA 11.2.1b
    410 ValueImp *DotAccessorNode::evaluate(ExecState *exec)
    411 {
    412   ValueImp *v = expr->evaluate(exec);
     410JSValue *DotAccessorNode::evaluate(ExecState *exec)
     411{
     412  JSValue *v = expr->evaluate(exec);
    413413  KJS_CHECKEXCEPTIONVALUE
    414414  return v->toObject(exec)->get(exec, ident);
    … …  
    418418// ------------------------------ ArgumentListNode -----------------------------
    419419
    420 ValueImp *ArgumentListNode::evaluate(ExecState *)
     420JSValue *ArgumentListNode::evaluate(ExecState *)
    421421{
    422422  assert(0);
    … …  
    430430
    431431  for (ArgumentListNode *n = this; n; n = n->list.get()) {
    432     ValueImp *v = n->expr->evaluate(exec);
     432    JSValue *v = n->expr->evaluate(exec);
    433433    KJS_CHECKEXCEPTIONLIST
    434434    l.append(v);
    … …  
    440440// ------------------------------ ArgumentsNode --------------------------------
    441441
    442 ValueImp *ArgumentsNode::evaluate(ExecState *)
     442JSValue *ArgumentsNode::evaluate(ExecState *)
    443443{
    444444  assert(0);
    … …  
    459459// ECMA 11.2.2
    460460
    461 ValueImp *NewExprNode::evaluate(ExecState *exec)
    462 {
    463   ValueImp *v = expr->evaluate(exec);
     461JSValue *NewExprNode::evaluate(ExecState *exec)
     462{
     463  JSValue *v = expr->evaluate(exec);
    464464  KJS_CHECKEXCEPTIONVALUE
    465465
    … …  
    474474  }
    475475
    476   ObjectImp *constr = static_cast<ObjectImp*>(v);
     476  JSObject *constr = static_cast<JSObject*>(v);
    477477  if (!constr->implementsConstruct()) {
    478478    return throwError(exec, TypeError, "Value %s (result of expression %s) is not a constructor. Cannot be used with new.", v, expr.get());
    … …  
    483483
    484484// ECMA 11.2.3
    485 ValueImp *FunctionCallValueNode::evaluate(ExecState *exec)
    486 {
    487   ValueImp *v = expr->evaluate(exec);
     485JSValue *FunctionCallValueNode::evaluate(ExecState *exec)
     486{
     487  JSValue *v = expr->evaluate(exec);
    488488  KJS_CHECKEXCEPTIONVALUE
    489489
    … …  
    492492  }
    493493 
    494   ObjectImp *func = static_cast<ObjectImp*>(v);
     494  JSObject *func = static_cast<JSObject*>(v);
    495495
    496496  if (!func->implementsCall()) {
    … …  
    501501  KJS_CHECKEXCEPTIONVALUE
    502502
    503   ObjectImp *thisObj =  exec->dynamicInterpreter()->globalObject();
     503  JSObject *thisObj =  exec->dynamicInterpreter()->globalObject();
    504504
    505505  return func->call(exec, thisObj, argList);
    … …  
    507507
    508508// ECMA 11.2.3
    509 ValueImp *FunctionCallResolveNode::evaluate(ExecState *exec)
     509JSValue *FunctionCallResolveNode::evaluate(ExecState *exec)
    510510{
    511511  const ScopeChain& chain = exec->context().imp()->scopeChain();
    … …  
    517517
    518518  PropertySlot slot;
    519   ObjectImp *base;
     519  JSObject *base;
    520520  do {
    521521    base = *iter;
    522522    if (base->getPropertySlot(exec, ident, slot)) {
    523       ValueImp *v = slot.getValue(exec, ident);
     523      JSValue *v = slot.getValue(exec, ident);
    524524      KJS_CHECKEXCEPTIONVALUE
    525525       
    … …  
    528528      }
    529529     
    530       ObjectImp *func = static_cast<ObjectImp*>(v);
     530      JSObject *func = static_cast<JSObject*>(v);
    531531     
    532532      if (!func->implementsCall()) {
    … …  
    537537      KJS_CHECKEXCEPTIONVALUE
    538538       
    539       ObjectImp *thisObj = base;
     539      JSObject *thisObj = base;
    540540      // ECMA 11.2.3 says that in this situation the this value should be null.
    541541      // However, section 10.2.3 says that in the case where the value provided
    … …  
    556556
    557557// ECMA 11.2.3
    558 ValueImp *FunctionCallBracketNode::evaluate(ExecState *exec)
    559 {
    560   ValueImp *baseVal = base->evaluate(exec);
    561   KJS_CHECKEXCEPTIONVALUE
    562 
    563   ValueImp *subscriptVal = subscript->evaluate(exec);
    564 
    565   ObjectImp *baseObj = baseVal->toObject(exec);
     558JSValue *FunctionCallBracketNode::evaluate(ExecState *exec)
     559{
     560  JSValue *baseVal = base->evaluate(exec);
     561  KJS_CHECKEXCEPTIONVALUE
     562
     563  JSValue *subscriptVal = subscript->evaluate(exec);
     564
     565  JSObject *baseObj = baseVal->toObject(exec);
    566566  uint32_t i;
    567567  PropertySlot slot;
    568568
    569   ValueImp *funcVal;
     569  JSValue *funcVal;
    570570  if (subscriptVal->getUInt32(i)) {
    571571    if (baseObj->getPropertySlot(exec, i, slot))
    … …  
    587587  }
    588588 
    589   ObjectImp *func = static_cast<ObjectImp*>(funcVal);
     589  JSObject *func = static_cast<JSObject*>(funcVal);
    590590
    591591  if (!func->implementsCall()) {
    … …  
    596596  KJS_CHECKEXCEPTIONVALUE
    597597
    598   ObjectImp *thisObj = baseObj;
     598  JSObject *thisObj = baseObj;
    599599  assert(thisObj);
    600600  assert(thisObj->isObject());
    … …  
    615615
    616616// ECMA 11.2.3
    617 ValueImp *FunctionCallDotNode::evaluate(ExecState *exec)
    618 {
    619   ValueImp *baseVal = base->evaluate(exec);
    620 
    621   ObjectImp *baseObj = baseVal->toObject(exec);
     617JSValue *FunctionCallDotNode::evaluate(ExecState *exec)
     618{
     619  JSValue *baseVal = base->evaluate(exec);
     620
     621  JSObject *baseObj = baseVal->toObject(exec);
    622622  PropertySlot slot;
    623   ValueImp *funcVal = baseObj->getPropertySlot(exec, ident, slot) ? slot.getValue(exec, ident) : jsUndefined();
     623  JSValue *funcVal = baseObj->getPropertySlot(exec, ident, slot) ? slot.getValue(exec, ident) : jsUndefined();
    624624  KJS_CHECKEXCEPTIONVALUE
    625625
    … …  
    627627    return throwError(exec, TypeError, dotExprNotAnObjectString(), funcVal, base.get(), ident);
    628628 
    629   ObjectImp *func = static_cast<ObjectImp*>(funcVal);
     629  JSObject *func = static_cast<JSObject*>(funcVal);
    630630
    631631  if (!func->implementsCall())
    … …  
    635635  KJS_CHECKEXCEPTIONVALUE
    636636
    637   ObjectImp *thisObj = baseObj;
     637  JSObject *thisObj = baseObj;
    638638  assert(thisObj);
    639639  assert(thisObj->isObject());
    … …  
    647647// ------------------------------ PostfixResolveNode ----------------------------------
    648648
    649 ValueImp *PostfixResolveNode::evaluate(ExecState *exec)
     649JSValue *PostfixResolveNode::evaluate(ExecState *exec)
    650650{
    651651  const ScopeChain& chain = exec->context().imp()->scopeChain();
    … …  
    657657
    658658  PropertySlot slot;
    659   ObjectImp *base;
     659  JSObject *base;
    660660  do {
    661661    base = *iter;
    662662    if (base->getPropertySlot(exec, m_ident, slot)) {
    663         ValueImp *v = slot.getValue(exec, m_ident);
     663        JSValue *v = slot.getValue(exec, m_ident);
    664664
    665665        double n = v->toNumber(exec);
    … …  
    679679// ------------------------------ PostfixBracketNode ----------------------------------
    680680
    681 ValueImp *PostfixBracketNode::evaluate(ExecState *exec)
    682 {
    683   ValueImp *baseValue = m_base->evaluate(exec);
    684   KJS_CHECKEXCEPTIONVALUE
    685   ValueImp *subscript = m_subscript->evaluate(exec);
    686   KJS_CHECKEXCEPTIONVALUE
    687 
    688   ObjectImp *base = baseValue->toObject(exec);
     681JSValue *PostfixBracketNode::evaluate(ExecState *exec)
     682{
     683  JSValue *baseValue = m_base->evaluate(exec);
     684  KJS_CHECKEXCEPTIONVALUE
     685  JSValue *subscript = m_subscript->evaluate(exec);
     686  KJS_CHECKEXCEPTIONVALUE
     687
     688  JSObject *base = baseValue->toObject(exec);
    689689
    690690  uint32_t propertyIndex;
    691691  if (subscript->getUInt32(propertyIndex)) {
    692692    PropertySlot slot;
    693     ValueImp *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, propertyIndex) : jsUndefined();
     693    JSValue *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, propertyIndex) : jsUndefined();
    694694    KJS_CHECKEXCEPTIONVALUE
    695695
    … …  
    704704  Identifier propertyName(subscript->toString(exec));
    705705  PropertySlot slot;
    706   ValueImp *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, propertyName) : jsUndefined();
     706  JSValue *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, propertyName) : jsUndefined();
    707707  KJS_CHECKEXCEPTIONVALUE
    708708
    … …  
    717717// ------------------------------ PostfixDotNode ----------------------------------
    718718
    719 ValueImp *PostfixDotNode::evaluate(ExecState *exec)
    720 {
    721   ValueImp *baseValue = m_base->evaluate(exec);
    722   KJS_CHECKEXCEPTIONVALUE
    723   ObjectImp *base = baseValue->toObject(exec);
     719JSValue *PostfixDotNode::evaluate(ExecState *exec)
     720{
     721  JSValue *baseValue = m_base->evaluate(exec);
     722  KJS_CHECKEXCEPTIONVALUE
     723  JSObject *base = baseValue->toObject(exec);
    724724
    725725  PropertySlot slot;
    726   ValueImp *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, m_ident) : jsUndefined();
     726  JSValue *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, m_ident) : jsUndefined();
    727727  KJS_CHECKEXCEPTIONVALUE
    728728
    … …  
    738738
    739739// ------------------------------ DeleteResolveNode -----------------------------------
    740 ValueImp *DeleteResolveNode::evaluate(ExecState *exec)
     740JSValue *DeleteResolveNode::evaluate(ExecState *exec)
    741741{
    742742  const ScopeChain& chain = exec->context().imp()->scopeChain();
    … …  
    748748
    749749  PropertySlot slot;
    750   ObjectImp *base;
     750  JSObject *base;
    751751  do {
    752752    base = *iter;
    … …  
    762762
    763763// ------------------------------ DeleteBracketNode -----------------------------------
    764 ValueImp *DeleteBracketNode::evaluate(ExecState *exec)
    765 {
    766   ValueImp *baseValue = m_base->evaluate(exec);
    767   KJS_CHECKEXCEPTIONVALUE
    768   ValueImp *subscript = m_subscript->evaluate(exec);
    769   KJS_CHECKEXCEPTIONVALUE
    770 
    771   ObjectImp *base = baseValue->toObject(exec);
     764JSValue *DeleteBracketNode::evaluate(ExecState *exec)
     765{
     766  JSValue *baseValue = m_base->evaluate(exec);
     767  KJS_CHECKEXCEPTIONVALUE
     768  JSValue *subscript = m_subscript->evaluate(exec);
     769  KJS_CHECKEXCEPTIONVALUE
     770
     771  JSObject *base = baseValue->toObject(exec);
    772772
    773773  uint32_t propertyIndex;
    … …  
    780780
    781781// ------------------------------ DeleteDotNode -----------------------------------
    782 ValueImp *DeleteDotNode::evaluate(ExecState *exec)
    783 {
    784   ValueImp *baseValue = m_base->evaluate(exec);
    785   ObjectImp *base = baseValue->toObject(exec);
     782JSValue *DeleteDotNode::evaluate(ExecState *exec)
     783{
     784  JSValue *baseValue = m_base->evaluate(exec);
     785  JSObject *base = baseValue->toObject(exec);
    786786  KJS_CHECKEXCEPTIONVALUE
    787787
    … …  
    790790
    791791// ------------------------------ DeleteValueNode -----------------------------------
    792 ValueImp *DeleteValueNode::evaluate(ExecState *exec)
     792JSValue *DeleteValueNode::evaluate(ExecState *exec)
    793793{
    794794  m_expr->evaluate(exec);
    … …  
    802802
    803803// ECMA 11.4.2
    804 ValueImp *VoidNode::evaluate(ExecState *exec)
     804JSValue *VoidNode::evaluate(ExecState *exec)
    805805{
    806806  expr->evaluate(exec);
    … …  
    814814// ------------------------------ TypeOfValueNode -----------------------------------
    815815
    816 static ValueImp *typeStringForValue(ValueImp *v)
     816static JSValue *typeStringForValue(JSValue *v)
    817817{
    818818    switch (v->type()) {
    … …  
    828828        return jsString("string");
    829829    default:
    830         if (v->isObject() && static_cast<ObjectImp*>(v)->implementsCall())
     830        if (v->isObject() && static_cast<JSObject*>(v)->implementsCall())
    831831            return jsString("function");
    832832        else
    … …  
    835835}
    836836
    837 ValueImp *TypeOfResolveNode::evaluate(ExecState *exec)
     837JSValue *TypeOfResolveNode::evaluate(ExecState *exec)
    838838{
    839839  const ScopeChain& chain = exec->context().imp()->scopeChain();
    … …  
    845845
    846846  PropertySlot slot;
    847   ObjectImp *base;
     847  JSObject *base;
    848848  do {
    849849    base = *iter;
    850850    if (base->getPropertySlot(exec, m_ident, slot)) {
    851         ValueImp *v = slot.getValue(exec, m_ident);
     851        JSValue *v = slot.getValue(exec, m_ident);
    852852        return typeStringForValue(v);
    853853    }
    … …  
    861861// ------------------------------ TypeOfValueNode -----------------------------------
    862862
    863 ValueImp *TypeOfValueNode::evaluate(ExecState *exec)
    864 {
    865   ValueImp *v = m_expr->evaluate(exec);
     863JSValue *TypeOfValueNode::evaluate(ExecState *exec)
     864{
     865  JSValue *v = m_expr->evaluate(exec);
    866866  KJS_CHECKEXCEPTIONVALUE
    867867
    … …  
    873873// ------------------------------ PrefixResolveNode ----------------------------------
    874874
    875 ValueImp *PrefixResolveNode::evaluate(ExecState *exec)
     875JSValue *PrefixResolveNode::evaluate(ExecState *exec)
    876876{
    877877  const ScopeChain& chain = exec->context().imp()->scopeChain();
    … …  
    883883
    884884  PropertySlot slot;
    885   ObjectImp *base;
     885  JSObject *base;
    886886  do {
    887887    base = *iter;
    888888    if (base->getPropertySlot(exec, m_ident, slot)) {
    889         ValueImp *v = slot.getValue(exec, m_ident);
     889        JSValue *v = slot.getValue(exec, m_ident);
    890890
    891891        double n = v->toNumber(exec);
    892892       
    893893        double newValue = (m_oper == OpPlusPlus) ? n + 1 : n - 1;
    894         ValueImp *n2 = jsNumber(newValue);
     894        JSValue *n2 = jsNumber(newValue);
    895895        base->put(exec, m_ident, n2);
    896896
    … …  
    906906// ------------------------------ PrefixBracketNode ----------------------------------
    907907
    908 ValueImp *PrefixBracketNode::evaluate(ExecState *exec)
    909 {
    910   ValueImp *baseValue = m_base->evaluate(exec);
    911   KJS_CHECKEXCEPTIONVALUE
    912   ValueImp *subscript = m_subscript->evaluate(exec);
    913   KJS_CHECKEXCEPTIONVALUE
    914 
    915   ObjectImp *base = baseValue->toObject(exec);
     908JSValue *PrefixBracketNode::evaluate(ExecState *exec)
     909{
     910  JSValue *baseValue = m_base->evaluate(exec);
     911  KJS_CHECKEXCEPTIONVALUE
     912  JSValue *subscript = m_subscript->evaluate(exec);
     913  KJS_CHECKEXCEPTIONVALUE
     914
     915  JSObject *base = baseValue->toObject(exec);
    916916
    917917  uint32_t propertyIndex;
    918918  if (subscript->getUInt32(propertyIndex)) {
    919919    PropertySlot slot;
    920     ValueImp *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, propertyIndex) : jsUndefined();
     920    JSValue *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, propertyIndex) : jsUndefined();
    921921    KJS_CHECKEXCEPTIONVALUE
    922922
    … …  
    924924
    925925    double newValue = (m_oper == OpPlusPlus) ? n + 1 : n - 1;
    926     ValueImp *n2 = jsNumber(newValue);
     926    JSValue *n2 = jsNumber(newValue);
    927927    base->put(exec, propertyIndex, n2);
    928928
    … …  
    932932  Identifier propertyName(subscript->toString(exec));
    933933  PropertySlot slot;
    934   ValueImp *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, propertyName) : jsUndefined();
     934  JSValue *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, propertyName) : jsUndefined();
    935935  KJS_CHECKEXCEPTIONVALUE
    936936
    … …  
    938938 
    939939  double newValue = (m_oper == OpPlusPlus) ? n + 1 : n - 1;
    940   ValueImp *n2 = jsNumber(newValue);
     940  JSValue *n2 = jsNumber(newValue);
    941941  base->put(exec, propertyName, n2);
    942942
    … …  
    946946// ------------------------------ PrefixDotNode ----------------------------------
    947947
    948 ValueImp *PrefixDotNode::evaluate(ExecState *exec)
    949 {
    950   ValueImp *baseValue = m_base->evaluate(exec);
    951   KJS_CHECKEXCEPTIONVALUE
    952   ObjectImp *base = baseValue->toObject(exec);
     948JSValue *PrefixDotNode::evaluate(ExecState *exec)
     949{
     950  JSValue *baseValue = m_base->evaluate(exec);
     951  KJS_CHECKEXCEPTIONVALUE
     952  JSObject *base = baseValue->toObject(exec);
    953953
    954954  PropertySlot slot;
    955   ValueImp *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, m_ident) : jsUndefined();
     955  JSValue *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, m_ident) : jsUndefined();
    956956  KJS_CHECKEXCEPTIONVALUE
    957957
    … …  
    959959 
    960960  double newValue = (m_oper == OpPlusPlus) ? n + 1 : n - 1;
    961   ValueImp *n2 = jsNumber(newValue);
     961  JSValue *n2 = jsNumber(newValue);
    962962  base->put(exec, m_ident, n2);
    963963
    … …  
    968968
    969969// ECMA 11.4.6
    970 ValueImp *UnaryPlusNode::evaluate(ExecState *exec)
    971 {
    972   ValueImp *v = expr->evaluate(exec);
     970JSValue *UnaryPlusNode::evaluate(ExecState *exec)
     971{
     972  JSValue *v = expr->evaluate(exec);
    973973  KJS_CHECKEXCEPTIONVALUE
    974974
    … …  
    979979
    980980// ECMA 11.4.7
    981 ValueImp *NegateNode::evaluate(ExecState *exec)
    982 {
    983   ValueImp *v = expr->evaluate(exec);
     981JSValue *NegateNode::evaluate(ExecState *exec)
     982{
     983  JSValue *v = expr->evaluate(exec);
    984984  KJS_CHECKEXCEPTIONVALUE
    985985
    … …  
    991991
    992992// ECMA 11.4.8
    993 ValueImp *BitwiseNotNode::evaluate(ExecState *exec)
    994 {
    995   ValueImp *v = expr->evaluate(exec);
     993JSValue *BitwiseNotNode::evaluate(ExecState *exec)
     994{
     995  JSValue *v = expr->evaluate(exec);
    996996  KJS_CHECKEXCEPTIONVALUE
    997997  return jsNumber(~v->toInt32(exec));
    … …  
    10011001
    10021002// ECMA 11.4.9
    1003 ValueImp *LogicalNotNode::evaluate(ExecState *exec)
    1004 {
    1005   ValueImp *v = expr->evaluate(exec);
     1003JSValue *LogicalNotNode::evaluate(ExecState *exec)
     1004{
     1005  JSValue *v = expr->evaluate(exec);
    10061006  KJS_CHECKEXCEPTIONVALUE
    10071007  return jsBoolean(!v->toBoolean(exec));
    … …  
    10111011
    10121012// ECMA 11.5
    1013 ValueImp *MultNode::evaluate(ExecState *exec)
    1014 {
    1015   ValueImp *v1 = term1->evaluate(exec);
    1016   KJS_CHECKEXCEPTIONVALUE
    1017 
    1018   ValueImp *v2 = term2->evaluate(exec);
     1013JSValue *MultNode::evaluate(ExecState *exec)
     1014{
     1015  JSValue *v1 = term1->evaluate(exec);
     1016  KJS_CHECKEXCEPTIONVALUE
     1017
     1018  JSValue *v2 = term2->evaluate(exec);
    10191019  KJS_CHECKEXCEPTIONVALUE
    10201020
    … …  
    10251025
    10261026// ECMA 11.6
    1027 ValueImp *AddNode::evaluate(ExecState *exec)
    1028 {
    1029   ValueImp *v1 = term1->evaluate(exec);
    1030   KJS_CHECKEXCEPTIONVALUE
    1031 
    1032   ValueImp *v2 = term2->evaluate(exec);
     1027JSValue *AddNode::evaluate(ExecState *exec)
     1028{
     1029  JSValue *v1 = term1->evaluate(exec);
     1030  KJS_CHECKEXCEPTIONVALUE
     1031
     1032  JSValue *v2 = term2->evaluate(exec);
    10331033  KJS_CHECKEXCEPTIONVALUE
    10341034
    … …  
    10391039
    10401040// ECMA 11.7
    1041 ValueImp *ShiftNode::evaluate(ExecState *exec)
    1042 {
    1043   ValueImp *v1 = term1->evaluate(exec);
    1044   KJS_CHECKEXCEPTIONVALUE
    1045   ValueImp *v2 = term2->evaluate(exec);
     1041JSValue *ShiftNode::evaluate(ExecState *exec)
     1042{
     1043  JSValue *v1 = term1->evaluate(exec);
     1044  KJS_CHECKEXCEPTIONVALUE
     1045  JSValue *v2 = term2->evaluate(exec);
    10461046  KJS_CHECKEXCEPTIONVALUE
    10471047  unsigned int i2 = v2->toUInt32(exec);
    … …  
    10641064
    10651065// ECMA 11.8
    1066 ValueImp *RelationalNode::evaluate(ExecState *exec)
    1067 {
    1068   ValueImp *v1 = expr1->evaluate(exec);
    1069   KJS_CHECKEXCEPTIONVALUE
    1070   ValueImp *v2 = expr2->evaluate(exec);
     1066JSValue *RelationalNode::evaluate(ExecState *exec)
     1067{
     1068  JSValue *v1 = expr1->evaluate(exec);
     1069  KJS_CHECKEXCEPTIONVALUE
     1070  JSValue *v2 = expr2->evaluate(exec);
    10711071  KJS_CHECKEXCEPTIONVALUE
    10721072
    … …  
    10891089          return throwError(exec,  TypeError,
    10901090                             "Value %s (result of expression %s) is not an object. Cannot be used with IN expression.", v2, expr2.get());
    1091       ObjectImp *o2(static_cast<ObjectImp*>(v2));
     1091      JSObject *o2(static_cast<JSObject*>(v2));
    10921092      b = o2->hasProperty(exec, Identifier(v1->toString(exec)));
    10931093  } else {
    … …  
    10961096                           "Value %s (result of expression %s) is not an object. Cannot be used with instanceof operator.", v2, expr2.get());
    10971097
    1098     ObjectImp *o2(static_cast<ObjectImp*>(v2));
     1098    JSObject *o2(static_cast<JSObject*>(v2));
    10991099    if (!o2->implementsHasInstance()) {
    11001100      // According to the spec, only some types of objects "implement" the [[HasInstance]] property.
    … …  
    11151115
    11161116// ECMA 11.9
    1117 ValueImp *EqualNode::evaluate(ExecState *exec)
    1118 {
    1119   ValueImp *v1 = expr1->evaluate(exec);
    1120   KJS_CHECKEXCEPTIONVALUE
    1121   ValueImp *v2 = expr2->evaluate(exec);
     1117JSValue *EqualNode::evaluate(ExecState *exec)
     1118{
     1119  JSValue *v1 = expr1->evaluate(exec);
     1120  KJS_CHECKEXCEPTIONVALUE
     1121  JSValue *v2 = expr2->evaluate(exec);
    11221122  KJS_CHECKEXCEPTIONVALUE
    11231123
    … …  
    11381138
    11391139// ECMA 11.10
    1140 ValueImp *BitOperNode::evaluate(ExecState *exec)
    1141 {
    1142   ValueImp *v1 = expr1->evaluate(exec);
    1143   KJS_CHECKEXCEPTIONVALUE
    1144   ValueImp *v2 = expr2->evaluate(exec);
     1140JSValue *BitOperNode::evaluate(ExecState *exec)
     1141{
     1142  JSValue *v1 = expr1->evaluate(exec);
     1143  KJS_CHECKEXCEPTIONVALUE
     1144  JSValue *v2 = expr2->evaluate(exec);
    11451145  KJS_CHECKEXCEPTIONVALUE
    11461146  int i1 = v1->toInt32(exec);
    … …  
    11601160
    11611161// ECMA 11.11
    1162 ValueImp *BinaryLogicalNode::evaluate(ExecState *exec)
    1163 {
    1164   ValueImp *v1 = expr1->evaluate(exec);
     1162JSValue *BinaryLogicalNode::evaluate(ExecState *exec)
     1163{
     1164  JSValue *v1 = expr1->evaluate(exec);
    11651165  KJS_CHECKEXCEPTIONVALUE
    11661166  bool b1 = v1->toBoolean(exec);
    … …  
    11681168    return v1;
    11691169
    1170   ValueImp *v2 = expr2->evaluate(exec);
     1170  JSValue *v2 = expr2->evaluate(exec);
    11711171  KJS_CHECKEXCEPTIONVALUE
    11721172
    … …  
    11771177
    11781178// ECMA 11.12
    1179 ValueImp *ConditionalNode::evaluate(ExecState *exec)
    1180 {
    1181   ValueImp *v = logical->evaluate(exec);
     1179JSValue *ConditionalNode::evaluate(ExecState *exec)
     1180{
     1181  JSValue *v = logical->evaluate(exec);
    11821182  KJS_CHECKEXCEPTIONVALUE
    11831183  bool b = v->toBoolean(exec);
    … …  
    11961196#if __GNUC__
    11971197// gcc refuses to inline this without the always_inline, but inlining it does help
    1198 static inline ValueImp *valueForReadModifyAssignment(ExecState * exec, ValueImp *v1, ValueImp *v2, Operator oper) __attribute__((always_inline));
     1198static inline JSValue *valueForReadModifyAssignment(ExecState * exec, JSValue *v1, JSValue *v2, Operator oper) __attribute__((always_inline));
    11991199#endif
    12001200
    1201 static inline ValueImp *valueForReadModifyAssignment(ExecState * exec, ValueImp *v1, ValueImp *v2, Operator oper)
    1202 {
    1203   ValueImp *v;
     1201static inline JSValue *valueForReadModifyAssignment(ExecState * exec, JSValue *v1, JSValue *v2, Operator oper)
     1202{
     1203  JSValue *v;
    12041204  int i1;
    12051205  int i2;
    … …  
    12641264// ------------------------------ AssignResolveNode -----------------------------------
    12651265
    1266 ValueImp *AssignResolveNode::evaluate(ExecState *exec)
     1266JSValue *AssignResolveNode::evaluate(ExecState *exec)
    12671267{
    12681268  const ScopeChain& chain = exec->context().imp()->scopeChain();
    … …  
    12741274
    12751275  PropertySlot slot;
    1276   ObjectImp *base;
     1276  JSObject *base;
    12771277  do {
    12781278    base = *iter;
    … …  
    12871287
    12881288 found:
    1289   ValueImp *v;
     1289  JSValue *v;
    12901290
    12911291  if (m_oper == OpEqual) {
    12921292    v = m_right->evaluate(exec);
    12931293  } else {
    1294     ValueImp *v1 = slot.getValue(exec, m_ident);
     1294    JSValue *v1 = slot.getValue(exec, m_ident);
    12951295    KJS_CHECKEXCEPTIONVALUE
    1296     ValueImp *v2 = m_right->evaluate(exec);
     1296    JSValue *v2 = m_right->evaluate(exec);
    12971297    v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    12981298  }
    … …  
    13061306// ------------------------------ AssignDotNode -----------------------------------
    13071307
    1308 ValueImp *AssignDotNode::evaluate(ExecState *exec)
    1309 {
    1310   ValueImp *baseValue = m_base->evaluate(exec);
    1311   KJS_CHECKEXCEPTIONVALUE
    1312   ObjectImp *base = baseValue->toObject(exec);
    1313 
    1314   ValueImp *v;
     1308JSValue *AssignDotNode::evaluate(ExecState *exec)
     1309{
     1310  JSValue *baseValue = m_base->evaluate(exec);
     1311  KJS_CHECKEXCEPTIONVALUE
     1312  JSObject *base = baseValue->toObject(exec);
     1313
     1314  JSValue *v;
    13151315
    13161316  if (m_oper == OpEqual) {
    … …  
    13181318  } else {
    13191319    PropertySlot slot;
    1320     ValueImp *v1 = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, m_ident) : jsUndefined();
     1320    JSValue *v1 = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, m_ident) : jsUndefined();
    13211321    KJS_CHECKEXCEPTIONVALUE
    1322     ValueImp *v2 = m_right->evaluate(exec);
     1322    JSValue *v2 = m_right->evaluate(exec);
    13231323    v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    13241324  }
    … …  
    13321332// ------------------------------ AssignBracketNode -----------------------------------
    13331333
    1334 ValueImp *AssignBracketNode::evaluate(ExecState *exec)
    1335 {
    1336   ValueImp *baseValue = m_base->evaluate(exec);
    1337   KJS_CHECKEXCEPTIONVALUE
    1338   ValueImp *subscript = m_subscript->evaluate(exec);
    1339   KJS_CHECKEXCEPTIONVALUE
    1340 
    1341   ObjectImp *base = baseValue->toObject(exec);
     1334JSValue *AssignBracketNode::evaluate(ExecState *exec)
     1335{
     1336  JSValue *baseValue = m_base->evaluate(exec);
     1337  KJS_CHECKEXCEPTIONVALUE
     1338  JSValue *subscript = m_subscript->evaluate(exec);
     1339  KJS_CHECKEXCEPTIONVALUE
     1340
     1341  JSObject *base = baseValue->toObject(exec);
    13421342
    13431343  uint32_t propertyIndex;
    13441344  if (subscript->getUInt32(propertyIndex)) {
    1345     ValueImp *v;
     1345    JSValue *v;
    13461346    if (m_oper == OpEqual) {
    13471347      v = m_right->evaluate(exec);
    13481348    } else {
    13491349      PropertySlot slot;
    1350       ValueImp *v1 = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, propertyIndex) : jsUndefined();
     1350      JSValue *v1 = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, propertyIndex) : jsUndefined();
    13511351      KJS_CHECKEXCEPTIONVALUE
    1352       ValueImp *v2 = m_right->evaluate(exec);
     1352      JSValue *v2 = m_right->evaluate(exec);
    13531353      v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    13541354    }
    … …  
    13611361
    13621362  Identifier propertyName(subscript->toString(exec));
    1363   ValueImp *v;
     1363  JSValue *v;
    13641364
    13651365  if (m_oper == OpEqual) {
    … …  
    13671367  } else {
    13681368    PropertySlot slot;
    1369     ValueImp *v1 = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, propertyName) : jsUndefined();
     1369    JSValue *v1 = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, propertyName) : jsUndefined();
    13701370    KJS_CHECKEXCEPTIONVALUE
    1371     ValueImp *v2 = m_right->evaluate(exec);
     1371    JSValue *v2 = m_right->evaluate(exec);
    13721372    v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    13731373  }
    … …  
    13821382
    13831383// ECMA 11.14
    1384 ValueImp *CommaNode::evaluate(ExecState *exec)
     1384JSValue *CommaNode::evaluate(ExecState *exec)
    13851385{
    13861386  expr1->evaluate(exec);
    13871387  KJS_CHECKEXCEPTIONVALUE
    1388   ValueImp *v = expr2->evaluate(exec);
     1388  JSValue *v = expr2->evaluate(exec);
    13891389  KJS_CHECKEXCEPTIONVALUE
    13901390
    … …  
    14151415    return c;
    14161416 
    1417   ValueImp *v = c.value();
     1417  JSValue *v = c.value();
    14181418 
    14191419  for (StatListNode *n = list.get(); n; n = n->list.get()) {
    … …  
    14401440
    14411441// ECMA 12.2
    1442 ValueImp *AssignExprNode::evaluate(ExecState *exec)
     1442JSValue *AssignExprNode::evaluate(ExecState *exec)
    14431443{
    14441444  return expr->evaluate(exec);
    … …  
    14541454
    14551455// ECMA 12.2
    1456 ValueImp *VarDeclNode::evaluate(ExecState *exec)
    1457 {
    1458   ObjectImp *variable = exec->context().imp()->variableObject();
    1459 
    1460   ValueImp *val;
     1456JSValue *VarDeclNode::evaluate(ExecState *exec)
     1457{
     1458  JSObject *variable = exec->context().imp()->variableObject();
     1459
     1460  JSValue *val;
    14611461  if (init) {
    14621462      val = init->evaluate(exec);
    … …  
    14871487void VarDeclNode::processVarDecls(ExecState *exec)
    14881488{
    1489   ObjectImp *variable = exec->context().imp()->variableObject();
     1489  JSObject *variable = exec->context().imp()->variableObject();
    14901490
    14911491  // If a variable by this name already exists, don't clobber it -
    … …  
    15041504
    15051505// ECMA 12.2
    1506 ValueImp *VarDeclListNode::evaluate(ExecState *exec)
     1506JSValue *VarDeclListNode::evaluate(ExecState *exec)
    15071507{
    15081508  for (VarDeclListNode *n = this; n; n = n->list.get()) {
    … …  
    15821582  KJS_BREAKPOINT;
    15831583
    1584   ValueImp *v = expr->evaluate(exec);
     1584  JSValue *v = expr->evaluate(exec);
    15851585  KJS_CHECKEXCEPTION
    15861586
    … …  
    15951595  KJS_BREAKPOINT;
    15961596
    1597   ValueImp *v = expr->evaluate(exec);
     1597  JSValue *v = expr->evaluate(exec);
    15981598  KJS_CHECKEXCEPTION
    15991599  bool b = v->toBoolean(exec);
    … …  
    16261626  KJS_BREAKPOINT;
    16271627
    1628   ValueImp *bv;
     1628  JSValue *bv;
    16291629  Completion c;
    16301630
    … …  
    16611661  KJS_BREAKPOINT;
    16621662
    1663   ValueImp *bv;
     1663  JSValue *bv;
    16641664  Completion c;
    16651665  bool b(false);
    1666   ValueImp *value = 0;
     1666  JSValue *value = 0;
    16671667
    16681668  while (1) {
    … …  
    17041704Completion ForNode::execute(ExecState *exec)
    17051705{
    1706   ValueImp *v, *cval = 0;
     1706  JSValue *v, *cval = 0;
    17071707
    17081708  if (expr1) {
    … …  
    17661766Completion ForInNode::execute(ExecState *exec)
    17671767{
    1768   ValueImp *e;
    1769   ValueImp *retval = 0;
    1770   ObjectImp *v;
     1768  JSValue *e;
     1769  JSValue *retval = 0;
     1770  JSObject *v;
    17711771  Completion c;
    17721772  ReferenceList propList;
    … …  
    18001800    }
    18011801
    1802     ValueImp *str = jsString(name.ustring());
     1802    JSValue *str = jsString(name.ustring());
    18031803
    18041804    if (lexpr->isResolveNode()) {
    … …  
    18131813
    18141814        PropertySlot slot;
    1815         ObjectImp *o;
     1815        JSObject *o;
    18161816        do {
    18171817            o = *iter;
    … …  
    18261826    } else if (lexpr->isDotAccessorNode()) {
    18271827        const Identifier& ident = static_cast<DotAccessorNode *>(lexpr.get())->identifier();
    1828         ValueImp *v = static_cast<DotAccessorNode *>(lexpr.get())->base()->evaluate(exec);
     1828        JSValue *v = static_cast<DotAccessorNode *>(lexpr.get())->base()->evaluate(exec);
    18291829        KJS_CHECKEXCEPTION
    1830         ObjectImp *o = v->toObject(exec);
     1830        JSObject *o = v->toObject(exec);
    18311831
    18321832        o->put(exec, ident, str);
    18331833    } else {
    18341834        assert(lexpr->isBracketAccessorNode());
    1835         ValueImp *v = static_cast<BracketAccessorNode *>(lexpr.get())->base()->evaluate(exec);
     1835        JSValue *v = static_cast<BracketAccessorNode *>(lexpr.get())->base()->evaluate(exec);
    18361836        KJS_CHECKEXCEPTION
    1837         ValueImp *v2 = static_cast<BracketAccessorNode *>(lexpr.get())->subscript()->evaluate(exec);
     1837        JSValue *v2 = static_cast<BracketAccessorNode *>(lexpr.get())->subscript()->evaluate(exec);
    18381838        KJS_CHECKEXCEPTION
    1839         ObjectImp *o = v->toObject(exec);
     1839        JSObject *o = v->toObject(exec);
    18401840
    18411841        uint32_t i;
    … …  
    19211921    return Completion(ReturnValue, jsUndefined());
    19221922
    1923   ValueImp *v = value->evaluate(exec);
     1923  JSValue *v = value->evaluate(exec);
    19241924  KJS_CHECKEXCEPTION
    19251925
    … …  
    19341934  KJS_BREAKPOINT;
    19351935
    1936   ValueImp *v = expr->evaluate(exec);
     1936  JSValue *v = expr->evaluate(exec);
    19371937  KJS_CHECKEXCEPTION
    1938   ObjectImp *o = v->toObject(exec);
     1938  JSObject *o = v->toObject(exec);
    19391939  KJS_CHECKEXCEPTION
    19401940  exec->context().imp()->pushScope(o);
    … …  
    19531953
    19541954// ECMA 12.11
    1955 ValueImp *CaseClauseNode::evaluate(ExecState *exec)
    1956 {
    1957   ValueImp *v = expr->evaluate(exec);
     1955JSValue *CaseClauseNode::evaluate(ExecState *exec)
     1956{
     1957  JSValue *v = expr->evaluate(exec);
    19581958  KJS_CHECKEXCEPTIONVALUE
    19591959
    … …  
    19781978// ------------------------------ ClauseListNode -------------------------------
    19791979
    1980 ValueImp *ClauseListNode::evaluate(ExecState *)
     1980JSValue *ClauseListNode::evaluate(ExecState *)
    19811981{
    19821982  // should never be called
    … …  
    20152015}
    20162016 
    2017 ValueImp *CaseBlockNode::evaluate(ExecState *)
     2017JSValue *CaseBlockNode::evaluate(ExecState *)
    20182018{
    20192019  // should never be called
    … …  
    20232023
    20242024// ECMA 12.11
    2025 Completion CaseBlockNode::evalBlock(ExecState *exec, ValueImp *input)
    2026 {
    2027   ValueImp *v;
     2025Completion CaseBlockNode::evalBlock(ExecState *exec, JSValue *input)
     2026{
     2027  JSValue *v;
    20282028  Completion res;
    20292029  ClauseListNode *a = list1.get();
    … …  
    21022102  KJS_BREAKPOINT;
    21032103
    2104   ValueImp *v = expr->evaluate(exec);
     2104  JSValue *v = expr->evaluate(exec);
    21052105  KJS_CHECKEXCEPTION
    21062106
    … …  
    21462146  KJS_BREAKPOINT;
    21472147
    2148   ValueImp *v = expr->evaluate(exec);
     2148  JSValue *v = expr->evaluate(exec);
    21492149  KJS_CHECKEXCEPTION
    21502150
    … …  
    21622162
    21632163  if (catchBlock && c.complType() == Throw) {
    2164     ObjectImp *obj = new ObjectImp;
     2164    JSObject *obj = new JSObject;
    21652165    obj->put(exec, exceptionIdent, c.value(), DontDelete);
    21662166    exec->context().imp()->pushScope(obj);
    … …  
    21902190
    21912191// ECMA 13
    2192 ValueImp *ParameterNode::evaluate(ExecState *)
     2192JSValue *ParameterNode::evaluate(ExecState *)
    21932193{
    21942194  return jsUndefined();
    … …  
    22192219  FunctionImp *func = new DeclaredFunctionImp(exec, ident, body.get(), context->scopeChain());
    22202220
    2221   ObjectImp *proto = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
     2221  JSObject *proto = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
    22222222  proto->put(exec, constructorPropertyName, func, ReadOnly|DontDelete|DontEnum);
    22232223  func->put(exec, prototypePropertyName, proto, Internal|DontDelete);
    … …  
    22352235    // hack the scope so that the function gets put as a property of func, and it's scope
    22362236    // contains the func as well as our current scope
    2237     ObjectImp *oldVar = context->variableObject();
     2237    JSObject *oldVar = context->variableObject();
    22382238    context->setVariableObject(func);
    22392239    context->pushScope(func);
    … …  
    22522252
    22532253// ECMA 13
    2254 ValueImp *FuncExprNode::evaluate(ExecState *exec)
     2254JSValue *FuncExprNode::evaluate(ExecState *exec)
    22552255{
    22562256  ContextImp *context = exec->context().imp();
    22572257  bool named = !ident.isNull();
    2258   ObjectImp *functionScopeObject = 0;
     2258  JSObject *functionScopeObject = 0;
    22592259
    22602260  if (named) {
    … …  
    22622262    // but they won't register with the current scope chain and should
    22632263    // be contained as single property in an anonymous object.
    2264     functionScopeObject = new ObjectImp;
     2264    functionScopeObject = new JSObject;
    22652265    context->pushScope(functionScopeObject);
    22662266  }
    22672267
    22682268  FunctionImp *func = new DeclaredFunctionImp(exec, ident, body.get(), context->scopeChain());
    2269   ObjectImp *proto = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
     2269  JSObject *proto = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
    22702270  proto->put(exec, constructorPropertyName, func, ReadOnly|DontDelete|DontEnum);
    22712271  func->put(exec, prototypePropertyName, proto, Internal|DontDelete);
Note: See TracChangeset for help on using the changeset viewer.