/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Rewrite/DeltaTree.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===- DeltaTree.cpp - B-Tree for Rewrite Delta tracking ------------------===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This file implements the DeltaTree and related classes. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #include "clang/Rewrite/Core/DeltaTree.h" |
14 | | #include "clang/Basic/LLVM.h" |
15 | | #include "llvm/Support/Casting.h" |
16 | | #include <cassert> |
17 | | #include <cstring> |
18 | | |
19 | | using namespace clang; |
20 | | |
21 | | /// The DeltaTree class is a multiway search tree (BTree) structure with some |
22 | | /// fancy features. B-Trees are generally more memory and cache efficient |
23 | | /// than binary trees, because they store multiple keys/values in each node. |
24 | | /// |
25 | | /// DeltaTree implements a key/value mapping from FileIndex to Delta, allowing |
26 | | /// fast lookup by FileIndex. However, an added (important) bonus is that it |
27 | | /// can also efficiently tell us the full accumulated delta for a specific |
28 | | /// file offset as well, without traversing the whole tree. |
29 | | /// |
30 | | /// The nodes of the tree are made up of instances of two classes: |
31 | | /// DeltaTreeNode and DeltaTreeInteriorNode. The later subclasses the |
32 | | /// former and adds children pointers. Each node knows the full delta of all |
33 | | /// entries (recursively) contained inside of it, which allows us to get the |
34 | | /// full delta implied by a whole subtree in constant time. |
35 | | |
36 | | namespace { |
37 | | |
38 | | /// SourceDelta - As code in the original input buffer is added and deleted, |
39 | | /// SourceDelta records are used to keep track of how the input SourceLocation |
40 | | /// object is mapped into the output buffer. |
41 | | struct SourceDelta { |
42 | | unsigned FileLoc; |
43 | | int Delta; |
44 | | |
45 | 117k | static SourceDelta get(unsigned Loc, int D) { |
46 | 117k | SourceDelta Delta; |
47 | 117k | Delta.FileLoc = Loc; |
48 | 117k | Delta.Delta = D; |
49 | 117k | return Delta; |
50 | 117k | } |
51 | | }; |
52 | | |
53 | | /// DeltaTreeNode - The common part of all nodes. |
54 | | /// |
55 | | class DeltaTreeNode { |
56 | | public: |
57 | | struct InsertResult { |
58 | | DeltaTreeNode *LHS, *RHS; |
59 | | SourceDelta Split; |
60 | | }; |
61 | | |
62 | | private: |
63 | | friend class DeltaTreeInteriorNode; |
64 | | |
65 | | /// WidthFactor - This controls the number of K/V slots held in the BTree: |
66 | | /// how wide it is. Each level of the BTree is guaranteed to have at least |
67 | | /// WidthFactor-1 K/V pairs (except the root) and may have at most |
68 | | /// 2*WidthFactor-1 K/V pairs. |
69 | | enum { WidthFactor = 8 }; |
70 | | |
71 | | /// Values - This tracks the SourceDelta's currently in this node. |
72 | | SourceDelta Values[2*WidthFactor-1]; |
73 | | |
74 | | /// NumValuesUsed - This tracks the number of values this node currently |
75 | | /// holds. |
76 | | unsigned char NumValuesUsed = 0; |
77 | | |
78 | | /// IsLeaf - This is true if this is a leaf of the btree. If false, this is |
79 | | /// an interior node, and is actually an instance of DeltaTreeInteriorNode. |
80 | | bool IsLeaf; |
81 | | |
82 | | /// FullDelta - This is the full delta of all the values in this node and |
83 | | /// all children nodes. |
84 | | int FullDelta = 0; |
85 | | |
86 | | public: |
87 | 70.2k | DeltaTreeNode(bool isLeaf = true) : IsLeaf(isLeaf) {} |
88 | | |
89 | 822k | bool isLeaf() const { return IsLeaf; } |
90 | 832k | int getFullDelta() const { return FullDelta; } |
91 | 138k | bool isFull() const { return NumValuesUsed == 2*WidthFactor-1; } |
92 | | |
93 | 1.79M | unsigned getNumValuesUsed() const { return NumValuesUsed; } |
94 | | |
95 | 1.73M | const SourceDelta &getValue(unsigned i) const { |
96 | 1.73M | assert(i < NumValuesUsed && "Invalid value #"); |
97 | 0 | return Values[i]; |
98 | 1.73M | } |
99 | | |
100 | 1.79M | SourceDelta &getValue(unsigned i) { |
101 | 1.79M | assert(i < NumValuesUsed && "Invalid value #"); |
102 | 0 | return Values[i]; |
103 | 1.79M | } |
104 | | |
105 | | /// DoInsertion - Do an insertion of the specified FileIndex/Delta pair into |
106 | | /// this node. If insertion is easy, do it and return false. Otherwise, |
107 | | /// split the node, populate InsertRes with info about the split, and return |
108 | | /// true. |
109 | | bool DoInsertion(unsigned FileIndex, int Delta, InsertResult *InsertRes); |
110 | | |
111 | | void DoSplit(InsertResult &InsertRes); |
112 | | |
113 | | |
114 | | /// RecomputeFullDeltaLocally - Recompute the FullDelta field by doing a |
115 | | /// local walk over our contained deltas. |
116 | | void RecomputeFullDeltaLocally(); |
117 | | |
118 | | void Destroy(); |
119 | | }; |
120 | | |
121 | | /// DeltaTreeInteriorNode - When isLeaf = false, a node has child pointers. |
122 | | /// This class tracks them. |
123 | | class DeltaTreeInteriorNode : public DeltaTreeNode { |
124 | | friend class DeltaTreeNode; |
125 | | |
126 | | DeltaTreeNode *Children[2*WidthFactor]; |
127 | | |
128 | 1.02k | ~DeltaTreeInteriorNode() { |
129 | 8.67k | for (unsigned i = 0, e = NumValuesUsed+1; i != e; ++i7.64k ) |
130 | 7.64k | Children[i]->Destroy(); |
131 | 1.02k | } |
132 | | |
133 | | public: |
134 | 562 | DeltaTreeInteriorNode() : DeltaTreeNode(false /*nonleaf*/) {} |
135 | | |
136 | | DeltaTreeInteriorNode(const InsertResult &IR) |
137 | 466 | : DeltaTreeNode(false /*nonleaf*/) { |
138 | 466 | Children[0] = IR.LHS; |
139 | 466 | Children[1] = IR.RHS; |
140 | 466 | Values[0] = IR.Split; |
141 | 466 | FullDelta = IR.LHS->getFullDelta()+IR.RHS->getFullDelta()+IR.Split.Delta; |
142 | 466 | NumValuesUsed = 1; |
143 | 466 | } |
144 | | |
145 | 974k | const DeltaTreeNode *getChild(unsigned i) const { |
146 | 974k | assert(i < getNumValuesUsed()+1 && "Invalid child"); |
147 | 0 | return Children[i]; |
148 | 974k | } |
149 | | |
150 | 8.99k | DeltaTreeNode *getChild(unsigned i) { |
151 | 8.99k | assert(i < getNumValuesUsed()+1 && "Invalid child"); |
152 | 0 | return Children[i]; |
153 | 8.99k | } |
154 | | |
155 | 480k | static bool classof(const DeltaTreeNode *N) { return !N->isLeaf(); } |
156 | | }; |
157 | | |
158 | | } // namespace |
159 | | |
160 | | /// Destroy - A 'virtual' destructor. |
161 | 70.2k | void DeltaTreeNode::Destroy() { |
162 | 70.2k | if (isLeaf()) |
163 | 69.2k | delete this; |
164 | 1.02k | else |
165 | 1.02k | delete cast<DeltaTreeInteriorNode>(this); |
166 | 70.2k | } |
167 | | |
168 | | /// RecomputeFullDeltaLocally - Recompute the FullDelta field by doing a |
169 | | /// local walk over our contained deltas. |
170 | 14.3k | void DeltaTreeNode::RecomputeFullDeltaLocally() { |
171 | 14.3k | int NewFullDelta = 0; |
172 | 114k | for (unsigned i = 0, e = getNumValuesUsed(); i != e; ++i100k ) |
173 | 100k | NewFullDelta += Values[i].Delta; |
174 | 14.3k | if (auto *IN = dyn_cast<DeltaTreeInteriorNode>(this)) |
175 | 10.1k | for (unsigned i = 0, e = getNumValuesUsed()+1; 1.12k i != e; ++i8.99k ) |
176 | 8.99k | NewFullDelta += IN->getChild(i)->getFullDelta(); |
177 | 14.3k | FullDelta = NewFullDelta; |
178 | 14.3k | } |
179 | | |
180 | | /// DoInsertion - Do an insertion of the specified FileIndex/Delta pair into |
181 | | /// this node. If insertion is easy, do it and return false. Otherwise, |
182 | | /// split the node, populate InsertRes with info about the split, and return |
183 | | /// true. |
184 | | bool DeltaTreeNode::DoInsertion(unsigned FileIndex, int Delta, |
185 | 287k | InsertResult *InsertRes) { |
186 | | // Maintain full delta for this node. |
187 | 287k | FullDelta += Delta; |
188 | | |
189 | | // Find the insertion point, the first delta whose index is >= FileIndex. |
190 | 287k | unsigned i = 0, e = getNumValuesUsed(); |
191 | 1.67M | while (i != e && FileIndex > getValue(i).FileLoc1.59M ) |
192 | 1.38M | ++i; |
193 | | |
194 | | // If we found an a record for exactly this file index, just merge this |
195 | | // value into the pre-existing record and finish early. |
196 | 287k | if (i != e && getValue(i).FileLoc == FileIndex202k ) { |
197 | | // NOTE: Delta could drop to zero here. This means that the delta entry is |
198 | | // useless and could be removed. Supporting erases is more complex than |
199 | | // leaving an entry with Delta=0, so we just leave an entry with Delta=0 in |
200 | | // the tree. |
201 | 15.5k | Values[i].Delta += Delta; |
202 | 15.5k | return false; |
203 | 15.5k | } |
204 | | |
205 | | // Otherwise, we found an insertion point, and we know that the value at the |
206 | | // specified index is > FileIndex. Handle the leaf case first. |
207 | 272k | if (isLeaf()) { |
208 | 124k | if (!isFull()) { |
209 | | // For an insertion into a non-full leaf node, just insert the value in |
210 | | // its sorted position. This requires moving later values over. |
211 | 117k | if (i != e) |
212 | 86.9k | memmove(&Values[i+1], &Values[i], sizeof(Values[0])*(e-i)); |
213 | 117k | Values[i] = SourceDelta::get(FileIndex, Delta); |
214 | 117k | ++NumValuesUsed; |
215 | 117k | return false; |
216 | 117k | } |
217 | | |
218 | | // Otherwise, if this is leaf is full, split the node at its median, insert |
219 | | // the value into one of the children, and return the result. |
220 | 6.61k | assert(InsertRes && "No result location specified"); |
221 | 0 | DoSplit(*InsertRes); |
222 | | |
223 | 6.61k | if (InsertRes->Split.FileLoc > FileIndex) |
224 | 826 | InsertRes->LHS->DoInsertion(FileIndex, Delta, nullptr /*can't fail*/); |
225 | 5.79k | else |
226 | 5.79k | InsertRes->RHS->DoInsertion(FileIndex, Delta, nullptr /*can't fail*/); |
227 | 6.61k | return true; |
228 | 124k | } |
229 | | |
230 | | // Otherwise, this is an interior node. Send the request down the tree. |
231 | 147k | auto *IN = cast<DeltaTreeInteriorNode>(this); |
232 | 147k | if (!IN->Children[i]->DoInsertion(FileIndex, Delta, InsertRes)) |
233 | 141k | return false; // If there was space in the child, just return. |
234 | | |
235 | | // Okay, this split the subtree, producing a new value and two children to |
236 | | // insert here. If this node is non-full, we can just insert it directly. |
237 | 6.71k | if (!isFull()) { |
238 | | // Now that we have two nodes and a new element, insert the perclated value |
239 | | // into ourself by moving all the later values/children down, then inserting |
240 | | // the new one. |
241 | 6.15k | if (i != e) |
242 | 4.49k | memmove(&IN->Children[i+2], &IN->Children[i+1], |
243 | 4.49k | (e-i)*sizeof(IN->Children[0])); |
244 | 6.15k | IN->Children[i] = InsertRes->LHS; |
245 | 6.15k | IN->Children[i+1] = InsertRes->RHS; |
246 | | |
247 | 6.15k | if (e != i) |
248 | 4.49k | memmove(&Values[i+1], &Values[i], (e-i)*sizeof(Values[0])); |
249 | 6.15k | Values[i] = InsertRes->Split; |
250 | 6.15k | ++NumValuesUsed; |
251 | 6.15k | return false; |
252 | 6.15k | } |
253 | | |
254 | | // Finally, if this interior node was full and a node is percolated up, split |
255 | | // ourself and return that up the chain. Start by saving all our info to |
256 | | // avoid having the split clobber it. |
257 | 562 | IN->Children[i] = InsertRes->LHS; |
258 | 562 | DeltaTreeNode *SubRHS = InsertRes->RHS; |
259 | 562 | SourceDelta SubSplit = InsertRes->Split; |
260 | | |
261 | | // Do the split. |
262 | 562 | DoSplit(*InsertRes); |
263 | | |
264 | | // Figure out where to insert SubRHS/NewSplit. |
265 | 562 | DeltaTreeInteriorNode *InsertSide; |
266 | 562 | if (SubSplit.FileLoc < InsertRes->Split.FileLoc) |
267 | 40 | InsertSide = cast<DeltaTreeInteriorNode>(InsertRes->LHS); |
268 | 522 | else |
269 | 522 | InsertSide = cast<DeltaTreeInteriorNode>(InsertRes->RHS); |
270 | | |
271 | | // We now have a non-empty interior node 'InsertSide' to insert |
272 | | // SubRHS/SubSplit into. Find out where to insert SubSplit. |
273 | | |
274 | | // Find the insertion point, the first delta whose index is >SubSplit.FileLoc. |
275 | 562 | i = 0; e = InsertSide->getNumValuesUsed(); |
276 | 3.27k | while (i != e && SubSplit.FileLoc > InsertSide->getValue(i).FileLoc3.15k ) |
277 | 2.71k | ++i; |
278 | | |
279 | | // Now we know that i is the place to insert the split value into. Insert it |
280 | | // and the child right after it. |
281 | 562 | if (i != e) |
282 | 440 | memmove(&InsertSide->Children[i+2], &InsertSide->Children[i+1], |
283 | 440 | (e-i)*sizeof(IN->Children[0])); |
284 | 562 | InsertSide->Children[i+1] = SubRHS; |
285 | | |
286 | 562 | if (e != i) |
287 | 440 | memmove(&InsertSide->Values[i+1], &InsertSide->Values[i], |
288 | 440 | (e-i)*sizeof(Values[0])); |
289 | 562 | InsertSide->Values[i] = SubSplit; |
290 | 562 | ++InsertSide->NumValuesUsed; |
291 | 562 | InsertSide->FullDelta += SubSplit.Delta + SubRHS->getFullDelta(); |
292 | 562 | return true; |
293 | 6.71k | } |
294 | | |
295 | | /// DoSplit - Split the currently full node (which has 2*WidthFactor-1 values) |
296 | | /// into two subtrees each with "WidthFactor-1" values and a pivot value. |
297 | | /// Return the pieces in InsertRes. |
298 | 7.18k | void DeltaTreeNode::DoSplit(InsertResult &InsertRes) { |
299 | 7.18k | assert(isFull() && "Why split a non-full node?"); |
300 | | |
301 | | // Since this node is full, it contains 2*WidthFactor-1 values. We move |
302 | | // the first 'WidthFactor-1' values to the LHS child (which we leave in this |
303 | | // node), propagate one value up, and move the last 'WidthFactor-1' values |
304 | | // into the RHS child. |
305 | | |
306 | | // Create the new child node. |
307 | 0 | DeltaTreeNode *NewNode; |
308 | 7.18k | if (auto *IN = dyn_cast<DeltaTreeInteriorNode>(this)) { |
309 | | // If this is an interior node, also move over 'WidthFactor' children |
310 | | // into the new node. |
311 | 562 | DeltaTreeInteriorNode *New = new DeltaTreeInteriorNode(); |
312 | 562 | memcpy(&New->Children[0], &IN->Children[WidthFactor], |
313 | 562 | WidthFactor*sizeof(IN->Children[0])); |
314 | 562 | NewNode = New; |
315 | 6.61k | } else { |
316 | | // Just create the new leaf node. |
317 | 6.61k | NewNode = new DeltaTreeNode(); |
318 | 6.61k | } |
319 | | |
320 | | // Move over the last 'WidthFactor-1' values from here to NewNode. |
321 | 7.18k | memcpy(&NewNode->Values[0], &Values[WidthFactor], |
322 | 7.18k | (WidthFactor-1)*sizeof(Values[0])); |
323 | | |
324 | | // Decrease the number of values in the two nodes. |
325 | 7.18k | NewNode->NumValuesUsed = NumValuesUsed = WidthFactor-1; |
326 | | |
327 | | // Recompute the two nodes' full delta. |
328 | 7.18k | NewNode->RecomputeFullDeltaLocally(); |
329 | 7.18k | RecomputeFullDeltaLocally(); |
330 | | |
331 | 7.18k | InsertRes.LHS = this; |
332 | 7.18k | InsertRes.RHS = NewNode; |
333 | 7.18k | InsertRes.Split = Values[WidthFactor-1]; |
334 | 7.18k | } |
335 | | |
336 | | //===----------------------------------------------------------------------===// |
337 | | // DeltaTree Implementation |
338 | | //===----------------------------------------------------------------------===// |
339 | | |
340 | | //#define VERIFY_TREE |
341 | | |
342 | | #ifdef VERIFY_TREE |
343 | | /// VerifyTree - Walk the btree performing assertions on various properties to |
344 | | /// verify consistency. This is useful for debugging new changes to the tree. |
345 | | static void VerifyTree(const DeltaTreeNode *N) { |
346 | | const auto *IN = dyn_cast<DeltaTreeInteriorNode>(N); |
347 | | if (IN == 0) { |
348 | | // Verify leaves, just ensure that FullDelta matches up and the elements |
349 | | // are in proper order. |
350 | | int FullDelta = 0; |
351 | | for (unsigned i = 0, e = N->getNumValuesUsed(); i != e; ++i) { |
352 | | if (i) |
353 | | assert(N->getValue(i-1).FileLoc < N->getValue(i).FileLoc); |
354 | | FullDelta += N->getValue(i).Delta; |
355 | | } |
356 | | assert(FullDelta == N->getFullDelta()); |
357 | | return; |
358 | | } |
359 | | |
360 | | // Verify interior nodes: Ensure that FullDelta matches up and the |
361 | | // elements are in proper order and the children are in proper order. |
362 | | int FullDelta = 0; |
363 | | for (unsigned i = 0, e = IN->getNumValuesUsed(); i != e; ++i) { |
364 | | const SourceDelta &IVal = N->getValue(i); |
365 | | const DeltaTreeNode *IChild = IN->getChild(i); |
366 | | if (i) |
367 | | assert(IN->getValue(i-1).FileLoc < IVal.FileLoc); |
368 | | FullDelta += IVal.Delta; |
369 | | FullDelta += IChild->getFullDelta(); |
370 | | |
371 | | // The largest value in child #i should be smaller than FileLoc. |
372 | | assert(IChild->getValue(IChild->getNumValuesUsed()-1).FileLoc < |
373 | | IVal.FileLoc); |
374 | | |
375 | | // The smallest value in child #i+1 should be larger than FileLoc. |
376 | | assert(IN->getChild(i+1)->getValue(0).FileLoc > IVal.FileLoc); |
377 | | VerifyTree(IChild); |
378 | | } |
379 | | |
380 | | FullDelta += IN->getChild(IN->getNumValuesUsed())->getFullDelta(); |
381 | | |
382 | | assert(FullDelta == N->getFullDelta()); |
383 | | } |
384 | | #endif // VERIFY_TREE |
385 | | |
386 | 394k | static DeltaTreeNode *getRoot(void *Root) { |
387 | 394k | return (DeltaTreeNode*)Root; |
388 | 394k | } |
389 | | |
390 | 20.8k | DeltaTree::DeltaTree() { |
391 | 20.8k | Root = new DeltaTreeNode(); |
392 | 20.8k | } |
393 | | |
394 | 41.7k | DeltaTree::DeltaTree(const DeltaTree &RHS) { |
395 | | // Currently we only support copying when the RHS is empty. |
396 | 41.7k | assert(getRoot(RHS.Root)->getNumValuesUsed() == 0 && |
397 | 41.7k | "Can only copy empty tree"); |
398 | 0 | Root = new DeltaTreeNode(); |
399 | 41.7k | } |
400 | | |
401 | 62.5k | DeltaTree::~DeltaTree() { |
402 | 62.5k | getRoot(Root)->Destroy(); |
403 | 62.5k | } |
404 | | |
405 | | /// getDeltaAt - Return the accumulated delta at the specified file offset. |
406 | | /// This includes all insertions or delections that occurred *before* the |
407 | | /// specified file index. |
408 | 157k | int DeltaTree::getDeltaAt(unsigned FileIndex) const { |
409 | 157k | const DeltaTreeNode *Node = getRoot(Root); |
410 | | |
411 | 157k | int Result = 0; |
412 | | |
413 | | // Walk down the tree. |
414 | 309k | while (true) { |
415 | | // For all nodes, include any local deltas before the specified file |
416 | | // index by summing them up directly. Keep track of how many were |
417 | | // included. |
418 | 309k | unsigned NumValsGreater = 0; |
419 | 1.74M | for (unsigned e = Node->getNumValuesUsed(); NumValsGreater != e; |
420 | 1.63M | ++NumValsGreater1.43M ) { |
421 | 1.63M | const SourceDelta &Val = Node->getValue(NumValsGreater); |
422 | | |
423 | 1.63M | if (Val.FileLoc >= FileIndex) |
424 | 202k | break; |
425 | 1.43M | Result += Val.Delta; |
426 | 1.43M | } |
427 | | |
428 | | // If we have an interior node, include information about children and |
429 | | // recurse. Otherwise, if we have a leaf, we're done. |
430 | 309k | const auto *IN = dyn_cast<DeltaTreeInteriorNode>(Node); |
431 | 309k | if (!IN) return Result156k ; |
432 | | |
433 | | // Include any children to the left of the values we skipped, all of |
434 | | // their deltas should be included as well. |
435 | 974k | for (unsigned i = 0; 152k i != NumValsGreater; ++i821k ) |
436 | 821k | Result += IN->getChild(i)->getFullDelta(); |
437 | | |
438 | | // If we found exactly the value we were looking for, break off the |
439 | | // search early. There is no need to search the RHS of the value for |
440 | | // partial results. |
441 | 152k | if (NumValsGreater != Node->getNumValuesUsed() && |
442 | 152k | Node->getValue(NumValsGreater).FileLoc == FileIndex96.2k ) |
443 | 810 | return Result+IN->getChild(NumValsGreater)->getFullDelta(); |
444 | | |
445 | | // Otherwise, traverse down the tree. The selected subtree may be |
446 | | // partially included in the range. |
447 | 152k | Node = IN->getChild(NumValsGreater); |
448 | 152k | } |
449 | | // NOT REACHED. |
450 | 157k | } |
451 | | |
452 | | /// AddDelta - When a change is made that shifts around the text buffer, |
453 | | /// this method is used to record that info. It inserts a delta of 'Delta' |
454 | | /// into the current DeltaTree at offset FileIndex. |
455 | 133k | void DeltaTree::AddDelta(unsigned FileIndex, int Delta) { |
456 | 133k | assert(Delta && "Adding a noop?"); |
457 | 0 | DeltaTreeNode *MyRoot = getRoot(Root); |
458 | | |
459 | 133k | DeltaTreeNode::InsertResult InsertRes; |
460 | 133k | if (MyRoot->DoInsertion(FileIndex, Delta, &InsertRes)) { |
461 | 466 | Root = new DeltaTreeInteriorNode(InsertRes); |
462 | | #ifdef VERIFY_TREE |
463 | | MyRoot = Root; |
464 | | #endif |
465 | 466 | } |
466 | | |
467 | | #ifdef VERIFY_TREE |
468 | | VerifyTree(MyRoot); |
469 | | #endif |
470 | 133k | } |