1 /* 2 * Copyright (C) 2003, 2008, 2009 Apple Inc. All rights reserved. 3 * 4 * This library is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Library General Public 6 * License as published by the Free Software Foundation; either 7 * version 2 of the License, or (at your option) any later version. 8 * 9 * This library is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * Library General Public License for more details. 13 * 14 * You should have received a copy of the GNU Library General Public License 15 * along with this library; see the file COPYING.LIB. If not, write to 16 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 17 * Boston, MA 02110-1301, USA. 18 * 19 */ 20 21 #ifndef ScopeChain_h 22 #define ScopeChain_h 23 24 #include "FastAllocBase.h" 25 26 namespace JSC { 27 28 class JSGlobalData; 29 class JSGlobalObject; 30 class JSObject; 31 class MarkStack; 32 class ScopeChainIterator; 33 34 class ScopeChainNode : public FastAllocBase { 35 public: 36 ScopeChainNode(ScopeChainNode* next, JSObject* object, JSGlobalData* globalData, JSGlobalObject* globalObject, JSObject* globalThis) 37 : next(next) 38 , object(object) 39 , globalData(globalData) 40 , globalObject(globalObject) 41 , globalThis(globalThis) 42 , refCount(1) 43 { 44 ASSERT(globalData); 45 ASSERT(globalObject); 46 } 47 #ifndef NDEBUG 48 // Due to the number of subtle and timing dependent bugs that have occurred due 49 // to deleted but still "valid" ScopeChainNodes we now deliberately clobber the 50 // contents in debug builds. 51 ~ScopeChainNode() 52 { 53 next = 0; 54 object = 0; 55 globalData = 0; 56 globalObject = 0; 57 globalThis = 0; 58 } 59 #endif 60 61 ScopeChainNode* next; 62 JSObject* object; 63 JSGlobalData* globalData; 64 JSGlobalObject* globalObject; 65 JSObject* globalThis; 66 int refCount; 67 68 void deref() { ASSERT(refCount); if (--refCount == 0) { release();} } 69 void ref() { ASSERT(refCount); ++refCount; } 70 void release(); 71 72 // Before calling "push" on a bare ScopeChainNode, a client should 73 // logically "copy" the node. Later, the client can "deref" the head 74 // of its chain of ScopeChainNodes to reclaim all the nodes it added 75 // after the logical copy, leaving nodes added before the logical copy 76 // (nodes shared with other clients) untouched. 77 ScopeChainNode* copy() 78 { 79 ref(); 80 return this; 81 } 82 83 ScopeChainNode* push(JSObject*); 84 ScopeChainNode* pop(); 85 86 ScopeChainIterator begin() const; 87 ScopeChainIterator end() const; 88 89 #ifndef NDEBUG 90 void print() const; 91 #endif 92 }; 93 94 inline ScopeChainNode* ScopeChainNode::push(JSObject* o) 95 { 96 ASSERT(o); 97 return new ScopeChainNode(this, o, globalData, globalObject, globalThis); 98 } 99 100 inline ScopeChainNode* ScopeChainNode::pop() 101 { 102 ASSERT(next); 103 ScopeChainNode* result = next; 104 105 if (--refCount != 0) 106 ++result->refCount; 107 else 108 delete this; 109 110 return result; 111 } 112 113 inline void ScopeChainNode::release() 114 { 115 // This function is only called by deref(), 116 // Deref ensures these conditions are true. 117 ASSERT(refCount == 0); 118 ScopeChainNode* n = this; 119 do { 120 ScopeChainNode* next = n->next; 121 delete n; 122 n = next; 123 } while (n && --n->refCount == 0); 124 } 125 126 class ScopeChainIterator { 127 public: 128 ScopeChainIterator(const ScopeChainNode* node) 129 : m_node(node) 130 { 131 } 132 133 JSObject* const & operator*() const { return m_node->object; } 134 JSObject* const * operator->() const { return &(operator*()); } 135 136 ScopeChainIterator& operator++() { m_node = m_node->next; return *this; } 137 138 // postfix ++ intentionally omitted 139 140 bool operator==(const ScopeChainIterator& other) const { return m_node == other.m_node; } 141 bool operator!=(const ScopeChainIterator& other) const { return m_node != other.m_node; } 142 143 private: 144 const ScopeChainNode* m_node; 145 }; 146 147 inline ScopeChainIterator ScopeChainNode::begin() const 148 { 149 return ScopeChainIterator(this); 150 } 151 152 inline ScopeChainIterator ScopeChainNode::end() const 153 { 154 return ScopeChainIterator(0); 155 } 156 157 class NoScopeChain {}; 158 159 class ScopeChain { 160 friend class JIT; 161 public: 162 ScopeChain(NoScopeChain) 163 : m_node(0) 164 { 165 } 166 167 ScopeChain(JSObject* o, JSGlobalData* globalData, JSGlobalObject* globalObject, JSObject* globalThis) 168 : m_node(new ScopeChainNode(0, o, globalData, globalObject, globalThis)) 169 { 170 } 171 172 ScopeChain(const ScopeChain& c) 173 : m_node(c.m_node->copy()) 174 { 175 } 176 177 ScopeChain& operator=(const ScopeChain& c); 178 179 explicit ScopeChain(ScopeChainNode* node) 180 : m_node(node->copy()) 181 { 182 } 183 184 ~ScopeChain() 185 { 186 if (m_node) 187 m_node->deref(); 188 #ifndef NDEBUG 189 m_node = 0; 190 #endif 191 } 192 193 void swap(ScopeChain&); 194 195 ScopeChainNode* node() const { return m_node; } 196 197 JSObject* top() const { return m_node->object; } 198 199 ScopeChainIterator begin() const { return m_node->begin(); } 200 ScopeChainIterator end() const { return m_node->end(); } 201 202 void push(JSObject* o) { m_node = m_node->push(o); } 203 204 void pop() { m_node = m_node->pop(); } 205 void clear() { m_node->deref(); m_node = 0; } 206 207 JSGlobalObject* globalObject() const { return m_node->globalObject; } 208 209 void markAggregate(MarkStack&) const; 210 211 // Caution: this should only be used if the codeblock this is being used 212 // with needs a full scope chain, otherwise this returns the depth of 213 // the preceeding call frame 214 // 215 // Returns the depth of the current call frame's scope chain 216 int localDepth() const; 217 218 #ifndef NDEBUG 219 void print() const { m_node->print(); } 220 #endif 221 222 private: 223 ScopeChainNode* m_node; 224 }; 225 226 inline void ScopeChain::swap(ScopeChain& o) 227 { 228 ScopeChainNode* tmp = m_node; 229 m_node = o.m_node; 230 o.m_node = tmp; 231 } 232 233 inline ScopeChain& ScopeChain::operator=(const ScopeChain& c) 234 { 235 ScopeChain tmp(c); 236 swap(tmp); 237 return *this; 238 } 239 240 } // namespace JSC 241 242 #endif // ScopeChain_h 243
