|
|
|
/*
|
|
|
|
* 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, "[nodes] 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, "[nodes] [%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);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- LogicalNotNode -------------------------------
|
|
|
|
|
|
|
|
void LogicalNotNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LogicalNotNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.4.9
|
|
|
|
bool LogicalNotNode::toBoolean(ExecState *exec) const
|
|
|
|
{
|
|
|
|
return !expr->toBoolean(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// could remove this
|
|
|
|
Value LogicalNotNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
bool b = expr->toBoolean(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return Boolean(!b);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- MultNode -------------------------------------
|
|
|
|
|
|
|
|
void MultNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( term1 )
|
|
|
|
term1->ref();
|
|
|
|
if ( term2 )
|
|
|
|
term2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MultNode::deref()
|
|
|
|
{
|
|
|
|
if ( term1 && term1->deref() )
|
|
|
|
delete term1;
|
|
|
|
if ( term2 && term2->deref() )
|
|
|
|
delete term2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.5
|
|
|
|
Value MultNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v1 = term1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
Value v2 = term2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return mult(exec,v1, v2, oper);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- AddNode --------------------------------------
|
|
|
|
|
|
|
|
// factory for an appropriate addition or substraction node
|
|
|
|
Node* AddNode::create(Node *t1, Node *t2, char op)
|
|
|
|
{
|
|
|
|
// ### many more combinations to check for
|
|
|
|
// fold constants
|
|
|
|
if ((t1->type() == NumberType || t1->type() == BooleanType) &&
|
|
|
|
(t2->type() == NumberType || t2->type() == BooleanType)) {
|
|
|
|
double d = t2->toNumber(0);
|
|
|
|
Node* n = new NumberNode(t1->toNumber(0) + (op == '+' ? d : -d));
|
|
|
|
delete t1;
|
|
|
|
delete t2;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op == '+' && t2->type() == StringType)
|
|
|
|
return new AppendStringNode(t1, t2->toString(0));
|
|
|
|
|
|
|
|
// fall back to generic node
|
|
|
|
return new AddNode(t1, t2, op);
|
|
|
|
}
|
|
|
|
|
|
|
|
void AddNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( term1 )
|
|
|
|
term1->ref();
|
|
|
|
if ( term2 )
|
|
|
|
term2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AddNode::deref()
|
|
|
|
{
|
|
|
|
if ( term1 && term1->deref() )
|
|
|
|
delete term1;
|
|
|
|
if ( term2 && term2->deref() )
|
|
|
|
delete term2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.6
|
|
|
|
Value AddNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v1 = term1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
Value v2 = term2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return add(exec,v1, v2, oper);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ------------------------ AddNumberNode ------------------------------------
|
|
|
|
|
|
|
|
void AppendStringNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
term->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AppendStringNode::deref()
|
|
|
|
{
|
|
|
|
if (term->deref())
|
|
|
|
delete term;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.6 (special case of string appending)
|
|
|
|
Value AppendStringNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
UString s = term->toString(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return String(s + str);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ShiftNode ------------------------------------
|
|
|
|
|
|
|
|
void ShiftNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( term1 )
|
|
|
|
term1->ref();
|
|
|
|
if ( term2 )
|
|
|
|
term2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ShiftNode::deref()
|
|
|
|
{
|
|
|
|
if ( term1 && term1->deref() )
|
|
|
|
delete term1;
|
|
|
|
if ( term2 && term2->deref() )
|
|
|
|
delete term2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.7
|
|
|
|
Value ShiftNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v1 = term1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
Value v2 = term2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
unsigned int i2 = v2.toUInt32(exec);
|
|
|
|
i2 &= 0x1f;
|
|
|
|
|
|
|
|
switch (oper) {
|
|
|
|
case OpLShift:
|
|
|
|
return Number(v1.toInt32(exec) << i2);
|
|
|
|
case OpRShift:
|
|
|
|
return Number(v1.toInt32(exec) >> i2);
|
|
|
|
case OpURShift:
|
|
|
|
return Number(v1.toUInt32(exec) >> i2);
|
|
|
|
default:
|
|
|
|
assert(!"ShiftNode: unhandled switch case");
|
|
|
|
return Undefined();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- RelationalNode -------------------------------
|
|
|
|
|
|
|
|
void RelationalNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr1 )
|
|
|
|
expr1->ref();
|
|
|
|
if ( expr2 )
|
|
|
|
expr2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool RelationalNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr1 && expr1->deref() )
|
|
|
|
delete expr1;
|
|
|
|
if ( expr2 && expr2->deref() )
|
|
|
|
delete expr2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.8
|
|
|
|
Value RelationalNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v1 = expr1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
Value v2 = expr2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
bool b;
|
|
|
|
if (oper == OpLess || oper == OpGreaterEq) {
|
|
|
|
int r = relation(exec, v1, v2);
|
|
|
|
if (r < 0)
|
|
|
|
b = false;
|
|
|
|
else
|
|
|
|
b = (oper == OpLess) ? (r == 1) : (r == 0);
|
|
|
|
} else if (oper == OpGreater || oper == OpLessEq) {
|
|
|
|
int r = relation(exec, v2, v1);
|
|
|
|
if (r < 0)
|
|
|
|
b = false;
|
|
|
|
else
|
|
|
|
b = (oper == OpGreater) ? (r == 1) : (r == 0);
|
|
|
|
} else if (oper == OpIn) {
|
|
|
|
// Is all of this OK for host objects?
|
|
|
|
if (v2.type() != ObjectType)
|
|
|
|
return throwError(exec, TypeError,
|
|
|
|
"Value %s (result of expression %s) is not an object. Cannot be used with IN expression.", v2, expr2);
|
|
|
|
Object o2(static_cast<ObjectImp*>(v2.imp()));
|
|
|
|
b = o2.hasProperty(exec,Identifier(v1.toString(exec)));
|
|
|
|
} else {
|
|
|
|
if (v2.type() != ObjectType)
|
|
|
|
return throwError(exec, TypeError,
|
|
|
|
"Value %s (result of expression %s) is not an object. Cannot be used with instanceof operator.", v2, expr2);
|
|
|
|
|
|
|
|
Object o2(static_cast<ObjectImp*>(v2.imp()));
|
|
|
|
if (!o2.implementsHasInstance()) {
|
|
|
|
// According to the spec, only some types of objects "imlement" the [[HasInstance]] property.
|
|
|
|
// But we are supposed to throw an exception where the object does not "have" the [[HasInstance]]
|
|
|
|
// property. It seems that all object have the property, but not all implement it, so in this
|
|
|
|
// case we return false (consistent with mozilla)
|
|
|
|
return Boolean(false);
|
|
|
|
// return throwError(exec, TypeError,
|
|
|
|
// "Object does not implement the [[HasInstance]] method." );
|
|
|
|
}
|
|
|
|
return o2.hasInstance(exec, v1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Boolean(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- EqualNode ------------------------------------
|
|
|
|
|
|
|
|
void EqualNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr1 )
|
|
|
|
expr1->ref();
|
|
|
|
if ( expr2 )
|
|
|
|
expr2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool EqualNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr1 && expr1->deref() )
|
|
|
|
delete expr1;
|
|
|
|
if ( expr2 && expr2->deref() )
|
|
|
|
delete expr2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.9
|
|
|
|
Value EqualNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v1 = expr1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
Value v2 = expr2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
bool result;
|
|
|
|
if (oper == OpEqEq || oper == OpNotEq) {
|
|
|
|
// == and !=
|
|
|
|
bool eq = equal(exec,v1, v2);
|
|
|
|
result = oper == OpEqEq ? eq : !eq;
|
|
|
|
} else {
|
|
|
|
// === and !==
|
|
|
|
bool eq = strictEqual(exec,v1, v2);
|
|
|
|
result = oper == OpStrEq ? eq : !eq;
|
|
|
|
}
|
|
|
|
return Boolean(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- BitOperNode ----------------------------------
|
|
|
|
|
|
|
|
void BitOperNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr1 )
|
|
|
|
expr1->ref();
|
|
|
|
if ( expr2 )
|
|
|
|
expr2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitOperNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr1 && expr1->deref() )
|
|
|
|
delete expr1;
|
|
|
|
if ( expr2 && expr2->deref() )
|
|
|
|
delete expr2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.10
|
|
|
|
Value BitOperNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v1 = expr1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
Value v2 = expr2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
int i1 = v1.toInt32(exec);
|
|
|
|
int i2 = v2.toInt32(exec);
|
|
|
|
int result;
|
|
|
|
if (oper == OpBitAnd)
|
|
|
|
result = i1 & i2;
|
|
|
|
else if (oper == OpBitXOr)
|
|
|
|
result = i1 ^ i2;
|
|
|
|
else
|
|
|
|
result = i1 | i2;
|
|
|
|
|
|
|
|
return Number(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- BinaryLogicalNode ----------------------------
|
|
|
|
|
|
|
|
void BinaryLogicalNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr1 )
|
|
|
|
expr1->ref();
|
|
|
|
if ( expr2 )
|
|
|
|
expr2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BinaryLogicalNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr1 && expr1->deref() )
|
|
|
|
delete expr1;
|
|
|
|
if ( expr2 && expr2->deref() )
|
|
|
|
delete expr2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.11
|
|
|
|
Value BinaryLogicalNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v1 = expr1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
bool b1 = v1.toBoolean(exec);
|
|
|
|
if ((!b1 && oper == OpAnd) || (b1 && oper == OpOr))
|
|
|
|
return v1;
|
|
|
|
|
|
|
|
Value v2 = expr2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return v2;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ConditionalNode ------------------------------
|
|
|
|
|
|
|
|
void ConditionalNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr1 )
|
|
|
|
expr1->ref();
|
|
|
|
if ( expr2 )
|
|
|
|
expr2->ref();
|
|
|
|
if ( logical )
|
|
|
|
logical->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ConditionalNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr1 && expr1->deref() )
|
|
|
|
delete expr1;
|
|
|
|
if ( expr2 && expr2->deref() )
|
|
|
|
delete expr2;
|
|
|
|
if ( logical && logical->deref() )
|
|
|
|
delete logical;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.12
|
|
|
|
Value ConditionalNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
bool b = logical->toBoolean(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
Value v = b ? expr1->evaluate(exec) : expr2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- AssignNode -----------------------------------
|
|
|
|
|
|
|
|
void AssignNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( left )
|
|
|
|
left->ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AssignNode::deref()
|
|
|
|
{
|
|
|
|
if ( left && left->deref() )
|
|
|
|
delete left;
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.13
|
|
|
|
Value AssignNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Reference l = left->evaluateReference(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
Value v;
|
|
|
|
if (oper == OpEqual) {
|
|
|
|
v = expr->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
} else {
|
|
|
|
Value v1 = l.getValue(exec);
|
|
|
|
Value v2 = expr->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
int i1;
|
|
|
|
int i2;
|
|
|
|
unsigned int ui;
|
|
|
|
switch (oper) {
|
|
|
|
case OpMultEq:
|
|
|
|
v = mult(exec, v1, v2, '*');
|
|
|
|
break;
|
|
|
|
case OpDivEq:
|
|
|
|
v = mult(exec, v1, v2, '/');
|
|
|
|
break;
|
|
|
|
case OpPlusEq:
|
|
|
|
v = add(exec, v1, v2, '+');
|
|
|
|
break;
|
|
|
|
case OpMinusEq:
|
|
|
|
v = add(exec, v1, v2, '-');
|
|
|
|
break;
|
|
|
|
case OpLShift:
|
|
|
|
i1 = v1.toInt32(exec);
|
|
|
|
i2 = v2.toInt32(exec);
|
|
|
|
v = Number(i1 << i2);
|
|
|
|
break;
|
|
|
|
case OpRShift:
|
|
|
|
i1 = v1.toInt32(exec);
|
|
|
|
i2 = v2.toInt32(exec);
|
|
|
|
v = Number(i1 >> i2);
|
|
|
|
break;
|
|
|
|
case OpURShift:
|
|
|
|
ui = v1.toUInt32(exec);
|
|
|
|
i2 = v2.toInt32(exec);
|
|
|
|
v = Number(ui >> i2);
|
|
|
|
break;
|
|
|
|
case OpAndEq:
|
|
|
|
i1 = v1.toInt32(exec);
|
|
|
|
i2 = v2.toInt32(exec);
|
|
|
|
v = Number(i1 & i2);
|
|
|
|
break;
|
|
|
|
case OpXOrEq:
|
|
|
|
i1 = v1.toInt32(exec);
|
|
|
|
i2 = v2.toInt32(exec);
|
|
|
|
v = Number(i1 ^ i2);
|
|
|
|
break;
|
|
|
|
case OpOrEq:
|
|
|
|
i1 = v1.toInt32(exec);
|
|
|
|
i2 = v2.toInt32(exec);
|
|
|
|
v = Number(i1 | i2);
|
|
|
|
break;
|
|
|
|
case OpModEq: {
|
|
|
|
double d1 = v1.toNumber(exec);
|
|
|
|
double d2 = v2.toNumber(exec);
|
|
|
|
v = Number(fmod(d1,d2));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
v = Undefined();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
l.putValue(exec,v);
|
|
|
|
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- CommaNode ------------------------------------
|
|
|
|
|
|
|
|
void CommaNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr1 )
|
|
|
|
expr1->ref();
|
|
|
|
if ( expr2 )
|
|
|
|
expr2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CommaNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr1 && expr1->deref() )
|
|
|
|
delete expr1;
|
|
|
|
if ( expr2 && expr2->deref() )
|
|
|
|
delete expr2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 11.14
|
|
|
|
Value CommaNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
(void) expr1->evaluate(exec); // ignore return value
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
Value v = expr2->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- StatListNode ---------------------------------
|
|
|
|
|
|
|
|
StatListNode::StatListNode(StatementNode *s)
|
|
|
|
: statement(s), list(this)
|
|
|
|
{
|
|
|
|
setLoc(s->firstLine(), s->lastLine(), s->code());
|
|
|
|
}
|
|
|
|
|
|
|
|
StatListNode::StatListNode(StatListNode *l, StatementNode *s)
|
|
|
|
: statement(s), list(l->list)
|
|
|
|
{
|
|
|
|
l->list = this;
|
|
|
|
setLoc(l->firstLine(),s->lastLine(),l->code());
|
|
|
|
}
|
|
|
|
|
|
|
|
void StatListNode::ref()
|
|
|
|
{
|
|
|
|
for (StatListNode *n = this; n; n = n->list) {
|
|
|
|
n->Node::ref();
|
|
|
|
if (n->statement)
|
|
|
|
n->statement->ref();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool StatListNode::deref()
|
|
|
|
{
|
|
|
|
StatListNode *next;
|
|
|
|
for (StatListNode *n = this; n; n = next) {
|
|
|
|
next = n->list;
|
|
|
|
if (n->statement && n->statement->deref())
|
|
|
|
delete n->statement;
|
|
|
|
if (n != this && n->Node::deref())
|
|
|
|
delete n;
|
|
|
|
}
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.1
|
|
|
|
Completion StatListNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
Completion c = statement->execute(exec);
|
|
|
|
KJS_ABORTPOINT
|
|
|
|
if (exec->hadException()) {
|
|
|
|
Value ex = exec->exception();
|
|
|
|
exec->clearException();
|
|
|
|
return Completion(Throw, ex);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c.complType() != Normal)
|
|
|
|
return c;
|
|
|
|
|
|
|
|
Value v = c.value();
|
|
|
|
|
|
|
|
for (StatListNode *n = list; n; n = n->list) {
|
|
|
|
Completion c2 = n->statement->execute(exec);
|
|
|
|
KJS_ABORTPOINT
|
|
|
|
if (c2.complType() != Normal)
|
|
|
|
return c2;
|
|
|
|
|
|
|
|
if (exec->hadException()) {
|
|
|
|
Value ex = exec->exception();
|
|
|
|
exec->clearException();
|
|
|
|
return Completion(Throw, ex);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c2.isValueCompletion())
|
|
|
|
v = c2.value();
|
|
|
|
c = c2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Completion(c.complType(), v, c.target());
|
|
|
|
}
|
|
|
|
|
|
|
|
void StatListNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
for (StatListNode *n = this; n; n = n->list)
|
|
|
|
n->statement->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- AssignExprNode -------------------------------
|
|
|
|
|
|
|
|
void AssignExprNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AssignExprNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.2
|
|
|
|
Value AssignExprNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
return expr->evaluate(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- VarDeclNode ----------------------------------
|
|
|
|
|
|
|
|
VarDeclNode::VarDeclNode(const Identifier &id, AssignExprNode *in, Type t)
|
|
|
|
: varType(t), ident(id), init(in)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void VarDeclNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( init )
|
|
|
|
init->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VarDeclNode::deref()
|
|
|
|
{
|
|
|
|
if ( init && init->deref() )
|
|
|
|
delete init;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.2
|
|
|
|
Value VarDeclNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Object variable = Object::dynamicCast(exec->context().imp()->variableObject());
|
|
|
|
|
|
|
|
Value val;
|
|
|
|
if (init) {
|
|
|
|
val = init->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
} else {
|
|
|
|
// ### check attributes? reuse check done in processVarDecls()?
|
|
|
|
if (variable.imp()->getDirect(ident)) // already declared ?
|
|
|
|
return Value();
|
|
|
|
val = Undefined();
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef KJS_VERBOSE
|
|
|
|
printInfo(exec,(UString("new variable ")+ident.ustring()).cstring().c_str(),val);
|
|
|
|
#endif
|
|
|
|
// We use Internal to bypass all checks in derived objects, e.g. so that
|
|
|
|
// "var location" creates a dynamic property instead of activating window.location.
|
|
|
|
int flags = Internal;
|
|
|
|
if (exec->context().imp()->codeType() != EvalCode)
|
|
|
|
flags |= DontDelete;
|
|
|
|
if (varType == VarDeclNode::Constant)
|
|
|
|
flags |= ReadOnly;
|
|
|
|
variable.put(exec, ident, val, flags);
|
|
|
|
|
|
|
|
// the spec wants us to return the name of the identifier here
|
|
|
|
// but we'll save the construction and copying as the return
|
|
|
|
// value isn't used by the caller
|
|
|
|
return Value();
|
|
|
|
}
|
|
|
|
|
|
|
|
void VarDeclNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
Object variable = exec->context().variableObject();
|
|
|
|
// ### use getDirect()? Check attributes?
|
|
|
|
// ### avoid duplication with actions performed in evaluate()?
|
|
|
|
if ( !variable.hasProperty( exec, ident ) ) { // already declared ?
|
|
|
|
int flags = None;
|
|
|
|
if (exec->_context->codeType() != EvalCode)
|
|
|
|
flags |= DontDelete;
|
|
|
|
if (varType == VarDeclNode::Constant)
|
|
|
|
flags |= ReadOnly;
|
|
|
|
// TODO: check for forbidden redeclaration of consts
|
|
|
|
variable.put(exec, ident, Undefined(), flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- VarDeclListNode ------------------------------
|
|
|
|
|
|
|
|
void VarDeclListNode::ref()
|
|
|
|
{
|
|
|
|
for (VarDeclListNode *n = this; n; n = n->list) {
|
|
|
|
n->Node::ref();
|
|
|
|
if (n->var)
|
|
|
|
n->var->ref();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VarDeclListNode::deref()
|
|
|
|
{
|
|
|
|
VarDeclListNode *next;
|
|
|
|
for (VarDeclListNode *n = this; n; n = next) {
|
|
|
|
next = n->list;
|
|
|
|
if (n->var && n->var->deref())
|
|
|
|
delete n->var;
|
|
|
|
if (n != this && n->Node::deref())
|
|
|
|
delete n;
|
|
|
|
}
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ECMA 12.2
|
|
|
|
Value VarDeclListNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
for (const VarDeclListNode *n = this; n; n = n->list) {
|
|
|
|
(void)n->var->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
}
|
|
|
|
return Undefined();
|
|
|
|
}
|
|
|
|
|
|
|
|
void VarDeclListNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
for (VarDeclListNode *n = this; n; n = n->list)
|
|
|
|
n->var->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- VarStatementNode -----------------------------
|
|
|
|
|
|
|
|
void VarStatementNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( list )
|
|
|
|
list->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VarStatementNode::deref()
|
|
|
|
{
|
|
|
|
if ( list && list->deref() )
|
|
|
|
delete list;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.2
|
|
|
|
Completion VarStatementNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
(void) list->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
return Completion(Normal);
|
|
|
|
}
|
|
|
|
|
|
|
|
void VarStatementNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
list->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- BlockNode ------------------------------------
|
|
|
|
|
|
|
|
BlockNode::BlockNode(SourceElementsNode *s)
|
|
|
|
{
|
|
|
|
if (s) {
|
|
|
|
source = s->elements;
|
|
|
|
s->elements = 0;
|
|
|
|
setLoc(s->firstLine(), s->lastLine(), s->code());
|
|
|
|
} else {
|
|
|
|
source = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void BlockNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( source )
|
|
|
|
source->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BlockNode::deref()
|
|
|
|
{
|
|
|
|
if ( source && source->deref() )
|
|
|
|
delete source;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.1
|
|
|
|
Completion BlockNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
if (!source)
|
|
|
|
return Completion(Normal);
|
|
|
|
|
|
|
|
source->processFuncDecl(exec);
|
|
|
|
|
|
|
|
return source->execute(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
void BlockNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
if (source)
|
|
|
|
source->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- EmptyStatementNode ---------------------------
|
|
|
|
|
|
|
|
// ECMA 12.3
|
|
|
|
Completion EmptyStatementNode::execute(ExecState * /*exec*/)
|
|
|
|
{
|
|
|
|
return Completion(Normal);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ExprStatementNode ----------------------------
|
|
|
|
|
|
|
|
void ExprStatementNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ExprStatementNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.4
|
|
|
|
Completion ExprStatementNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Value v = expr->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
return Completion(Normal, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- IfNode ---------------------------------------
|
|
|
|
|
|
|
|
void IfNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( statement1 )
|
|
|
|
statement1->ref();
|
|
|
|
if ( statement2 )
|
|
|
|
statement2->ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IfNode::deref()
|
|
|
|
{
|
|
|
|
if ( statement1 && statement1->deref() )
|
|
|
|
delete statement1;
|
|
|
|
if ( statement2 && statement2->deref() )
|
|
|
|
delete statement2;
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.5
|
|
|
|
Completion IfNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
assert(expr);
|
|
|
|
bool b = expr->toBoolean(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
// if ... then
|
|
|
|
if (b)
|
|
|
|
return statement1->execute(exec);
|
|
|
|
|
|
|
|
// no else
|
|
|
|
if (!statement2)
|
|
|
|
return Completion(Normal);
|
|
|
|
|
|
|
|
// else
|
|
|
|
return statement2->execute(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
void IfNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
statement1->processVarDecls(exec);
|
|
|
|
|
|
|
|
if (statement2)
|
|
|
|
statement2->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- DoWhileNode ----------------------------------
|
|
|
|
|
|
|
|
void DoWhileNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( statement )
|
|
|
|
statement->ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool DoWhileNode::deref()
|
|
|
|
{
|
|
|
|
if ( statement && statement->deref() )
|
|
|
|
delete statement;
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.6.1
|
|
|
|
Completion DoWhileNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Completion c;
|
|
|
|
Value value;
|
|
|
|
bool b;
|
|
|
|
|
|
|
|
do {
|
|
|
|
// bail out on error
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
exec->context().imp()->seenLabels()->pushIteration();
|
|
|
|
c = statement->execute(exec);
|
|
|
|
exec->context().imp()->seenLabels()->popIteration();
|
|
|
|
if (!((c.complType() == Continue) && ls.contains(c.target()))) {
|
|
|
|
if ((c.complType() == Break) && ls.contains(c.target()))
|
|
|
|
return Completion(Normal, value);
|
|
|
|
if (c.complType() != Normal)
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
b = expr->toBoolean(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
} while (b);
|
|
|
|
|
|
|
|
return Completion(Normal, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DoWhileNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
statement->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- WhileNode ------------------------------------
|
|
|
|
|
|
|
|
void WhileNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( statement )
|
|
|
|
statement->ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool WhileNode::deref()
|
|
|
|
{
|
|
|
|
if ( statement && statement->deref() )
|
|
|
|
delete statement;
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.6.2
|
|
|
|
Completion WhileNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Completion c;
|
|
|
|
Value value;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
bool b = expr->toBoolean(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
// bail out on error
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
if (!b)
|
|
|
|
return Completion(Normal, value);
|
|
|
|
|
|
|
|
exec->context().imp()->seenLabels()->pushIteration();
|
|
|
|
c = statement->execute(exec);
|
|
|
|
exec->context().imp()->seenLabels()->popIteration();
|
|
|
|
if (c.isValueCompletion())
|
|
|
|
value = c.value();
|
|
|
|
|
|
|
|
if ((c.complType() == Continue) && ls.contains(c.target()))
|
|
|
|
continue;
|
|
|
|
if ((c.complType() == Break) && ls.contains(c.target()))
|
|
|
|
return Completion(Normal, value);
|
|
|
|
if (c.complType() != Normal)
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void WhileNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
statement->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ForNode --------------------------------------
|
|
|
|
|
|
|
|
void ForNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( statement )
|
|
|
|
statement->ref();
|
|
|
|
if ( expr1 )
|
|
|
|
expr1->ref();
|
|
|
|
if ( expr2 )
|
|
|
|
expr2->ref();
|
|
|
|
if ( expr3 )
|
|
|
|
expr3->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ForNode::deref()
|
|
|
|
{
|
|
|
|
if ( statement && statement->deref() )
|
|
|
|
delete statement;
|
|
|
|
if ( expr1 && expr1->deref() )
|
|
|
|
delete expr1;
|
|
|
|
if ( expr2 && expr2->deref() )
|
|
|
|
delete expr2;
|
|
|
|
if ( expr3 && expr3->deref() )
|
|
|
|
delete expr3;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.6.3
|
|
|
|
Completion ForNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
Value v, cval;
|
|
|
|
|
|
|
|
if (expr1) {
|
|
|
|
v = expr1->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
}
|
|
|
|
for (;;) {
|
|
|
|
if (expr2) {
|
|
|
|
bool b = expr2->toBoolean(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
if (!b)
|
|
|
|
return Completion(Normal, cval);
|
|
|
|
}
|
|
|
|
// bail out on error
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
exec->context().imp()->seenLabels()->pushIteration();
|
|
|
|
Completion c = statement->execute(exec);
|
|
|
|
exec->context().imp()->seenLabels()->popIteration();
|
|
|
|
if (c.isValueCompletion())
|
|
|
|
cval = c.value();
|
|
|
|
if (!((c.complType() == Continue) && ls.contains(c.target()))) {
|
|
|
|
if ((c.complType() == Break) && ls.contains(c.target()))
|
|
|
|
return Completion(Normal, cval);
|
|
|
|
if (c.complType() != Normal)
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
if (expr3) {
|
|
|
|
v = expr3->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ForNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
if (expr1)
|
|
|
|
expr1->processVarDecls(exec);
|
|
|
|
|
|
|
|
statement->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ForInNode ------------------------------------
|
|
|
|
|
|
|
|
ForInNode::ForInNode(Node *l, Node *e, StatementNode *s)
|
|
|
|
: init(0L), lexpr(l), expr(e), varDecl(0L), statement(s)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
ForInNode::ForInNode(const Identifier &i, AssignExprNode *in, Node *e, StatementNode *s)
|
|
|
|
: ident(i), init(in), expr(e), statement(s)
|
|
|
|
{
|
|
|
|
// for( var foo = bar in baz )
|
|
|
|
varDecl = new VarDeclNode(ident, init, VarDeclNode::Variable);
|
|
|
|
lexpr = new ResolveNode(ident);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ForInNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( statement )
|
|
|
|
statement->ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
if ( lexpr )
|
|
|
|
lexpr->ref();
|
|
|
|
if ( init )
|
|
|
|
init->ref();
|
|
|
|
if ( varDecl )
|
|
|
|
varDecl->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ForInNode::deref()
|
|
|
|
{
|
|
|
|
if ( statement && statement->deref() )
|
|
|
|
delete statement;
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
if ( lexpr && lexpr->deref() )
|
|
|
|
delete lexpr;
|
|
|
|
if ( init && init->deref() )
|
|
|
|
delete init;
|
|
|
|
if ( varDecl && varDecl->deref() )
|
|
|
|
delete varDecl;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.6.4
|
|
|
|
Completion ForInNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
Value retval;
|
|
|
|
Completion c;
|
|
|
|
|
|
|
|
if ( varDecl ) {
|
|
|
|
(void)varDecl->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
}
|
|
|
|
|
|
|
|
Value v = expr->evaluate(exec);
|
|
|
|
// for Null and Undefined, we want to make sure not to go through
|
|
|
|
// the loop at all, because their object wrappers will have a
|
|
|
|
// property list but will throw an exception if you attempt to
|
|
|
|
// access any property.
|
|
|
|
if (v.isA(NullType) || v.isA(UndefinedType))
|
|
|
|
return Completion(Normal, retval);
|
|
|
|
|
|
|
|
Object o = v.toObject(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
ReferenceList propList = o.propList(exec);
|
|
|
|
|
|
|
|
ReferenceListIterator propIt = propList.begin();
|
|
|
|
|
|
|
|
while (propIt != propList.end()) {
|
|
|
|
Identifier name = propIt->getPropertyName(exec);
|
|
|
|
if (!o.hasProperty(exec,name)) {
|
|
|
|
propIt++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
Reference ref = lexpr->evaluateReference(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
ref.putValue(exec, String(name.ustring()));
|
|
|
|
|
|
|
|
exec->context().imp()->seenLabels()->pushIteration();
|
|
|
|
c = statement->execute(exec);
|
|
|
|
exec->context().imp()->seenLabels()->popIteration();
|
|
|
|
if (c.isValueCompletion())
|
|
|
|
retval = c.value();
|
|
|
|
|
|
|
|
if (!((c.complType() == Continue) && ls.contains(c.target()))) {
|
|
|
|
if ((c.complType() == Break) && ls.contains(c.target()))
|
|
|
|
break;
|
|
|
|
if (c.complType() != Normal) {
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
propIt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// bail out on error
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
return Completion(Normal, retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ForInNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
statement->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ContinueNode ---------------------------------
|
|
|
|
|
|
|
|
// ECMA 12.7
|
|
|
|
Completion ContinueNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Value dummy;
|
|
|
|
|
|
|
|
if (ident.isEmpty() && !exec->context().imp()->seenLabels()->inIteration())
|
|
|
|
return Completion(Throw,
|
|
|
|
throwError(exec, SyntaxError, "continue used outside of iteration statement"));
|
|
|
|
else if (!ident.isEmpty() && !exec->context().imp()->seenLabels()->contains(ident))
|
|
|
|
return Completion(Throw,
|
|
|
|
throwError(exec, SyntaxError, "Label %s not found in containing block. Can't continue.", ident));
|
|
|
|
else
|
|
|
|
return Completion(Continue, dummy, ident);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- BreakNode ------------------------------------
|
|
|
|
|
|
|
|
// ECMA 12.8
|
|
|
|
Completion BreakNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Value dummy;
|
|
|
|
|
|
|
|
if (ident.isEmpty() && !exec->context().imp()->seenLabels()->inIteration() &&
|
|
|
|
!exec->context().imp()->seenLabels()->inSwitch())
|
|
|
|
return Completion(Throw,
|
|
|
|
throwError(exec, SyntaxError, "break used outside of iteration or switch statement"));
|
|
|
|
else if (!ident.isEmpty() && !exec->context().imp()->seenLabels()->contains(ident))
|
|
|
|
return Completion(Throw,
|
|
|
|
throwError(exec, SyntaxError, "Label %s not found in containing block. Can't break.", ident));
|
|
|
|
else
|
|
|
|
return Completion(Break, dummy, ident);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ReturnNode -----------------------------------
|
|
|
|
|
|
|
|
void ReturnNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( value )
|
|
|
|
value->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ReturnNode::deref()
|
|
|
|
{
|
|
|
|
if ( value && value->deref() )
|
|
|
|
delete value;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.9
|
|
|
|
Completion ReturnNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
CodeType codeType = exec->context().imp()->codeType();
|
|
|
|
if (codeType != FunctionCode) {
|
|
|
|
return Completion(Throw, throwError(exec, SyntaxError, "Invalid return statement."));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!value)
|
|
|
|
return Completion(ReturnValue, Undefined());
|
|
|
|
|
|
|
|
Value v = value->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
return Completion(ReturnValue, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- WithNode -------------------------------------
|
|
|
|
|
|
|
|
void WithNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( statement )
|
|
|
|
statement->ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool WithNode::deref()
|
|
|
|
{
|
|
|
|
if ( statement && statement->deref() )
|
|
|
|
delete statement;
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.10
|
|
|
|
Completion WithNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Value v = expr->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
Object o = v.toObject(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
exec->context().imp()->pushScope(o);
|
|
|
|
Completion res = statement->execute(exec);
|
|
|
|
exec->context().imp()->popScope();
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WithNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
statement->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- CaseClauseNode -------------------------------
|
|
|
|
|
|
|
|
void CaseClauseNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
if ( list )
|
|
|
|
list->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CaseClauseNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
if ( list && list->deref() )
|
|
|
|
delete list;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.11
|
|
|
|
Value CaseClauseNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
Value v = expr->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTIONVALUE
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.11
|
|
|
|
Completion CaseClauseNode::evalStatements(ExecState *exec) const
|
|
|
|
{
|
|
|
|
if (list)
|
|
|
|
return list->execute(exec);
|
|
|
|
else
|
|
|
|
return Completion(Normal, Undefined());
|
|
|
|
}
|
|
|
|
|
|
|
|
void CaseClauseNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
if (list)
|
|
|
|
list->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ClauseListNode -------------------------------
|
|
|
|
|
|
|
|
void ClauseListNode::ref()
|
|
|
|
{
|
|
|
|
for (ClauseListNode *n = this; n; n = n->nx) {
|
|
|
|
n->Node::ref();
|
|
|
|
if (n->cl)
|
|
|
|
n->cl->ref();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ClauseListNode::deref()
|
|
|
|
{
|
|
|
|
ClauseListNode *next;
|
|
|
|
for (ClauseListNode *n = this; n; n = next) {
|
|
|
|
next = n->nx;
|
|
|
|
if (n->cl && n->cl->deref())
|
|
|
|
delete n->cl;
|
|
|
|
if (n != this && n->Node::deref())
|
|
|
|
delete n;
|
|
|
|
}
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
Value ClauseListNode::evaluate(ExecState * /*exec*/) const
|
|
|
|
{
|
|
|
|
/* should never be called */
|
|
|
|
assert(false);
|
|
|
|
return Value();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.11
|
|
|
|
void ClauseListNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
for (ClauseListNode *n = this; n; n = n->nx)
|
|
|
|
if (n->cl)
|
|
|
|
n->cl->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- CaseBlockNode --------------------------------
|
|
|
|
|
|
|
|
CaseBlockNode::CaseBlockNode(ClauseListNode *l1, CaseClauseNode *d,
|
|
|
|
ClauseListNode *l2)
|
|
|
|
{
|
|
|
|
def = d;
|
|
|
|
if (l1) {
|
|
|
|
list1 = l1->nx;
|
|
|
|
l1->nx = 0;
|
|
|
|
} else {
|
|
|
|
list1 = 0;
|
|
|
|
}
|
|
|
|
if (l2) {
|
|
|
|
list2 = l2->nx;
|
|
|
|
l2->nx = 0;
|
|
|
|
} else {
|
|
|
|
list2 = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CaseBlockNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( def )
|
|
|
|
def->ref();
|
|
|
|
if ( list1 )
|
|
|
|
list1->ref();
|
|
|
|
if ( list2 )
|
|
|
|
list2->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CaseBlockNode::deref()
|
|
|
|
{
|
|
|
|
if ( def && def->deref() )
|
|
|
|
delete def;
|
|
|
|
if ( list1 && list1->deref() )
|
|
|
|
delete list1;
|
|
|
|
if ( list2 && list2->deref() )
|
|
|
|
delete list2;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
Value CaseBlockNode::evaluate(ExecState * /*exec*/) const
|
|
|
|
{
|
|
|
|
/* should never be called */
|
|
|
|
assert(false);
|
|
|
|
return Value();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.11
|
|
|
|
Completion CaseBlockNode::evalBlock(ExecState *exec, const Value& input) const
|
|
|
|
{
|
|
|
|
Value v;
|
|
|
|
Completion res;
|
|
|
|
ClauseListNode *a = list1, *b = list2;
|
|
|
|
CaseClauseNode *clause;
|
|
|
|
|
|
|
|
while (a) {
|
|
|
|
clause = a->clause();
|
|
|
|
a = a->next();
|
|
|
|
v = clause->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
if (strictEqual(exec, input, v)) {
|
|
|
|
res = clause->evalStatements(exec);
|
|
|
|
if (res.complType() != Normal)
|
|
|
|
return res;
|
|
|
|
while (a) {
|
|
|
|
res = a->clause()->evalStatements(exec);
|
|
|
|
if (res.complType() != Normal)
|
|
|
|
return res;
|
|
|
|
a = a->next();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (b) {
|
|
|
|
clause = b->clause();
|
|
|
|
b = b->next();
|
|
|
|
v = clause->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
if (strictEqual(exec, input, v)) {
|
|
|
|
res = clause->evalStatements(exec);
|
|
|
|
if (res.complType() != Normal)
|
|
|
|
return res;
|
|
|
|
goto step18;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// default clause
|
|
|
|
if (def) {
|
|
|
|
res = def->evalStatements(exec);
|
|
|
|
if (res.complType() != Normal)
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
b = list2;
|
|
|
|
step18:
|
|
|
|
while (b) {
|
|
|
|
clause = b->clause();
|
|
|
|
res = clause->evalStatements(exec);
|
|
|
|
if (res.complType() != Normal)
|
|
|
|
return res;
|
|
|
|
b = b->next();
|
|
|
|
}
|
|
|
|
|
|
|
|
// bail out on error
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
return Completion(Normal);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CaseBlockNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
if (list1)
|
|
|
|
list1->processVarDecls(exec);
|
|
|
|
if (def)
|
|
|
|
def->processVarDecls(exec);
|
|
|
|
if (list2)
|
|
|
|
list2->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- SwitchNode -----------------------------------
|
|
|
|
|
|
|
|
void SwitchNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
if ( block )
|
|
|
|
block->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SwitchNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
if ( block && block->deref() )
|
|
|
|
delete block;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.11
|
|
|
|
Completion SwitchNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Value v = expr->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
exec->context().imp()->seenLabels()->pushSwitch();
|
|
|
|
Completion res = block->evalBlock(exec,v);
|
|
|
|
exec->context().imp()->seenLabels()->popSwitch();
|
|
|
|
|
|
|
|
if ((res.complType() == Break) && ls.contains(res.target()))
|
|
|
|
return Completion(Normal, res.value());
|
|
|
|
else
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SwitchNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
block->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- LabelNode ------------------------------------
|
|
|
|
|
|
|
|
void LabelNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( statement )
|
|
|
|
statement->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LabelNode::deref()
|
|
|
|
{
|
|
|
|
if ( statement && statement->deref() )
|
|
|
|
delete statement;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.12
|
|
|
|
Completion LabelNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
Completion e;
|
|
|
|
|
|
|
|
if (!exec->context().imp()->seenLabels()->push(label)) {
|
|
|
|
return Completion( Throw,
|
|
|
|
throwError(exec, SyntaxError, "Duplicated label %s found.", label));
|
|
|
|
};
|
|
|
|
e = statement->execute(exec);
|
|
|
|
exec->context().imp()->seenLabels()->pop();
|
|
|
|
|
|
|
|
if ((e.complType() == Break) && (e.target() == label))
|
|
|
|
return Completion(Normal, e.value());
|
|
|
|
else
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
void LabelNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
statement->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ThrowNode ------------------------------------
|
|
|
|
|
|
|
|
void ThrowNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( expr )
|
|
|
|
expr->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ThrowNode::deref()
|
|
|
|
{
|
|
|
|
if ( expr && expr->deref() )
|
|
|
|
delete expr;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.13
|
|
|
|
Completion ThrowNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Value v = expr->evaluate(exec);
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
// bail out on error
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
Debugger *dbg = exec->interpreter()->imp()->debugger();
|
|
|
|
if (dbg)
|
|
|
|
dbg->exception(exec,v,exec->context().imp()->inTryCatch());
|
|
|
|
|
|
|
|
return Completion(Throw, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- CatchNode ------------------------------------
|
|
|
|
|
|
|
|
void CatchNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( block )
|
|
|
|
block->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CatchNode::deref()
|
|
|
|
{
|
|
|
|
if ( block && block->deref() )
|
|
|
|
delete block;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
Completion CatchNode::execute(ExecState * /*exec*/)
|
|
|
|
{
|
|
|
|
// should never be reached. execute(exec, arg) is used instead
|
|
|
|
assert(0L);
|
|
|
|
return Completion();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.14
|
|
|
|
Completion CatchNode::execute(ExecState *exec, const Value &arg)
|
|
|
|
{
|
|
|
|
/* TODO: correct ? Not part of the spec */
|
|
|
|
|
|
|
|
exec->clearException();
|
|
|
|
|
|
|
|
Object obj(new ObjectImp());
|
|
|
|
obj.put(exec, ident, arg, DontDelete);
|
|
|
|
exec->context().imp()->pushScope(obj);
|
|
|
|
Completion c = block->execute(exec);
|
|
|
|
exec->context().imp()->popScope();
|
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CatchNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
block->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- FinallyNode ----------------------------------
|
|
|
|
|
|
|
|
void FinallyNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( block )
|
|
|
|
block->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FinallyNode::deref()
|
|
|
|
{
|
|
|
|
if ( block && block->deref() )
|
|
|
|
delete block;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.14
|
|
|
|
Completion FinallyNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
return block->execute(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
void FinallyNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
block->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- TryNode --------------------------------------
|
|
|
|
|
|
|
|
void TryNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( block )
|
|
|
|
block->ref();
|
|
|
|
if ( _final )
|
|
|
|
_final->ref();
|
|
|
|
if ( _catch )
|
|
|
|
_catch->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TryNode::deref()
|
|
|
|
{
|
|
|
|
if ( block && block->deref() )
|
|
|
|
delete block;
|
|
|
|
if ( _final && _final->deref() )
|
|
|
|
delete _final;
|
|
|
|
if ( _catch && _catch->deref() )
|
|
|
|
delete _catch;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 12.14
|
|
|
|
Completion TryNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_BREAKPOINT;
|
|
|
|
|
|
|
|
Completion c, c2;
|
|
|
|
|
|
|
|
if (_catch)
|
|
|
|
exec->context().imp()->pushTryCatch();
|
|
|
|
c = block->execute(exec);
|
|
|
|
if (_catch)
|
|
|
|
exec->context().imp()->popTryCatch();
|
|
|
|
|
|
|
|
if (!_final) {
|
|
|
|
if (c.complType() != Throw)
|
|
|
|
return c;
|
|
|
|
return _catch->execute(exec,c.value());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!_catch) {
|
|
|
|
Value exception = exec->_exception;
|
|
|
|
exec->_exception = Value();
|
|
|
|
|
|
|
|
c2 = _final->execute(exec);
|
|
|
|
|
|
|
|
if (!exec->hadException() && c2.complType() != Throw)
|
|
|
|
exec->_exception = exception;
|
|
|
|
|
|
|
|
return (c2.complType() == Normal) ? c : c2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c.complType() == Throw)
|
|
|
|
c = _catch->execute(exec,c.value());
|
|
|
|
|
|
|
|
c2 = _final->execute(exec);
|
|
|
|
return (c2.complType() == Normal) ? c : c2;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TryNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
block->processVarDecls(exec);
|
|
|
|
if (_final)
|
|
|
|
_final->processVarDecls(exec);
|
|
|
|
if (_catch)
|
|
|
|
_catch->processVarDecls(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- ParameterNode --------------------------------
|
|
|
|
|
|
|
|
void ParameterNode::ref()
|
|
|
|
{
|
|
|
|
for (ParameterNode *n = this; n; n = n->next)
|
|
|
|
n->Node::ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ParameterNode::deref()
|
|
|
|
{
|
|
|
|
ParameterNode *next;
|
|
|
|
for (ParameterNode *n = this; n; n = next) {
|
|
|
|
next = n->next;
|
|
|
|
if (n != this && n->Node::deref())
|
|
|
|
delete n;
|
|
|
|
}
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 13
|
|
|
|
Value ParameterNode::evaluate(ExecState * /*exec*/) const
|
|
|
|
{
|
|
|
|
return Undefined();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- FunctionBodyNode -----------------------------
|
|
|
|
|
|
|
|
|
|
|
|
FunctionBodyNode::FunctionBodyNode(SourceElementsNode *s)
|
|
|
|
: BlockNode(s)
|
|
|
|
{
|
|
|
|
//fprintf(stderr,"FunctionBodyNode::FunctionBodyNode %p\n",this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void FunctionBodyNode::processFuncDecl(ExecState *exec)
|
|
|
|
{
|
|
|
|
if (source)
|
|
|
|
source->processFuncDecl(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- FuncDeclNode ---------------------------------
|
|
|
|
|
|
|
|
void FuncDeclNode::ref()
|
|
|
|
{
|
|
|
|
StatementNode::ref();
|
|
|
|
if ( param )
|
|
|
|
param->ref();
|
|
|
|
if ( body )
|
|
|
|
body->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FuncDeclNode::deref()
|
|
|
|
{
|
|
|
|
if ( param && param->deref() )
|
|
|
|
delete param;
|
|
|
|
if ( body && body->deref() )
|
|
|
|
delete body;
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 13
|
|
|
|
void FuncDeclNode::processFuncDecl(ExecState *exec)
|
|
|
|
{
|
|
|
|
ContextImp *ctx = exec->context().imp();
|
|
|
|
// TODO: let this be an object with [[Class]] property "Function"
|
|
|
|
FunctionImp *fimp = new DeclaredFunctionImp(exec, ident, body, exec->context().imp()->scopeChain());
|
|
|
|
Object func(fimp); // protect from GC
|
|
|
|
|
|
|
|
// Value proto = exec->lexicalInterpreter()->builtinObject().construct(exec,List::empty());
|
|
|
|
List empty;
|
|
|
|
Object proto = exec->lexicalInterpreter()->builtinObject().construct(exec,empty);
|
|
|
|
proto.put(exec, constructorPropertyName, func, ReadOnly|DontDelete|DontEnum);
|
|
|
|
func.put(exec, prototypePropertyName, proto, Internal|DontDelete);
|
|
|
|
|
|
|
|
int plen = 0;
|
|
|
|
for(const ParameterNode *p = param; p != 0L; p = p->nextParam(), plen++)
|
|
|
|
fimp->addParameter(p->ident());
|
|
|
|
|
|
|
|
func.put(exec, lengthPropertyName, Number(plen), ReadOnly|DontDelete|DontEnum);
|
|
|
|
|
|
|
|
#ifdef KJS_VERBOSE
|
|
|
|
fprintf(stderr,"KJS: new function %s in %p\n", ident.ustring().cstring().c_str(), ctx->variableObject().imp());
|
|
|
|
#endif
|
|
|
|
if (exec->_context->codeType() == EvalCode) {
|
|
|
|
// ECMA 10.2.2
|
|
|
|
ctx->variableObject().put(exec, ident, func, Internal);
|
|
|
|
} else {
|
|
|
|
ctx->variableObject().put(exec, ident, func, DontDelete | Internal);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (body) {
|
|
|
|
// hack the scope so that the function gets put as a property of func, and it's scope
|
|
|
|
// contains the func as well as our current scope
|
|
|
|
Object oldVar = ctx->variableObject();
|
|
|
|
ctx->setVariableObject(func);
|
|
|
|
ctx->pushScope(func);
|
|
|
|
body->processFuncDecl(exec);
|
|
|
|
ctx->popScope();
|
|
|
|
ctx->setVariableObject(oldVar);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- FuncExprNode ---------------------------------
|
|
|
|
|
|
|
|
void FuncExprNode::ref()
|
|
|
|
{
|
|
|
|
Node::ref();
|
|
|
|
if ( param )
|
|
|
|
param->ref();
|
|
|
|
if ( body )
|
|
|
|
body->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FuncExprNode::deref()
|
|
|
|
{
|
|
|
|
if ( param && param->deref() )
|
|
|
|
delete param;
|
|
|
|
if ( body && body->deref() )
|
|
|
|
delete body;
|
|
|
|
return Node::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ECMA 13
|
|
|
|
Value FuncExprNode::evaluate(ExecState *exec) const
|
|
|
|
{
|
|
|
|
ContextImp *context = exec->context().imp();
|
|
|
|
bool named = !ident.isNull();
|
|
|
|
Object functionScopeObject;
|
|
|
|
|
|
|
|
if (named) {
|
|
|
|
// named FunctionExpressions can recursively call themselves,
|
|
|
|
// but they won't register with the current scope chain and should
|
|
|
|
// be contained as single property in an anonymous object.
|
|
|
|
functionScopeObject = Object(new ObjectImp());
|
|
|
|
context->pushScope(functionScopeObject);
|
|
|
|
}
|
|
|
|
|
|
|
|
FunctionImp *fimp = new DeclaredFunctionImp(exec, Identifier::null(), body, exec->context().imp()->scopeChain());
|
|
|
|
Value ret(fimp);
|
|
|
|
List empty;
|
|
|
|
Value proto = exec->lexicalInterpreter()->builtinObject().construct(exec,empty);
|
|
|
|
fimp->put(exec, prototypePropertyName, proto, Internal|DontDelete);
|
|
|
|
|
|
|
|
for(const ParameterNode *p = param; p != 0L; p = p->nextParam())
|
|
|
|
fimp->addParameter(p->ident());
|
|
|
|
|
|
|
|
if (named) {
|
|
|
|
functionScopeObject.put(exec, ident, Value(fimp), ReadOnly|DontDelete);
|
|
|
|
context->popScope();
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------- SourceElementsNode ---------------------------
|
|
|
|
|
|
|
|
SourceElementsNode::SourceElementsNode(StatementNode *s1)
|
|
|
|
{
|
|
|
|
element = s1;
|
|
|
|
elements = this;
|
|
|
|
setLoc(s1->firstLine(), s1->lastLine(), s1->code());
|
|
|
|
}
|
|
|
|
|
|
|
|
SourceElementsNode::SourceElementsNode(SourceElementsNode *s1, StatementNode *s2)
|
|
|
|
{
|
|
|
|
elements = s1->elements;
|
|
|
|
s1->elements = this;
|
|
|
|
element = s2;
|
|
|
|
setLoc(s1->firstLine(), s2->lastLine(), s1->code());
|
|
|
|
}
|
|
|
|
|
|
|
|
void SourceElementsNode::ref()
|
|
|
|
{
|
|
|
|
for (SourceElementsNode *n = this; n; n = n->elements) {
|
|
|
|
n->Node::ref();
|
|
|
|
if (n->element)
|
|
|
|
n->element->ref();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SourceElementsNode::deref()
|
|
|
|
{
|
|
|
|
SourceElementsNode *next;
|
|
|
|
for (SourceElementsNode *n = this; n; n = next) {
|
|
|
|
next = n->elements;
|
|
|
|
if (n->element && n->element->deref())
|
|
|
|
delete n->element;
|
|
|
|
if (n != this && n->Node::deref())
|
|
|
|
delete n;
|
|
|
|
}
|
|
|
|
return StatementNode::deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 14
|
|
|
|
Completion SourceElementsNode::execute(ExecState *exec)
|
|
|
|
{
|
|
|
|
KJS_CHECKEXCEPTION
|
|
|
|
|
|
|
|
Completion c1 = element->execute(exec);
|
|
|
|
KJS_CHECKEXCEPTION;
|
|
|
|
if (c1.complType() != Normal)
|
|
|
|
return c1;
|
|
|
|
|
|
|
|
for (SourceElementsNode *n = elements; n; n = n->elements) {
|
|
|
|
Completion c2 = n->element->execute(exec);
|
|
|
|
if (c2.complType() != Normal)
|
|
|
|
return c2;
|
|
|
|
// The spec says to return c2 here, but it seems that mozilla returns c1 if
|
|
|
|
// c2 doesn't have a value
|
|
|
|
if (c2.value().isValid())
|
|
|
|
c1 = c2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return c1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ECMA 14
|
|
|
|
void SourceElementsNode::processFuncDecl(ExecState *exec)
|
|
|
|
{
|
|
|
|
for (SourceElementsNode *n = this; n; n = n->elements)
|
|
|
|
n->element->processFuncDecl(exec);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SourceElementsNode::processVarDecls(ExecState *exec)
|
|
|
|
{
|
|
|
|
for (SourceElementsNode *n = this; n; n = n->elements)
|
|
|
|
n->element->processVarDecls(exec);
|
|
|
|
}
|