2000-04-05 10:05:57 +04:00
|
|
|
// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
//
|
|
|
|
// The contents of this file are subject to the Netscape Public
|
|
|
|
// License Version 1.1 (the "License"); you may not use this file
|
|
|
|
// except in compliance with the License. You may obtain a copy of
|
|
|
|
// the License at http://www.mozilla.org/NPL/
|
|
|
|
//
|
|
|
|
// Software distributed under the License is distributed on an "AS
|
|
|
|
// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
|
|
|
|
// implied. See the License for the specific language governing
|
|
|
|
// rights and limitations under the License.
|
|
|
|
//
|
|
|
|
// The Original Code is the JavaScript 2 Prototype.
|
|
|
|
//
|
|
|
|
// The Initial Developer of the Original Code is Netscape
|
|
|
|
// Communications Corporation. Portions created by Netscape are
|
2000-04-11 07:07:39 +04:00
|
|
|
// Copyright (C) 2000 Netscape Communications Corporation. All
|
2000-04-05 10:05:57 +04:00
|
|
|
// Rights Reserved.
|
|
|
|
|
|
|
|
#ifndef interpreter_h
|
|
|
|
#define interpreter_h
|
|
|
|
|
2000-04-18 04:17:34 +04:00
|
|
|
#include "utilities.h"
|
|
|
|
#include "jstypes.h"
|
2000-04-29 04:23:06 +04:00
|
|
|
#include "vmtypes.h"
|
2000-04-05 10:05:57 +04:00
|
|
|
#include "icodegenerator.h"
|
2000-04-21 04:04:14 +04:00
|
|
|
#include "gc_allocator.h"
|
2000-04-05 10:05:57 +04:00
|
|
|
|
2000-04-26 09:29:35 +04:00
|
|
|
namespace JavaScript {
|
|
|
|
namespace Interpreter {
|
|
|
|
|
2000-04-19 01:51:45 +04:00
|
|
|
using namespace ICG;
|
|
|
|
using namespace JSTypes;
|
2000-04-21 04:04:14 +04:00
|
|
|
|
2000-04-29 04:23:06 +04:00
|
|
|
struct Activation;
|
|
|
|
|
2000-04-26 09:29:35 +04:00
|
|
|
struct Linkage;
|
2000-07-13 04:14:54 +04:00
|
|
|
|
2000-04-21 04:04:14 +04:00
|
|
|
class Context : public gc_base {
|
2000-06-16 05:36:59 +04:00
|
|
|
void initContext();
|
2000-04-21 04:04:14 +04:00
|
|
|
public:
|
2000-04-29 18:14:28 +04:00
|
|
|
explicit Context(World& world, JSScope* aGlobal)
|
2001-01-11 03:03:05 +03:00
|
|
|
: mWorld(world), mGlobal(aGlobal), mLinkage(0), mActivation(0), mCurrentClosure(0) { initContext(); }
|
2000-04-21 04:04:14 +04:00
|
|
|
|
2000-04-29 18:44:42 +04:00
|
|
|
World& getWorld() { return mWorld; }
|
|
|
|
JSScope* getGlobalObject() { return mGlobal; }
|
|
|
|
InstructionIterator getPC() { return mPC; }
|
2000-04-29 04:23:06 +04:00
|
|
|
|
2000-04-29 18:44:42 +04:00
|
|
|
JSValues& getRegisters();
|
|
|
|
ICodeModule* getICode();
|
2000-04-29 04:23:06 +04:00
|
|
|
|
2000-05-12 05:17:32 +04:00
|
|
|
enum Event {
|
|
|
|
EV_NONE = 0x0000,
|
|
|
|
EV_STEP = 0x0001,
|
|
|
|
EV_THROW = 0x0002,
|
2000-06-24 02:27:17 +04:00
|
|
|
EV_DEBUG = 0x0004,
|
2000-05-12 05:17:32 +04:00
|
|
|
EV_ALL = 0xffff
|
|
|
|
};
|
|
|
|
|
2000-04-26 09:29:35 +04:00
|
|
|
class Listener {
|
|
|
|
public:
|
2000-05-12 05:17:32 +04:00
|
|
|
virtual void listen(Context *context, Event event) = 0;
|
2000-04-26 09:29:35 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
void addListener(Listener* listener);
|
|
|
|
void removeListener(Listener* listener);
|
|
|
|
|
|
|
|
class Frame {
|
|
|
|
public:
|
|
|
|
virtual Frame* getNext() = 0;
|
2000-04-29 04:23:06 +04:00
|
|
|
virtual void getState(InstructionIterator& pc, JSValues*& registers,
|
|
|
|
ICodeModule*& iCode) = 0;
|
2000-04-26 09:29:35 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
Frame* getFrames();
|
|
|
|
|
2000-04-26 05:42:00 +04:00
|
|
|
JSValue interpret(ICodeModule* iCode, const JSValues& args);
|
2000-05-19 21:41:10 +04:00
|
|
|
void doCall(JSFunction *target, Instruction *pc);
|
2000-04-21 04:04:14 +04:00
|
|
|
|
2000-08-05 00:28:35 +04:00
|
|
|
ICodeModule* compileFunction(const String &source);
|
2000-07-12 03:49:20 +04:00
|
|
|
ICodeModule* genCode(StmtNode *p, const String &fileName);
|
|
|
|
JSValue readEvalFile(FILE* in, const String& fileName);
|
|
|
|
|
2000-10-19 03:37:44 +04:00
|
|
|
void loadClass(const char *fileName);
|
|
|
|
|
2001-01-11 03:03:05 +03:00
|
|
|
const JSValue findBinaryOverride(JSValue &operand1, JSValue &operand2, ExprNode::Kind op);
|
2000-07-13 04:14:54 +04:00
|
|
|
|
2000-04-26 09:29:35 +04:00
|
|
|
private:
|
2000-05-12 05:17:32 +04:00
|
|
|
void broadcast(Event event);
|
2000-07-13 04:14:54 +04:00
|
|
|
void initOperatorsPackage();
|
2000-09-02 05:01:04 +04:00
|
|
|
bool hasNamedArguments(ArgumentList &args);
|
2000-04-26 09:29:35 +04:00
|
|
|
|
2000-04-21 04:04:14 +04:00
|
|
|
private:
|
2000-04-26 05:42:00 +04:00
|
|
|
World& mWorld;
|
2000-04-29 18:14:28 +04:00
|
|
|
JSScope* mGlobal;
|
2000-04-26 09:29:35 +04:00
|
|
|
Linkage* mLinkage;
|
2000-05-12 05:17:32 +04:00
|
|
|
typedef std::vector<Listener*, gc_allocator<Listener*> > ListenerList;
|
|
|
|
typedef ListenerList::iterator ListenerIterator;
|
|
|
|
ListenerList mListeners;
|
2000-04-29 04:23:06 +04:00
|
|
|
Activation* mActivation;
|
2000-12-09 02:55:39 +03:00
|
|
|
ICodeModule* mICode;
|
2000-12-30 04:08:31 +03:00
|
|
|
JSClosure* mCurrentClosure;
|
2000-07-13 04:14:54 +04:00
|
|
|
|
2000-04-29 18:44:42 +04:00
|
|
|
InstructionIterator mPC;
|
2000-07-13 04:14:54 +04:00
|
|
|
|
2000-04-26 09:29:35 +04:00
|
|
|
}; /* class Context */
|
|
|
|
|
2000-12-09 02:55:39 +03:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct Handler: public gc_base {
|
|
|
|
Handler(Label *catchLabel, Label *finallyLabel)
|
|
|
|
: catchTarget(catchLabel), finallyTarget(finallyLabel) {}
|
|
|
|
Label *catchTarget;
|
|
|
|
Label *finallyTarget;
|
|
|
|
};
|
|
|
|
typedef std::vector<Handler *> CatchStack;
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Represents the current function's invocation state.
|
|
|
|
*/
|
|
|
|
struct Activation : public JSObject {
|
|
|
|
JSValues mRegisters;
|
|
|
|
CatchStack catchStack;
|
|
|
|
|
|
|
|
Activation(uint32 highRegister, const JSValues& args)
|
|
|
|
: mRegisters(highRegister + 1)
|
|
|
|
{
|
|
|
|
// copy arg list to initial registers.
|
|
|
|
JSValues::iterator dest = mRegisters.begin();
|
|
|
|
for (JSValues::const_iterator src = args.begin(),
|
|
|
|
end = args.end(); src != end; ++src, ++dest) {
|
|
|
|
*dest = *src;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Activation(uint32 highRegister, Activation* caller, const JSValue thisArg,
|
|
|
|
const ArgumentList* list)
|
|
|
|
: mRegisters(highRegister + 1)
|
|
|
|
{
|
|
|
|
// copy caller's parameter list to initial registers.
|
|
|
|
JSValues::iterator dest = mRegisters.begin();
|
|
|
|
*dest++ = thisArg;
|
|
|
|
const JSValues& params = caller->mRegisters;
|
|
|
|
for (ArgumentList::const_iterator src = list->begin(),
|
|
|
|
end = list->end(); src != end; ++src, ++dest) {
|
|
|
|
Register r = (*src).first.first;
|
|
|
|
if (r != NotARegister)
|
|
|
|
*dest = params[r];
|
|
|
|
else
|
|
|
|
*dest = JSValue(JSValue::uninitialized_tag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// calling a binary operator, no 'this'
|
|
|
|
Activation(uint32 highRegister, const JSValue thisArg, const JSValue arg1, const JSValue arg2)
|
|
|
|
: mRegisters(highRegister + 1)
|
|
|
|
{
|
|
|
|
mRegisters[0] = thisArg;
|
|
|
|
mRegisters[1] = arg1;
|
|
|
|
mRegisters[2] = arg2;
|
|
|
|
}
|
|
|
|
|
|
|
|
// calling a getter function, no arguments
|
|
|
|
Activation(uint32 highRegister, const JSValue thisArg)
|
|
|
|
: mRegisters(highRegister + 1)
|
|
|
|
{
|
|
|
|
mRegisters[0] = thisArg;
|
|
|
|
}
|
|
|
|
|
|
|
|
// calling a setter function, 1 argument
|
|
|
|
Activation(uint32 highRegister, const JSValue thisArg, const JSValue arg)
|
|
|
|
: mRegisters(highRegister + 1)
|
|
|
|
{
|
|
|
|
mRegisters[0] = thisArg;
|
|
|
|
mRegisters[1] = arg;
|
|
|
|
}
|
|
|
|
|
|
|
|
}; /* struct Activation */
|
|
|
|
|
2000-04-26 09:29:35 +04:00
|
|
|
} /* namespace Interpreter */
|
2000-04-19 01:51:45 +04:00
|
|
|
} /* namespace JavaScript */
|
2000-04-05 10:05:57 +04:00
|
|
|
|
|
|
|
#endif /* interpreter_h */
|