Skip to main content :: ::

KDE API Reference

:: Skip to Link Menu

/ API Reference / kjs

nodes.cpp // -*- c-basic-offset: 2 -*- /* * This file is part of the KDE libraries * Copyright (C) 1999-2002, 2003 Harri Porten (porten@kde.org) * Copyright (C) 2001 Peter Kelly (pmk@post.com) * Copyright (C) 2003 Apple Computer, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this library; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. * */ #include "nodes.h" #include <math.h> #include <assert.h> #ifdef KJS_DEBUG_MEM #include <stdio.h> #include <typeinfo> #endif #ifdef KJS_VERBOSE #include <iostream> using namespace std; #endif #include "collector.h" #include "context.h" #include "debugger.h" #include "function_object.h" #include "internal.h" #include "value.h" #include "object.h" #include "types.h" #include "interpreter.h" #include "lexer.h" #include "operations.h" #include "ustring.h" using namespace KJS; #define KJS_BREAKPOINT \ if (!hitStatement(exec)) \ return Completion(Normal); #define KJS_ABORTPOINT \ if (exec->dynamicInterpreter()->imp()->debugger() && \ exec->dynamicInterpreter()->imp()->debugger()->imp()->aborted()) \ return Completion(Normal); #define KJS_CHECKEXCEPTION \ if (exec->hadException()) { \ setExceptionDetailsIfNeeded(exec); \ return Completion(Throw, exec->exception()); \ } \ if (Collector::outOfMemory()) \ return Completion(Throw, Error::create(exec,GeneralError,"Out of memory")); #define KJS_CHECKEXCEPTIONVALUE \ if (exec->hadException()) { \ setExceptionDetailsIfNeeded(exec); \ return exec->exception(); \ } \ if (Collector::outOfMemory()) \ return Undefined(); // will be picked up by KJS_CHECKEXCEPTION #define KJS_CHECKEXCEPTIONREFERENCE \ if (exec->hadException()) { \ setExceptionDetailsIfNeeded(exec); \ return Reference::makeValueReference(Undefined()); \ } \ if (Collector::outOfMemory()) \ return Reference::makeValueReference(Undefined()); // will be picked up by KJS_CHECKEXCEPTION #define KJS_CHECKEXCEPTIONLIST \ if (exec->hadException()) { \ setExceptionDetailsIfNeeded(exec); \ return List(); \ } \ if (Collector::outOfMemory()) \ return List(); // will be picked up by KJS_CHECKEXCEPTION #ifdef KJS_DEBUG_MEM std::list<Node *> * Node::s_nodes = 0L; #endif // ----------------------------- Node ----------------------------------------- Node::Node() { line = Lexer::curr()->lineNo(); refcount = 0; #ifdef KJS_DEBUG_MEM if (!s_nodes) s_nodes = new std::list<Node *>; s_nodes->push_back(this); #endif } Node::~Node() { #ifdef KJS_DEBUG_MEM s_nodes->remove( this ); #endif } Reference Node::evaluateReference(ExecState *exec) const { Value v = evaluate(exec); KJS_CHECKEXCEPTIONREFERENCE return Reference::makeValueReference(v); } // fallback for those nodes without a evaluate() reimplementation // TODO: reimplemint in each sub class, make Node::evaluate() pure virtual Value Node::evaluate(ExecState *exec) const { // fprintf(stderr, "%s::evaluate()\n", typeid(*this).name()); return evaluateReference(exec).getValue(exec); } bool Node::toBoolean(ExecState *exec) const { // fprintf(stderr, "Node(%s)::toBoolean()\n", typeid(*this).name()); return evaluate(exec).toBoolean(exec); } double Node::toNumber(ExecState *exec) const { // fprintf(stderr, "Node(%s)::toNumber()\n", typeid(*this).name()); return evaluate(exec).toNumber(exec); } UString Node::toString(ExecState *exec) const { return evaluate(exec).toString(exec); } #ifdef KJS_DEBUG_MEM void Node::finalCheck() { if (!s_nodes) { fprintf(stderr, "Node::finalCheck(): list 0\n"); return; } fprintf( stderr, "Node::finalCheck(): list count : %d\n", (int)s_nodes->size() ); std::list<Node *>::iterator it = s_nodes->begin(); for ( uint i = 0; it != s_nodes->end() ; ++it, ++i ) fprintf( stderr, "[%d] Still having node %p (%s) (refcount %d)\n", i, (void*)*it, typeid( **it ).name(), (*it)->refcount ); delete s_nodes; s_nodes = 0L; } #endif Value Node::throwError(ExecState *exec, ErrorType e, const char *msg) const { Object err = Error::create(exec, e, msg, lineNo(), sourceId()); exec->setException(err); return err; } Value Node::throwError(ExecState *exec, ErrorType e, const char *msg, const Value &v, const Node *expr) const { char *vStr = strdup(v.toString(exec).ascii()); char *exprStr = strdup(expr->toCode().ascii()); int length = strlen(msg) - 4 /* two %s */ + strlen(vStr) + strlen(exprStr) + 1 /* null terminator */; char *str = new char[length]; sprintf(str, msg, vStr, exprStr); free(vStr); free(exprStr); Value result = throwError(exec, e, str); delete [] str; return result; } Value Node::throwError(ExecState *exec, ErrorType e, const char *msg, Identifier label) const { const char *l = label.ascii(); int length = strlen(msg) - 2 /* %s */ + strlen(l) + 1 /* null terminator */; char *message = new char[length]; sprintf(message, msg, l); Value result = throwError(exec, e, message); delete [] message; return result; } void Node::setExceptionDetailsIfNeeded(ExecState *exec) const { if (exec->hadException()) { Object exception = exec->exception().toObject(exec); if (!exception.hasProperty(exec, "line") /* && !exception.hasProperty(exec, "sourceURL")*/ ) { exception.put(exec, "line", Number(line)); // exception.put(exec, "sourceURL", String(sourceURL)); } } } // ----------------------------- StatementNode -------------------------------- StatementNode::StatementNode() : l0(-1), l1(-1), sourceCode(0), breakPoint(false) { } StatementNode::~StatementNode() { if (sourceCode) sourceCode->deref(); } void StatementNode::setLoc(int line0, int line1, SourceCode *src) { // ### require these to be passed to the constructor l0 = line0; l1 = line1; if (sourceCode != src) { if (sourceCode) sourceCode->deref(); sourceCode = src; sourceCode->ref(); } } // return true if the debugger wants us to stop at this point bool StatementNode::hitStatement(ExecState *exec) { assert(sourceCode); assert(exec->context().imp()->sourceId == sourceCode->sid); exec->context().imp()->setLines(l0,l1); Debugger *dbg = exec->dynamicInterpreter()->imp()->debugger(); if (dbg) return dbg->atStatement(exec); else return true; // continue } // return true if the debugger wants us to stop at this point bool StatementNode::abortStatement(ExecState *exec) { Debugger *dbg = exec->dynamicInterpreter()->imp()->debugger(); if (dbg) return dbg->imp()->aborted(); else return false; } void StatementNode::processFuncDecl(ExecState *) { } // ----------------------------- NullNode ------------------------------------- Value NullNode::evaluate(ExecState *) const { return Null(); } bool NullNode::toBoolean(ExecState *) const { return false; } double NullNode::toNumber(ExecState *) const { return 0.0; } UString NullNode::toString(ExecState *) const { return "null"; } // ----------------------------- BooleanNode ---------------------------------- Value BooleanNode::evaluate(ExecState *) const { return Boolean(val); } bool BooleanNode::toBoolean(ExecState *) const { return val; } double BooleanNode::toNumber(ExecState *) const { return val ? 1.0 : 0.0; } UString BooleanNode::toString(ExecState *) const { return val ? "true" : "false"; } // ----------------------------- NumberNode ----------------------------------- Value NumberNode::evaluate(ExecState *) const { return Number(val); } bool NumberNode::toBoolean(ExecState *) const { return !((val == 0) /* || (iVal() == N0) */ || isNaN(val)); } double NumberNode::toNumber(ExecState *) const { return val; } UString NumberNode::toString(ExecState *) const { return UString::from(val); } // ----------------------------- StringNode ----------------------------------- Value StringNode::evaluate(ExecState *) const { return String(val); } bool StringNode::toBoolean(ExecState *) const { return !val.isEmpty(); } double StringNode::toNumber(ExecState *) const { return val.toDouble(); } UString StringNode::toString(ExecState *) const { return val; } // ----------------------------- RegExpNode ----------------------------------- Value RegExpNode::evaluate(ExecState *exec) const { List list; String p(pattern); String f(flags); list.append(p); list.append(f); Object reg = exec->lexicalInterpreter()->imp()->builtinRegExp(); return reg.construct(exec,list); } bool RegExpNode::toBoolean(ExecState *) const { return true; } // ----------------------------- ThisNode ------------------------------------- // ECMA 11.1.1 Value ThisNode::evaluate(ExecState *exec) const { return exec->context().imp()->thisValue(); } // ----------------------------- ResolveNode ---------------------------------- // ECMA 11.1.2 & 10.1.4 Value ResolveNode::evaluate(ExecState *exec) const { return evaluateReference(exec).getValue(exec); } Reference ResolveNode::evaluateReference(ExecState *exec) const { ScopeChain chain = exec->context().imp()->scopeChain(); while (!chain.isEmpty()) { ObjectImp *o = chain.top(); //cerr << "Resolve: looking at '" << ident.ascii() << "'" // << " in " << (void*)o << " " << o->classInfo()->className << endl; if (o->hasProperty(exec,ident)) { //cerr << "Resolve: FOUND '" << ident.ascii() << "'" // << " in " << (void*)o << " " << o->classInfo()->className << endl; return Reference(o, ident); } chain.pop(); } // identifier not found #ifdef KJS_VERBOSE cerr << "Resolve::evaluateReference: didn't find '" << ident.ustring().ascii() << "'" << endl; #endif return Reference(Null(), ident); } // ----------------------------- GroupNode ------------------------------------ void GroupNode::ref() { Node::ref(); if ( group ) group->ref(); } bool GroupNode::deref() { if ( group && group->deref() ) delete group; return Node::deref(); } // ECMA 11.1.6 Value GroupNode::evaluate(ExecState *exec) const { return group->evaluate(exec); } Reference GroupNode::evaluateReference(ExecState *exec) const { return group->evaluateReference(exec); } // ----------------------------- ElementNode ---------------------------------- void ElementNode::ref() { for (ElementNode *n = this; n; n = n->list) { n->Node::ref(); if (n->node) n->node->ref(); } } bool ElementNode::deref() { ElementNode *next; for (ElementNode *n = this; n; n = next) { next = n->list; if (n->node && n->node->deref()) delete n->node; if (n != this && n->Node::deref()) delete n; } return Node::deref(); } // ECMA 11.1.4 Value ElementNode::evaluate(ExecState *exec) const { Object array = exec->lexicalInterpreter()->builtinArray().construct(exec, List::empty()); int length = 0; for (const ElementNode *n = this; n; n = n->list) { Value val = n->node->evaluate(exec); KJS_CHECKEXCEPTIONVALUE length += n->elision; array.put(exec, length++, val); } return array; } // ----------------------------- ArrayNode ------------------------------------ void ArrayNode::ref() { Node::ref(); if ( element ) element->ref(); } bool ArrayNode::deref() { if ( element && element->deref() ) delete element; return Node::deref(); } // ECMA 11.1.4 Value ArrayNode::evaluate(ExecState *exec) const { Object array; int length; if (element) { array = Object(static_cast<ObjectImp*>(element->evaluate(exec).imp())); KJS_CHECKEXCEPTIONVALUE length = opt ? array.get(exec,lengthPropertyName).toInt32(exec) : 0; } else { Value newArr = exec->lexicalInterpreter()->builtinArray().construct(exec,List::empty()); array = Object(static_cast<ObjectImp*>(newArr.imp())); length = 0; } if (opt) array.put(exec,lengthPropertyName, Number(elision + length), DontEnum | DontDelete); return array; } // ----------------------------- ObjectLiteralNode ---------------------------- void ObjectLiteralNode::ref() { Node::ref(); if ( list ) list->ref(); } bool ObjectLiteralNode::deref() { if ( list && list->deref() ) delete list; return Node::deref(); } // ECMA 11.1.5 Value ObjectLiteralNode::evaluate(ExecState *exec) const { if (list) return list->evaluate(exec); return exec->lexicalInterpreter()->builtinObject().construct(exec,List::empty()); } // ----------------------------- PropertyValueNode ---------------------------- void PropertyValueNode::ref() { for (PropertyValueNode *n = this; n; n = n->list) { n->Node::ref(); if (n->name) n->name->ref(); if (n->assign) n->assign->ref(); } } bool PropertyValueNode::deref() { PropertyValueNode *next; for (PropertyValueNode *n = this; n; n = next) { next = n->list; if ( n->name && n->name->deref() ) delete n->name; if ( n->assign && n->assign->deref() ) delete n->assign; if (n != this && n->Node::deref() ) delete n; } return Node::deref(); } // ECMA 11.1.5 Value PropertyValueNode::evaluate(ExecState *exec) const { Object obj = exec->lexicalInterpreter()->builtinObject().construct(exec, List::empty()); for (const PropertyValueNode *p = this; p; p = p->list) { Value n = p->name->evaluate(exec); KJS_CHECKEXCEPTIONVALUE Value v = p->assign->evaluate(exec); KJS_CHECKEXCEPTIONVALUE obj.put(exec, Identifier(n.toString(exec)), v); } return obj; } // ----------------------------- PropertyNode --------------------------------- // ECMA 11.1.5 Value PropertyNode::evaluate(ExecState * /*exec*/) const { Value s; if (str.isNull()) { s = String(UString::from(numeric)); } else { s = String(str.ustring()); } return s; } // ----------------------------- AccessorNode1 -------------------------------- void AccessorNode1::ref() { Node::ref(); if ( expr1 ) expr1->ref(); if ( expr2 ) expr2->ref(); } bool AccessorNode1::deref() { if ( expr1 && expr1->deref() ) delete expr1; if ( expr2 && expr2->deref() ) delete expr2; return Node::deref(); } // ECMA 11.2.1a Reference AccessorNode1::evaluateReference(ExecState *exec) const { Value v1 = expr1->evaluate(exec); KJS_CHECKEXCEPTIONREFERENCE Value v2 = expr2->evaluate(exec); KJS_CHECKEXCEPTIONREFERENCE #ifndef NDEBUG // catch errors before being caught in toObject(). better error message. if (v1.isA(UndefinedType) || v1.isA(NullType)) { UString s = "Attempted to access property on %s object " "(result of expression %s)"; (void)throwError(exec, TypeError, s.cstring().c_str(), v1, this); return Reference::makeValueReference(Undefined()); } #endif Object o = v1.toObject(exec); unsigned i; if (v2.toUInt32(i)) return Reference(o, i); UString s = v2.toString(exec); return Reference(o, Identifier(s)); } // ----------------------------- AccessorNode2 -------------------------------- void AccessorNode2::ref() { Node::ref(); if ( expr ) expr->ref(); } bool AccessorNode2::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.2.1b Reference AccessorNode2::evaluateReference(ExecState *exec) const { Value v = expr->evaluate(exec); KJS_CHECKEXCEPTIONREFERENCE assert(v.isValid()); #ifndef NDEBUG // catch errors before being caught in toObject(). better error message. if (v.isA(UndefinedType) || v.isA(NullType)) { UString s = "Attempted to access '" + ident.ustring() + "' property on %s object (result of expression %s)"; (void)throwError(exec, TypeError, s.cstring().c_str(), v, this); return Reference::makeValueReference(Undefined()); } #endif Object o = v.toObject(exec); return Reference(o, ident); } // ----------------------------- ArgumentListNode ----------------------------- void ArgumentListNode::ref() { for (ArgumentListNode *n = this; n; n = n->list) { n->Node::ref(); if (n->expr) n->expr->ref(); } } bool ArgumentListNode::deref() { ArgumentListNode *next; for (ArgumentListNode *n = this; n; n = next) { next = n->list; if (n->expr && n->expr->deref()) delete n->expr; if (n != this && n->Node::deref()) delete n; } return Node::deref(); } Value ArgumentListNode::evaluate(ExecState * /*exec*/) const { assert(0); return Value(); // dummy, see evaluateList() } // ECMA 11.2.4 List ArgumentListNode::evaluateList(ExecState *exec) const { List l; for (const ArgumentListNode *n = this; n; n = n->list) { Value v = n->expr->evaluate(exec); KJS_CHECKEXCEPTIONLIST l.append(v); } return l; } // ----------------------------- ArgumentsNode -------------------------------- void ArgumentsNode::ref() { Node::ref(); if ( list ) list->ref(); } bool ArgumentsNode::deref() { if ( list && list->deref() ) delete list; return Node::deref(); } Value ArgumentsNode::evaluate(ExecState * /*exec*/) const { assert(0); return Value(); // dummy, see evaluateList() } // ECMA 11.2.4 List ArgumentsNode::evaluateList(ExecState *exec) const { if (!list) return List(); return list->evaluateList(exec); } // ----------------------------- NewExprNode ---------------------------------- // ECMA 11.2.2 void NewExprNode::ref() { Node::ref(); if ( expr ) expr->ref(); if ( args ) args->ref(); } bool NewExprNode::deref() { if ( expr && expr->deref() ) delete expr; if ( args && args->deref() ) delete args; return Node::deref(); } Value NewExprNode::evaluate(ExecState *exec) const { Value v = expr->evaluate(exec); KJS_CHECKEXCEPTIONVALUE List argList; if (args) { argList = args->evaluateList(exec); KJS_CHECKEXCEPTIONVALUE } if (v.type() != ObjectType) { return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with new.", v, expr); } Object constr = Object(static_cast<ObjectImp*>(v.imp())); if (!constr.implementsConstruct()) { return throwError(exec, TypeError, "Value %s (result of expression %s) is not a constructor. Cannot be used with new.", v, expr); } Value res = constr.construct(exec,argList); return res; } // ----------------------------- FunctionCallNode ----------------------------- void FunctionCallNode::ref() { Node::ref(); if ( expr ) expr->ref(); if ( args ) args->ref(); } bool FunctionCallNode::deref() { if ( expr && expr->deref() ) delete expr; if ( args && args->deref() ) delete args; return Node::deref(); } // ECMA 11.2.3 Value FunctionCallNode::evaluate(ExecState *exec) const { Reference ref = expr->evaluateReference(exec); KJS_CHECKEXCEPTIONVALUE List argList = args->evaluateList(exec); KJS_CHECKEXCEPTIONVALUE Value v = ref.getValue(exec); KJS_CHECKEXCEPTIONVALUE if (v.type() != ObjectType) { return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be called.", v, expr); } Object func = Object(static_cast<ObjectImp*>(v.imp())); if (!func.implementsCall()) { return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, expr); } Value thisVal; if (ref.isMutable()) thisVal = ref.getBase(exec); else thisVal = Null(); if (thisVal.type() == ObjectType && Object::dynamicCast(thisVal).inherits(&ActivationImp::info)) thisVal = Null(); if (thisVal.type() != ObjectType) { // ECMA 11.2.3 says that in this situation the this value should be null. // However, section 10.2.3 says that in the case where the value provided // by the caller is null, the global object should be used. It also says // that the section does not apply to interal functions, but for simplicity // of implementation we use the global object anyway here. This guarantees // that in host objects you always get a valid object for this. // thisVal = Null(); thisVal = exec->dynamicInterpreter()->globalObject(); } Object thisObj = Object::dynamicCast(thisVal); Value result = func.call(exec,thisObj, argList); return result; } // ----------------------------- PostfixNode ---------------------------------- void PostfixNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool PostfixNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.3 Value PostfixNode::evaluate(ExecState *exec) const { Reference ref = expr->evaluateReference(exec); KJS_CHECKEXCEPTIONVALUE Value v = ref.getValue(exec); double n = v.toNumber(exec); double newValue = (oper == OpPlusPlus) ? n + 1 : n - 1; ref.putValue(exec, Number(newValue)); return Number(n); } // ----------------------------- DeleteNode ----------------------------------- void DeleteNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool DeleteNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.4.1 Value DeleteNode::evaluate(ExecState *exec) const { Reference ref = expr->evaluateReference(exec); KJS_CHECKEXCEPTIONVALUE return Boolean(ref.deleteValue(exec)); } // ----------------------------- VoidNode ------------------------------------- void VoidNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool VoidNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.4.2 Value VoidNode::evaluate(ExecState *exec) const { Value dummy1 = expr->evaluate(exec); KJS_CHECKEXCEPTIONVALUE return Undefined(); } // ----------------------------- TypeOfNode ----------------------------------- void TypeOfNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool TypeOfNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.4.3 Value TypeOfNode::evaluate(ExecState *exec) const { const char *s = 0L; Reference ref = expr->evaluateReference(exec); KJS_CHECKEXCEPTIONVALUE if (ref.isMutable()) { Value b = ref.getBase(exec); if (b.type() == NullType) return String("undefined"); } Value v = ref.getValue(exec); switch (v.type()) { case UndefinedType: s = "undefined"; break; case NullType: s = "object"; break; case BooleanType: s = "boolean"; break; case NumberType: s = "number"; break; case StringType: s = "string"; break; default: if (v.type() == ObjectType && static_cast<ObjectImp*>(v.imp())->implementsCall()) s = "function"; else s = "object"; break; } return String(s); } // ----------------------------- PrefixNode ----------------------------------- void PrefixNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool PrefixNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.4.4 and 11.4.5 Value PrefixNode::evaluate(ExecState *exec) const { Reference ref = expr->evaluateReference(exec); KJS_CHECKEXCEPTIONVALUE Value v = ref.getValue(exec); double n = v.toNumber(exec); double newValue = (oper == OpPlusPlus) ? n + 1 : n - 1; Value n2 = Number(newValue); ref.putValue(exec,n2); return n2; } // ----------------------------- UnaryPlusNode -------------------------------- void UnaryPlusNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool UnaryPlusNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.4.6 double UnaryPlusNode::toNumber(ExecState *exec) const { return expr->toNumber(exec); } // could go Value UnaryPlusNode::evaluate(ExecState *exec) const { Value v = expr->evaluate(exec); KJS_CHECKEXCEPTIONVALUE return Number(v.toNumber(exec)); /* TODO: optimize */ } // ----------------------------- NegateNode ----------------------------------- void NegateNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool NegateNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.4.7 double NegateNode::toNumber(ExecState *exec) const { return -expr->toNumber(exec); } Value NegateNode::evaluate(ExecState *exec) const { Value v = expr->evaluate(exec); KJS_CHECKEXCEPTIONVALUE double d = -v.toNumber(exec); return Number(d); } // ----------------------------- BitwiseNotNode ------------------------------- void BitwiseNotNode::ref() { Node::ref(); if ( expr ) expr->ref(); } bool BitwiseNotNode::deref() { if ( expr && expr->deref() ) delete expr; return Node::deref(); } // ECMA 11.4.8 Value BitwiseNotNode::evaluate(ExecState *exec) const { Value v = expr->evaluate(exec); KJS_CHECKEXCEPTIONVALUE int i32 = v.toInt32(exec); return Number(~i32); }