Changeset 14799 in webkit for trunk/JavaScriptCore/kjs/context.h

Timestamp:

Jun 9, 2006, 8:57:13 PM (19 years ago)

Author:

ggaren

Message:

Reviewed by Eric (yay!).

• Removed Context wrapper for ContextImp, renamed ContextImp to Context, split Context into its own file -- Context.cpp -- renamed _var to m_var, change ' *' to '* '.

• JavaScriptCore.xcodeproj/project.pbxproj:
• kjs/Context.cpp: Added. (KJS::Context::Context): (KJS::Context::~Context): (KJS::Context::mark):
• kjs/context.h: (KJS::Context::scopeChain): (KJS::Context::variableObject): (KJS::Context::setVariableObject): (KJS::Context::thisValue): (KJS::Context::callingContext): (KJS::Context::activationObject): (KJS::Context::currentBody): (KJS::Context::function): (KJS::Context::arguments): (KJS::Context::pushScope): (KJS::Context::seenLabels):
• kjs/function.cpp: (KJS::FunctionImp::callAsFunction): (KJS::FunctionImp::processParameters): (KJS::FunctionImp::argumentsGetter): (KJS::GlobalFuncImp::callAsFunction):
• kjs/internal.cpp: (KJS::InterpreterImp::evaluate):
• kjs/internal.h: (KJS::InterpreterImp::setContext): (KJS::InterpreterImp::context):
• kjs/interpreter.cpp:
• kjs/interpreter.h: (KJS::ExecState::context): (KJS::ExecState::ExecState):
• kjs/nodes.cpp: (currentSourceId): (currentSourceURL): (ThisNode::evaluate): (ResolveNode::evaluate): (FunctionCallResolveNode::evaluate): (PostfixResolveNode::evaluate): (DeleteResolveNode::evaluate): (TypeOfResolveNode::evaluate): (PrefixResolveNode::evaluate): (AssignResolveNode::evaluate): (VarDeclNode::evaluate): (VarDeclNode::processVarDecls): (DoWhileNode::execute): (WhileNode::execute): (ForNode::execute): (ForInNode::execute): (ContinueNode::execute): (BreakNode::execute): (ReturnNode::execute): (WithNode::execute): (SwitchNode::execute): (LabelNode::execute): (TryNode::execute): (FuncDeclNode::processFuncDecl): (FuncExprNode::evaluate):

File:

• trunk/JavaScriptCore/kjs/context.h (modified) (4 diffs)

trunk/JavaScriptCore/kjs/context.h

@@ -4 +4 @@
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
  *  Copyright (C) 2001 Peter Kelly ([email protected])
- *  Copyright (C) 2003 Apple Computer, Inc.
+ *  Copyright (C) 2003, 2006 Apple Computer, Inc.
  *
  *  This library is free software; you can redistribute it and/or
@@ -23 +23 @@
  */
 
-#ifndef KJS_CONTEXT_H
-#define KJS_CONTEXT_H
+#ifndef KJS_Context_h
+#define KJS_Context_h
 
 #include "function.h"
@@ -30 +30 @@
 namespace KJS  {
 
-  /**
+  /** 
    * @short Execution context.
-   */
-  class ContextImp {
+   *
+   * Represents an execution context, as specified by section 10 of the ECMA
+   * spec.
+   *
+   * An execution context contains information about the current state of the
+   * script - the scope for variable lookup, the value of "this", etc. A new
+   * execution context is entered whenever global code is executed (e.g. with
+   * Interpreter::evaluate()), a function is called (see
+   * Object::call()), or the builtin "eval" function is executed.
+   *
+   * Most inheritable functions in the KJS api take a ExecState pointer as
+   * their first parameter. This can be used to obtain a handle to the current
+   * execution context.
+   */    
+  class Context {
   public:
-    ContextImp(JSObject* global, InterpreterImp*, JSObject* thisV, FunctionBodyNode* currentBody,
-               CodeType type = GlobalCode, ContextImp* callingContext = 0, FunctionImp* function = 0, const List* args = 0);
-    ~ContextImp();
+    Context(JSObject* global, InterpreterImp*, JSObject* thisV, 
+            FunctionBodyNode* currentBody, CodeType type = GlobalCode, 
+            Context* callingContext = 0, FunctionImp* function = 0, const List* args = 0);
+    ~Context();
 
+    /**
+     * Returns the scope chain for this execution context. This is used for
+     * variable lookup, with the list being searched from start to end until a
+     * variable is found.
+     *
+     * @return The execution context's scope chain
+     */
+    const ScopeChain& scopeChain() const { return scope; }
+
+    /**
+     * Returns the variable object for the execution context. This contains a
+     * property for each variable declared in the execution context.
+     *
+     * @return The execution context's variable object
+     */
+    JSObject* variableObject() const { return m_variable; }
+    void setVariableObject(JSObject* v) { m_variable = v; }
+
+    /**
+     * Returns the "this" value for the execution context. This is the value
+     * returned when a script references the special variable "this". It should
+     * always be an Object, unless application-specific code has passed in a
+     * different type.
+     *
+     * The object that is used as the "this" value depends on the type of
+     * execution context - for global contexts, the global object is used. For
+     * function objewcts, the value is given by the caller (e.g. in the case of
+     * obj.func(), obj would be the "this" value). For code executed by the
+     * built-in "eval" function, the this value is the same as the calling
+     * context.
+     *
+     * @return The execution context's "this" value
+     */
+    JSObject* thisValue() const { return m_thisVal; }
+
+    /**
+     * Returns the context from which the current context was invoked. For
+     * global code this will be a null context (i.e. one for which
+     * isNull() returns true). You should check isNull() on the returned
+     * value before calling any of it's methods.
+     *
+     * @return The calling execution context
+     */
+    Context* callingContext() { return m_callingContext; }
+    
+    JSObject* activationObject() { return m_activation; }
+    CodeType codeType() { return m_codeType; }
     FunctionBodyNode* currentBody() { return m_currentBody; }
+    FunctionImp* function() const { return m_function; }
+    const List* arguments() const { return m_arguments; }
 
-    const ScopeChain &scopeChain() const { return scope; }
-    CodeType codeType() { return m_codeType; }
-    JSObject *variableObject() const { return variable; }
-    void setVariableObject(JSObject *v) { variable = v; }
-    JSObject *thisValue() const { return thisVal; }
-    ContextImp *callingContext() { return _callingContext; }
-    JSObject *activationObject() { return activation; }
-    FunctionImp *function() const { return _function; }
-    const List *arguments() const { return _arguments; }
-
-    void pushScope(JSObject *s) { scope.push(s); }
+    void pushScope(JSObject* s) { scope.push(s); }
     void popScope() { scope.pop(); }
-    LabelStack *seenLabels() { return &ls; }
-
+    LabelStack* seenLabels() { return &ls; }
 
     void pushIteration() { m_iterationDepth++; }
@@ -67 +119 @@
 
   private:
-    InterpreterImp *_interpreter;
-    ContextImp *_callingContext;
+    // Contexts are always stack-allocated, and the garbage collector
+    // marks the stack, so we don't need to protect the objects below from GC.
+
+    InterpreterImp* m_interpreter;
+    Context* m_callingContext;
     FunctionBodyNode* m_currentBody;
 
-    FunctionImp *_function;
-    const List *_arguments;
-    // because ContextImp is always allocated on the stack,
-    // there is no need to protect various pointers from conservative
-    // GC since they will be caught by the conservative sweep anyway!
-    JSObject *activation;
+    FunctionImp* m_function;
+    const List* m_arguments;
+    JSObject* m_activation;
     
     ScopeChain scope;
-    JSObject *variable;
-    JSObject *thisVal;
+    JSObject* m_variable;
+    JSObject* m_thisVal;
 
     LabelStack ls;