Web Inspector: Provide $exception in the console for the thrown exception value
[WebKit-https.git] / Source / JavaScriptCore / debugger / DebuggerScope.cpp
1 /*
2  * Copyright (C) 2008-2009, 2014 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "DebuggerScope.h"
28
29 #include "JSLexicalEnvironment.h"
30 #include "JSCInlines.h"
31 #include "JSNameScope.h"
32 #include "JSWithScope.h"
33
34 namespace JSC {
35
36 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(DebuggerScope);
37
38 const ClassInfo DebuggerScope::s_info = { "DebuggerScope", &Base::s_info, 0, CREATE_METHOD_TABLE(DebuggerScope) };
39
40 DebuggerScope::DebuggerScope(VM& vm, JSScope* scope)
41     : JSNonFinalObject(vm, scope->globalObject()->debuggerScopeStructure())
42 {
43     ASSERT(scope);
44     m_scope.set(vm, this, scope);
45 }
46
47 void DebuggerScope::finishCreation(VM& vm)
48 {
49     Base::finishCreation(vm);
50 }
51
52 void DebuggerScope::visitChildren(JSCell* cell, SlotVisitor& visitor)
53 {
54     DebuggerScope* thisObject = jsCast<DebuggerScope*>(cell);
55     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
56     JSObject::visitChildren(thisObject, visitor);
57     visitor.append(&thisObject->m_scope);
58     visitor.append(&thisObject->m_next);
59 }
60
61 String DebuggerScope::className(const JSObject* object)
62 {
63     const DebuggerScope* scope = jsCast<const DebuggerScope*>(object);
64     ASSERT(scope->isValid());
65     if (!scope->isValid())
66         return String();
67     JSObject* thisObject = JSScope::objectAtScope(scope->jsScope());
68     return thisObject->methodTable()->className(thisObject);
69 }
70
71 bool DebuggerScope::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
72 {
73     DebuggerScope* scope = jsCast<DebuggerScope*>(object);
74     ASSERT(scope->isValid());
75     if (!scope->isValid())
76         return false;
77     JSObject* thisObject = JSScope::objectAtScope(scope->jsScope());
78     slot.setThisValue(JSValue(thisObject));
79
80     // By default, JSObject::getPropertySlot() will look in the DebuggerScope's prototype
81     // chain and not the wrapped scope, and JSObject::getPropertySlot() cannot be overridden
82     // to behave differently for the DebuggerScope.
83     //
84     // Instead, we'll treat all properties in the wrapped scope and its prototype chain as
85     // the own properties of the DebuggerScope. This is fine because the WebInspector
86     // does not presently need to distinguish between what's owned at each level in the
87     // prototype chain. Hence, we'll invoke getPropertySlot() on the wrapped scope here
88     // instead of getOwnPropertySlot().
89     return thisObject->getPropertySlot(exec, propertyName, slot);
90 }
91
92 void DebuggerScope::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
93 {
94     DebuggerScope* scope = jsCast<DebuggerScope*>(cell);
95     ASSERT(scope->isValid());
96     if (!scope->isValid())
97         return;
98     JSObject* thisObject = JSScope::objectAtScope(scope->jsScope());
99     slot.setThisValue(JSValue(thisObject));
100     thisObject->methodTable()->put(thisObject, exec, propertyName, value, slot);
101 }
102
103 bool DebuggerScope::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
104 {
105     DebuggerScope* scope = jsCast<DebuggerScope*>(cell);
106     ASSERT(scope->isValid());
107     if (!scope->isValid())
108         return false;
109     JSObject* thisObject = JSScope::objectAtScope(scope->jsScope());
110     return thisObject->methodTable()->deleteProperty(thisObject, exec, propertyName);
111 }
112
113 void DebuggerScope::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
114 {
115     DebuggerScope* scope = jsCast<DebuggerScope*>(object);
116     ASSERT(scope->isValid());
117     if (!scope->isValid())
118         return;
119     JSObject* thisObject = JSScope::objectAtScope(scope->jsScope());
120     thisObject->methodTable()->getPropertyNames(thisObject, exec, propertyNames, mode);
121 }
122
123 bool DebuggerScope::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, const PropertyDescriptor& descriptor, bool shouldThrow)
124 {
125     DebuggerScope* scope = jsCast<DebuggerScope*>(object);
126     ASSERT(scope->isValid());
127     if (!scope->isValid())
128         return false;
129     JSObject* thisObject = JSScope::objectAtScope(scope->jsScope());
130     return thisObject->methodTable()->defineOwnProperty(thisObject, exec, propertyName, descriptor, shouldThrow);
131 }
132
133 DebuggerScope* DebuggerScope::next()
134 {
135     ASSERT(isValid());
136     if (!m_next && m_scope->next()) {
137         VM& vm = *m_scope->vm();
138         DebuggerScope* nextScope = create(vm, m_scope->next());
139         m_next.set(vm, this, nextScope);
140     }
141     return m_next.get();
142 }
143
144 void DebuggerScope::invalidateChain()
145 {
146     if (!isValid())
147         return;
148
149     DebuggerScope* scope = this;
150     while (scope) {
151         DebuggerScope* nextScope = scope->m_next.get();
152         scope->m_next.clear();
153         scope->m_scope.clear(); // This also marks this scope as invalid.
154         scope = nextScope;
155     }
156 }
157
158 bool DebuggerScope::isCatchScope() const
159 {
160     return m_scope->isNameScopeObject() && reinterpret_cast<JSNameScope*>(m_scope.get())->isCatchScope();
161 }
162
163 bool DebuggerScope::isFunctionNameScope() const
164 {
165     return m_scope->isNameScopeObject() && reinterpret_cast<JSNameScope*>(m_scope.get())->isFunctionNameScope();
166 }
167
168 bool DebuggerScope::isWithScope() const
169 {
170     return m_scope->isWithScope();
171 }
172
173 bool DebuggerScope::isGlobalScope() const
174 {
175     return m_scope->isGlobalObject();
176 }
177
178 bool DebuggerScope::isFunctionOrEvalScope() const
179 {
180     // In the current debugger implementation, every function or eval will create an
181     // lexical environment object. Hence, a lexical environment object implies a
182     // function or eval scope.
183     return m_scope->isActivationObject();
184 }
185
186 JSValue DebuggerScope::caughtValue() const
187 {
188     ASSERT(isCatchScope());
189     return reinterpret_cast<JSNameScope*>(m_scope.get())->value();
190 }
191
192 } // namespace JSC