OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) | 2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
3 * Copyright (C) 2000 Frederik Holljen (frederik.holljen@hig.no) | 3 * Copyright (C) 2000 Frederik Holljen (frederik.holljen@hig.no) |
4 * Copyright (C) 2001 Peter Kelly (pmk@post.com) | 4 * Copyright (C) 2001 Peter Kelly (pmk@post.com) |
5 * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com) | 5 * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com) |
6 * Copyright (C) 2004, 2008 Apple Inc. All rights reserved. | 6 * Copyright (C) 2004, 2008 Apple Inc. All rights reserved. |
7 * | 7 * |
8 * This library is free software; you can redistribute it and/or | 8 * This library is free software; you can redistribute it and/or |
9 * modify it under the terms of the GNU Library General Public | 9 * modify it under the terms of the GNU Library General Public |
10 * License as published by the Free Software Foundation; either | 10 * License as published by the Free Software Foundation; either |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
54 return m_current.get(); | 54 return m_current.get(); |
55 } | 55 } |
56 | 56 |
57 Node* TreeWalker::parentNode(ExceptionState& exceptionState) | 57 Node* TreeWalker::parentNode(ExceptionState& exceptionState) |
58 { | 58 { |
59 RefPtrWillBeRawPtr<Node> node = m_current; | 59 RefPtrWillBeRawPtr<Node> node = m_current; |
60 while (node != root()) { | 60 while (node != root()) { |
61 node = node->parentNode(); | 61 node = node->parentNode(); |
62 if (!node) | 62 if (!node) |
63 return 0; | 63 return 0; |
64 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 64 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
65 if (exceptionState.hadException()) | 65 if (exceptionState.hadException()) |
66 return 0; | 66 return 0; |
67 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) | 67 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) |
68 return setCurrent(node.release()); | 68 return setCurrent(node.release()); |
69 } | 69 } |
70 return 0; | 70 return 0; |
71 } | 71 } |
72 | 72 |
73 Node* TreeWalker::firstChild(ExceptionState& exceptionState) | 73 Node* TreeWalker::firstChild(ExceptionState& exceptionState) |
74 { | 74 { |
75 for (RefPtrWillBeRawPtr<Node> node = m_current->firstChild(); node; ) { | 75 for (RefPtrWillBeRawPtr<Node> node = m_current->firstChild(); node; ) { |
76 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 76 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
77 if (exceptionState.hadException()) | 77 if (exceptionState.hadException()) |
78 return 0; | 78 return 0; |
79 switch (acceptNodeResult) { | 79 switch (acceptNodeResult) { |
80 case NodeFilter::FILTER_ACCEPT: | 80 case NodeFilter::FILTER_ACCEPT: |
81 m_current = node.release(); | 81 m_current = node.release(); |
82 return m_current.get(); | 82 return m_current.get(); |
83 case NodeFilter::FILTER_SKIP: | 83 case NodeFilter::FILTER_SKIP: |
84 if (node->hasChildren()) { | 84 if (node->hasChildren()) { |
85 node = node->firstChild(); | 85 node = node->firstChild(); |
86 continue; | 86 continue; |
(...skipping 12 matching lines...) Expand all Loading... |
99 return 0; | 99 return 0; |
100 node = parent; | 100 node = parent; |
101 } while (node); | 101 } while (node); |
102 } | 102 } |
103 return 0; | 103 return 0; |
104 } | 104 } |
105 | 105 |
106 Node* TreeWalker::lastChild(ExceptionState& exceptionState) | 106 Node* TreeWalker::lastChild(ExceptionState& exceptionState) |
107 { | 107 { |
108 for (RefPtrWillBeRawPtr<Node> node = m_current->lastChild(); node; ) { | 108 for (RefPtrWillBeRawPtr<Node> node = m_current->lastChild(); node; ) { |
109 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 109 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
110 if (exceptionState.hadException()) | 110 if (exceptionState.hadException()) |
111 return 0; | 111 return 0; |
112 switch (acceptNodeResult) { | 112 switch (acceptNodeResult) { |
113 case NodeFilter::FILTER_ACCEPT: | 113 case NodeFilter::FILTER_ACCEPT: |
114 m_current = node.release(); | 114 m_current = node.release(); |
115 return m_current.get(); | 115 return m_current.get(); |
116 case NodeFilter::FILTER_SKIP: | 116 case NodeFilter::FILTER_SKIP: |
117 if (node->lastChild()) { | 117 if (node->lastChild()) { |
118 node = node->lastChild(); | 118 node = node->lastChild(); |
119 continue; | 119 continue; |
(...skipping 16 matching lines...) Expand all Loading... |
136 return 0; | 136 return 0; |
137 } | 137 } |
138 | 138 |
139 Node* TreeWalker::previousSibling(ExceptionState& exceptionState) | 139 Node* TreeWalker::previousSibling(ExceptionState& exceptionState) |
140 { | 140 { |
141 RefPtrWillBeRawPtr<Node> node = m_current; | 141 RefPtrWillBeRawPtr<Node> node = m_current; |
142 if (node == root()) | 142 if (node == root()) |
143 return 0; | 143 return 0; |
144 while (1) { | 144 while (1) { |
145 for (RefPtrWillBeRawPtr<Node> sibling = node->previousSibling(); sibling
; ) { | 145 for (RefPtrWillBeRawPtr<Node> sibling = node->previousSibling(); sibling
; ) { |
146 short acceptNodeResult = acceptNode(sibling.get(), exceptionState); | 146 unsigned acceptNodeResult = acceptNode(sibling.get(), exceptionState
); |
147 if (exceptionState.hadException()) | 147 if (exceptionState.hadException()) |
148 return 0; | 148 return 0; |
149 switch (acceptNodeResult) { | 149 switch (acceptNodeResult) { |
150 case NodeFilter::FILTER_ACCEPT: | 150 case NodeFilter::FILTER_ACCEPT: |
151 m_current = sibling.release(); | 151 m_current = sibling.release(); |
152 return m_current.get(); | 152 return m_current.get(); |
153 case NodeFilter::FILTER_SKIP: | 153 case NodeFilter::FILTER_SKIP: |
154 if (sibling->lastChild()) { | 154 if (sibling->lastChild()) { |
155 sibling = sibling->lastChild(); | 155 sibling = sibling->lastChild(); |
156 node = sibling; | 156 node = sibling; |
157 continue; | 157 continue; |
158 } | 158 } |
159 break; | 159 break; |
160 case NodeFilter::FILTER_REJECT: | 160 case NodeFilter::FILTER_REJECT: |
161 break; | 161 break; |
162 } | 162 } |
163 sibling = sibling->previousSibling(); | 163 sibling = sibling->previousSibling(); |
164 } | 164 } |
165 node = node->parentNode(); | 165 node = node->parentNode(); |
166 if (!node || node == root()) | 166 if (!node || node == root()) |
167 return 0; | 167 return 0; |
168 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 168 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
169 if (exceptionState.hadException()) | 169 if (exceptionState.hadException()) |
170 return 0; | 170 return 0; |
171 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) | 171 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) |
172 return 0; | 172 return 0; |
173 } | 173 } |
174 } | 174 } |
175 | 175 |
176 Node* TreeWalker::nextSibling(ExceptionState& exceptionState) | 176 Node* TreeWalker::nextSibling(ExceptionState& exceptionState) |
177 { | 177 { |
178 RefPtrWillBeRawPtr<Node> node = m_current; | 178 RefPtrWillBeRawPtr<Node> node = m_current; |
179 if (node == root()) | 179 if (node == root()) |
180 return 0; | 180 return 0; |
181 while (1) { | 181 while (1) { |
182 for (RefPtrWillBeRawPtr<Node> sibling = node->nextSibling(); sibling; )
{ | 182 for (RefPtrWillBeRawPtr<Node> sibling = node->nextSibling(); sibling; )
{ |
183 short acceptNodeResult = acceptNode(sibling.get(), exceptionState); | 183 unsigned acceptNodeResult = acceptNode(sibling.get(), exceptionState
); |
184 if (exceptionState.hadException()) | 184 if (exceptionState.hadException()) |
185 return 0; | 185 return 0; |
186 switch (acceptNodeResult) { | 186 switch (acceptNodeResult) { |
187 case NodeFilter::FILTER_ACCEPT: | 187 case NodeFilter::FILTER_ACCEPT: |
188 m_current = sibling.release(); | 188 m_current = sibling.release(); |
189 return m_current.get(); | 189 return m_current.get(); |
190 case NodeFilter::FILTER_SKIP: | 190 case NodeFilter::FILTER_SKIP: |
191 if (sibling->hasChildren()) { | 191 if (sibling->hasChildren()) { |
192 sibling = sibling->firstChild(); | 192 sibling = sibling->firstChild(); |
193 node = sibling; | 193 node = sibling; |
194 continue; | 194 continue; |
195 } | 195 } |
196 break; | 196 break; |
197 case NodeFilter::FILTER_REJECT: | 197 case NodeFilter::FILTER_REJECT: |
198 break; | 198 break; |
199 } | 199 } |
200 sibling = sibling->nextSibling(); | 200 sibling = sibling->nextSibling(); |
201 } | 201 } |
202 node = node->parentNode(); | 202 node = node->parentNode(); |
203 if (!node || node == root()) | 203 if (!node || node == root()) |
204 return 0; | 204 return 0; |
205 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 205 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
206 if (exceptionState.hadException()) | 206 if (exceptionState.hadException()) |
207 return 0; | 207 return 0; |
208 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) | 208 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) |
209 return 0; | 209 return 0; |
210 } | 210 } |
211 } | 211 } |
212 | 212 |
213 Node* TreeWalker::previousNode(ExceptionState& exceptionState) | 213 Node* TreeWalker::previousNode(ExceptionState& exceptionState) |
214 { | 214 { |
215 RefPtrWillBeRawPtr<Node> node = m_current; | 215 RefPtrWillBeRawPtr<Node> node = m_current; |
216 while (node != root()) { | 216 while (node != root()) { |
217 while (Node* previousSibling = node->previousSibling()) { | 217 while (Node* previousSibling = node->previousSibling()) { |
218 node = previousSibling; | 218 node = previousSibling; |
219 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 219 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
220 if (exceptionState.hadException()) | 220 if (exceptionState.hadException()) |
221 return 0; | 221 return 0; |
222 if (acceptNodeResult == NodeFilter::FILTER_REJECT) | 222 if (acceptNodeResult == NodeFilter::FILTER_REJECT) |
223 continue; | 223 continue; |
224 while (Node* lastChild = node->lastChild()) { | 224 while (Node* lastChild = node->lastChild()) { |
225 node = lastChild; | 225 node = lastChild; |
226 acceptNodeResult = acceptNode(node.get(), exceptionState); | 226 acceptNodeResult = acceptNode(node.get(), exceptionState); |
227 if (exceptionState.hadException()) | 227 if (exceptionState.hadException()) |
228 return 0; | 228 return 0; |
229 if (acceptNodeResult == NodeFilter::FILTER_REJECT) | 229 if (acceptNodeResult == NodeFilter::FILTER_REJECT) |
230 break; | 230 break; |
231 } | 231 } |
232 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) { | 232 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) { |
233 m_current = node.release(); | 233 m_current = node.release(); |
234 return m_current.get(); | 234 return m_current.get(); |
235 } | 235 } |
236 } | 236 } |
237 if (node == root()) | 237 if (node == root()) |
238 return 0; | 238 return 0; |
239 ContainerNode* parent = node->parentNode(); | 239 ContainerNode* parent = node->parentNode(); |
240 if (!parent) | 240 if (!parent) |
241 return 0; | 241 return 0; |
242 node = parent; | 242 node = parent; |
243 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 243 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
244 if (exceptionState.hadException()) | 244 if (exceptionState.hadException()) |
245 return 0; | 245 return 0; |
246 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) | 246 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) |
247 return setCurrent(node.release()); | 247 return setCurrent(node.release()); |
248 } | 248 } |
249 return 0; | 249 return 0; |
250 } | 250 } |
251 | 251 |
252 Node* TreeWalker::nextNode(ExceptionState& exceptionState) | 252 Node* TreeWalker::nextNode(ExceptionState& exceptionState) |
253 { | 253 { |
254 RefPtrWillBeRawPtr<Node> node = m_current; | 254 RefPtrWillBeRawPtr<Node> node = m_current; |
255 Children: | 255 Children: |
256 while (Node* firstChild = node->firstChild()) { | 256 while (Node* firstChild = node->firstChild()) { |
257 node = firstChild; | 257 node = firstChild; |
258 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 258 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
259 if (exceptionState.hadException()) | 259 if (exceptionState.hadException()) |
260 return 0; | 260 return 0; |
261 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) | 261 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) |
262 return setCurrent(node.release()); | 262 return setCurrent(node.release()); |
263 if (acceptNodeResult == NodeFilter::FILTER_REJECT) | 263 if (acceptNodeResult == NodeFilter::FILTER_REJECT) |
264 break; | 264 break; |
265 } | 265 } |
266 while (Node* nextSibling = NodeTraversal::nextSkippingChildren(*node, root()
)) { | 266 while (Node* nextSibling = NodeTraversal::nextSkippingChildren(*node, root()
)) { |
267 node = nextSibling; | 267 node = nextSibling; |
268 short acceptNodeResult = acceptNode(node.get(), exceptionState); | 268 unsigned acceptNodeResult = acceptNode(node.get(), exceptionState); |
269 if (exceptionState.hadException()) | 269 if (exceptionState.hadException()) |
270 return 0; | 270 return 0; |
271 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) | 271 if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) |
272 return setCurrent(node.release()); | 272 return setCurrent(node.release()); |
273 if (acceptNodeResult == NodeFilter::FILTER_SKIP) | 273 if (acceptNodeResult == NodeFilter::FILTER_SKIP) |
274 goto Children; | 274 goto Children; |
275 } | 275 } |
276 return 0; | 276 return 0; |
277 } | 277 } |
278 | 278 |
279 DEFINE_TRACE(TreeWalker) | 279 DEFINE_TRACE(TreeWalker) |
280 { | 280 { |
281 visitor->trace(m_current); | 281 visitor->trace(m_current); |
282 NodeIteratorBase::trace(visitor); | 282 NodeIteratorBase::trace(visitor); |
283 } | 283 } |
284 | 284 |
285 } // namespace blink | 285 } // namespace blink |
OLD | NEW |