internal.h
// -*- c-basic-offset: 2 -*-
/*
* This file is part of the KDE libraries
* Copyright (C) 1999-2001 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.
*
*/
#ifndef _INTERNAL_H_
#define _INTERNAL_H_
#include "ustring.h"
#include "value.h"
#include "object.h"
#include "function.h"
#include "types.h"
#include "interpreter.h"
#include "scope_chain.h"
#include "array_instance.h"
#ifndef I18N_NOOP
#define I18N_NOOP(s) s
#endif
namespace KJS {
static const double D16 = 65536.0;
static const double D32 = 4294967296.0;
class FunctionBodyNode;
class FunctionBodyNode;
class FunctionPrototypeImp;
class FunctionImp;
class Parameter;
class Debugger;
// ---------------------------------------------------------------------------
// Primitive impls
// ---------------------------------------------------------------------------
class UndefinedImp : public ValueImp {
public:
Type type() const { return UndefinedType; }
Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
bool toBoolean(ExecState *exec) const;
double toNumber(ExecState *exec) const;
UString toString(ExecState *exec) const;
Object toObject(ExecState *exec) const;
static UndefinedImp *staticUndefined;
};
inline Undefined::Undefined(UndefinedImp *imp) : Value(imp) { }
class NullImp : public ValueImp {
public:
Type type() const { return NullType; }
Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
bool toBoolean(ExecState *exec) const;
double toNumber(ExecState *exec) const;
UString toString(ExecState *exec) const;
Object toObject(ExecState *exec) const;
static NullImp *staticNull;
};
inline Null::Null(NullImp *imp) : Value(imp) { }
class BooleanImp : public ValueImp {
public:
BooleanImp(bool v = false) : val(v) { }
bool value() const { return val; }
Type type() const { return BooleanType; }
Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
bool toBoolean(ExecState *exec) const;
double toNumber(ExecState *exec) const;
UString toString(ExecState *exec) const;
Object toObject(ExecState *exec) const;
static BooleanImp *staticTrue;
static BooleanImp *staticFalse;
private:
bool val;
};
inline Boolean::Boolean(BooleanImp *imp) : Value(imp) { }
class StringImp : public ValueImp {
public:
StringImp(const UString& v) : val(v) { }
UString value() const { return val; }
Type type() const { return StringType; }
Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
bool toBoolean(ExecState *exec) const;
double toNumber(ExecState *exec) const;
UString toString(ExecState *exec) const;
Object toObject(ExecState *exec) const;
private:
UString val;
};
inline String::String(StringImp *imp) : Value(imp) { }
class NumberImp : public ValueImp {
friend class Number;
friend class InterpreterImp;
public:
static ValueImp *create(int);
static ValueImp *create(double);
static ValueImp *zero() { return SimpleNumber::make(0); }
static ValueImp *one() { return SimpleNumber::make(1); }
static ValueImp *two() { return SimpleNumber::make(2); }
double value() const { return val; }
Type type() const { return NumberType; }
Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
bool toBoolean(ExecState *exec) const;
double toNumber(ExecState *exec) const;
UString toString(ExecState *exec) const;
Object toObject(ExecState *exec) const;
static NumberImp *staticNaN;
private:
NumberImp(double v) : val(v) { }
virtual bool toUInt32(unsigned&) const;
double val;
};
inline Number::Number(NumberImp *imp) : Value(imp) { }
class LabelStack {
public:
LabelStack(): tos(0L), iterationDepth(0), switchDepth(0) {}
~LabelStack();
LabelStack(const LabelStack &other);
LabelStack &operator=(const LabelStack &other);
bool push(const Identifier &id);
bool contains(const Identifier &id) const;
void pop();
void pushIteration() { iterationDepth++; }
void popIteration() { iterationDepth--; }
bool inIteration() const { return (iterationDepth > 0); }
void pushSwitch() { switchDepth++; }
void popSwitch() { switchDepth--; }
bool inSwitch() const { return (switchDepth > 0); }
private:
struct StackElem {
Identifier id;
StackElem *prev;
};
StackElem *tos;
void clear();
int iterationDepth;
int switchDepth;
};
// ---------------------------------------------------------------------------
// Parsing & evaluateion
// ---------------------------------------------------------------------------
class SourceCode {
public:
SourceCode(int _sid)
: sid(_sid), interpreter(0), refcount(0), next(0) {}
void ref() { refcount++; }
void deref() { if (!--refcount) cleanup(); }
void cleanup();
int sid;
InterpreterImp *interpreter;
int refcount;
SourceCode *next;
};
class Parser {
public:
static FunctionBodyNode *parse(const UChar *code, unsigned int length, SourceCode **src,
int *errLine = 0, UString *errMsg = 0);
static FunctionBodyNode *progNode;
static SourceCode *source;
static int sid;
private:
};
class InterpreterImp {
friend class Collector;
public:
static void globalInit();
static void globalClear();
InterpreterImp(Interpreter *interp, const Object &glob);
~InterpreterImp();
Object &globalObject() const { return const_cast<Object &>(global); }
Interpreter* interpreter() const { return m_interpreter; }
void initGlobalObject();
static void lock();
static void unlock();
void mark();
ExecState *globalExec() { return globExec; }
bool checkSyntax(const UString &code,int *errLine, UString *errMsg);
bool checkSyntax(const UString &code);
Completion evaluate(const UString &code, const Value &thisV);
Debugger *debugger() const { return dbg; }
void setDebugger(Debugger *d);
Object builtinObject() const { return b_Object; }
Object builtinFunction() const { return b_Function; }
Object builtinArray() const { return b_Array; }
Object builtinBoolean() const { return b_Boolean; }
Object builtinString() const { return b_String; }
Object builtinNumber() const { return b_Number; }
Object builtinDate() const { return b_Date; }
Object builtinRegExp() const { return b_RegExp; }
Object builtinError() const { return b_Error; }
Object builtinObjectPrototype() const { return b_ObjectPrototype; }
Object builtinFunctionPrototype() const { return b_FunctionPrototype; }
Object builtinArrayPrototype() const { return b_ArrayPrototype; }
Object builtinBooleanPrototype() const { return b_BooleanPrototype; }
Object builtinStringPrototype() const { return b_StringPrototype; }
Object builtinNumberPrototype() const { return b_NumberPrototype; }
Object builtinDatePrototype() const { return b_DatePrototype; }
Object builtinRegExpPrototype() const { return b_RegExpPrototype; }
Object builtinErrorPrototype() const { return b_ErrorPrototype; }
Object builtinEvalError() const { return b_evalError; }
Object builtinRangeError() const { return b_rangeError; }
Object builtinReferenceError() const { return b_referenceError; }
Object builtinSyntaxError() const { return b_syntaxError; }
Object builtinTypeError() const { return b_typeError; }
Object builtinURIError() const { return b_uriError; }
Object builtinEvalErrorPrototype() const { return b_evalErrorPrototype; }
Object builtinRangeErrorPrototype() const { return b_rangeErrorPrototype; }
Object builtinReferenceErrorPrototype() const { return b_referenceErrorPrototype; }
Object builtinSyntaxErrorPrototype() const { return b_syntaxErrorPrototype; }
Object builtinTypeErrorPrototype() const { return b_typeErrorPrototype; }
Object builtinURIErrorPrototype() const { return b_uriErrorPrototype; }
void setCompatMode(Interpreter::CompatMode mode) { m_compatMode = mode; }
Interpreter::CompatMode compatMode() const { return m_compatMode; }
// Chained list of interpreters (ring)
static InterpreterImp* firstInterpreter() { return s_hook; }
InterpreterImp *nextInterpreter() const { return next; }
InterpreterImp *prevInterpreter() const { return prev; }
void addSourceCode(SourceCode *code);
void removeSourceCode(SourceCode *code);
void setContext(ContextImp *c) { _context = c; }
private:
void clear();
Interpreter *m_interpreter;
Object global;
Debugger *dbg;
// Built-in properties of the object prototype. These are accessible
// from here even if they are replaced by js code (e.g. assigning to
// Array.prototype)
Object b_Object;
Object b_Function;
Object b_Array;
Object b_Boolean;
Object b_String;
Object b_Number;
Object b_Date;
Object b_RegExp;
Object b_Error;
Object b_ObjectPrototype;
Object b_FunctionPrototype;
Object b_ArrayPrototype;
Object b_BooleanPrototype;
Object b_StringPrototype;
Object b_NumberPrototype;
Object b_DatePrototype;
Object b_RegExpPrototype;
Object b_ErrorPrototype;
Object b_evalError;
Object b_rangeError;
Object b_referenceError;
Object b_syntaxError;
Object b_typeError;
Object b_uriError;
Object b_evalErrorPrototype;
Object b_rangeErrorPrototype;
Object b_referenceErrorPrototype;
Object b_syntaxErrorPrototype;
Object b_typeErrorPrototype;
Object b_uriErrorPrototype;
ExecState *globExec;
Interpreter::CompatMode m_compatMode;
// Chained list of interpreters (ring) - for collector
static InterpreterImp* s_hook;
InterpreterImp *next, *prev;
ContextImp *_context;
int recursion;
SourceCode *sources;
};
class AttachedInterpreter;
class DebuggerImp {
public:
DebuggerImp() {
interps = 0;
isAborted = false;
}
void abort() { isAborted = true; }
bool aborted() const { return isAborted; }
AttachedInterpreter *interps;
bool isAborted;
};
class FunctionImp : public InternalFunctionImp {
friend class ActivationImp;
public:
FunctionImp(ExecState *exec, const Identifier &n = Identifier::null());
virtual ~FunctionImp();
virtual Value get(ExecState *exec, const Identifier &propertyName) const;
virtual void put(ExecState *exec, const Identifier &propertyName, const Value &value, int attr = None);
virtual bool hasProperty(ExecState *exec, const Identifier &propertyName) const;
virtual bool deleteProperty(ExecState *exec, const Identifier &propertyName);
virtual bool implementsCall() const;
virtual Value call(ExecState *exec, Object &thisObj, const List &args);
void addParameter(const Identifier &n);
Identifier parameterProperty(int index) const;
// parameters in string representation, e.g. (a, b, c)
UString parameterString() const;
virtual CodeType codeType() const = 0;
virtual Completion execute(ExecState *exec) = 0;
int firstLine() const { return line0; }
int lastLine() const { return line1; }
int sourceId() const { return sid; }
virtual const ClassInfo *classInfo() const { return &info; }
static const ClassInfo info;
protected:
Parameter *param;
int line0;
int line1;
int sid;
private:
void processParameters(ExecState *exec, const List &);
virtual void processVarDecls(ExecState *exec);
};
class DeclaredFunctionImp : public FunctionImp {
public:
DeclaredFunctionImp(ExecState *exec, const Identifier &n,
FunctionBodyNode *b, const ScopeChain &sc);
~DeclaredFunctionImp();
bool implementsConstruct() const;
Object construct(ExecState *exec, const List &args);
virtual Completion execute(ExecState *exec);
CodeType codeType() const { return FunctionCode; }
FunctionBodyNode *body;
virtual const ClassInfo *classInfo() const { return &info; }
KJS_EXPORT static const ClassInfo info;
private:
virtual void processVarDecls(ExecState *exec);
};
class ActivationImp;
class ArgumentsImp : public ObjectImp {
public:
ArgumentsImp(ExecState *exec, FunctionImp *func, const List &args, ActivationImp *act);
virtual void mark();
virtual Value get(ExecState *exec, const Identifier &propertyName) const;
virtual void put(ExecState *exec, const Identifier &propertyName,
const Value &value, int attr = None);
virtual const ClassInfo *classInfo() const { return &info; }
static const ClassInfo info;
private:
ActivationImp *activation;
};
class ActivationImp : public ObjectImp {
public:
ActivationImp(FunctionImp *function, const List &arguments);
virtual Value get(ExecState *exec, const Identifier &propertyName) const;
virtual bool hasProperty(ExecState *exec, const Identifier &propertyName) const;
virtual bool deleteProperty(ExecState *exec, const Identifier &propertyName);
virtual const ClassInfo *classInfo() const { return &info; }
static const ClassInfo info;
virtual void mark();
private:
FunctionImp *_function;
List _arguments;
mutable ArgumentsImp *_argumentsObject;
};
class GlobalFuncImp : public InternalFunctionImp {
public:
GlobalFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto,
int i, int len, const Identifier &_ident);
virtual bool implementsCall() const;
virtual Value call(ExecState *exec, Object &thisObj, const List &args);
virtual CodeType codeType() const;
enum { Eval, ParseInt, ParseFloat, IsNaN, IsFinite, DecodeURI, DecodeURIComponent,
EncodeURI, EncodeURIComponent, Escape, UnEscape, KJSPrint };
private:
int id;
};
// helper function for toInteger, toInt32, toUInt32 and toUInt16
double roundValue(ExecState *exec, const Value &v);
#ifndef NDEBUG
void printInfo(ExecState *exec, const char *s, const Value &o, int lineno = -1);
#endif
} // namespace
#endif // _INTERNAL_H_
KJS::Value
Value objects are act as wrappers ("smart pointers") around ValueImp objects and their descendents...
Definition: value.h:168
KStdAccel::next
const KShortcut & next()
KJS::InternalFunctionImp
Base class for all function objects.
Definition: function.h:41
KJS::ScopeChain
A scope chain object.
Definition: scope_chain.h:47
KJS::LabelStack::push
bool push(const Identifier &id)
If id is not empty and is not in the stack already, puts it on top of the stack and returns true...
Definition: internal.cpp:321
KJS::Object
Represents an Object.
Definition: object.h:82
KJS::FunctionImp
Implementation class for functions implemented in JS.
Definition: internal.h:390
KJS::UString
Unicode string class.
Definition: ustring.h:189
KJS::LabelStack::contains
bool contains(const Identifier &id) const
Is the id in the stack?
Definition: internal.cpp:333
KJS::LabelStack::pop
void pop()
Removes from the stack the last pushed id (what else?)
Definition: internal.cpp:345
KJS::Completion
Completion objects are used to convey the return status and value from functions. ...
Definition: completion.h:49
KJS::List
Native list type.
Definition: list.h:48
KJS::ClassInfo
Class Information.
Definition: object.h:59
KJS::LabelStack
The "label set" in Ecma-262 spec.
Definition: internal.h:162
KJS::Identifier::null
static const Identifier & null()
Creates an empty Identifier.
Definition: identifier.cpp:302
KJS::ExecState
Represents the current state of script execution.
Definition: interpreter.h:439
KJS::Identifier
Represents an Identifier for a Javascript object.
Definition: identifier.h:32

KDE Home | KDE Accessibility Home | Description of Access Keys