?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ahci: Whitespace and line length cleanup only.
[haiku.git] / headers / cpp / ropeimpl.h
blob18bb2c9ec9d187f0d017458c2c53e6d2a7c540ae
1 /*
2 * Copyright (c) 1997
3 * Silicon Graphics Computer Systems, Inc.
4 *
5 * Permission to use, copy, modify, distribute and sell this software
6 * and its documentation for any purpose is hereby granted without fee,
7 * provided that the above copyright notice appear in all copies and
8 * that both that copyright notice and this permission notice appear
9 * in supporting documentation. Silicon Graphics makes no
10 * representations about the suitability of this software for any
11 * purpose. It is provided "as is" without express or implied warranty.
12 */
13
14 /* NOTE: This is an internal header file, included by other STL headers.
15 * You should not attempt to use it directly.
16 */
17
18 # include <stdio.h> /* XXX should use <cstdio> */
19 # include <iostream.h> /* XXX should use <iostream> */
20
21 __STL_BEGIN_NAMESPACE
22
23 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
24 #pragma set woff 1174
25 #endif
26
27 // Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
28 // if necessary. Assumes _M_path_end[leaf_index] and leaf_pos are correct.
29 // Results in a valid buf_ptr if the iterator can be legitimately
30 // dereferenced.
31 template <class _CharT, class _Alloc>
32 void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf(
33 _Rope_iterator_base<_CharT,_Alloc>& __x)
34 {
35 const _RopeRep* __leaf = __x._M_path_end[__x._M_leaf_index];
36 size_t __leaf_pos = __x._M_leaf_pos;
37 size_t __pos = __x._M_current_pos;
38
39 switch(__leaf->_M_tag) {
40 case _RopeRep::_S_leaf:
41 __x._M_buf_start =
42 ((_Rope_RopeLeaf<_CharT,_Alloc>*)__leaf)->_M_data;
43 __x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos);
44 __x._M_buf_end = __x._M_buf_start + __leaf->_M_size;
45 break;
46 case _RopeRep::_S_function:
47 case _RopeRep::_S_substringfn:
48 {
49 size_t __len = _S_iterator_buf_len;
50 size_t __buf_start_pos = __leaf_pos;
51 size_t __leaf_end = __leaf_pos + __leaf->_M_size;
52 char_producer<_CharT>* __fn =
53 ((_Rope_RopeFunction<_CharT,_Alloc>*)__leaf)->_M_fn;
54
55 if (__buf_start_pos + __len <= __pos) {
56 __buf_start_pos = __pos - __len/4;
57 if (__buf_start_pos + __len > __leaf_end) {
58 __buf_start_pos = __leaf_end - __len;
59 }
60 }
61 if (__buf_start_pos + __len > __leaf_end) {
62 __len = __leaf_end - __buf_start_pos;
63 }
64 (*__fn)(__buf_start_pos - __leaf_pos, __len, __x._M_tmp_buf);
65 __x._M_buf_ptr = __x._M_tmp_buf + (__pos - __buf_start_pos);
66 __x._M_buf_start = __x._M_tmp_buf;
67 __x._M_buf_end = __x._M_tmp_buf + __len;
68 }
69 break;
70 default:
71 __stl_assert(0);
72 }
73 }
74
75 // Set path and buffer inside a rope iterator. We assume that
76 // pos and root are already set.
77 template <class _CharT, class _Alloc>
78 void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache
79 (_Rope_iterator_base<_CharT,_Alloc>& __x)
80 {
81 const _RopeRep* __path[_RopeRep::_S_max_rope_depth+1];
82 const _RopeRep* __curr_rope;
83 int __curr_depth = -1; /* index into path */
84 size_t __curr_start_pos = 0;
85 size_t __pos = __x._M_current_pos;
86 unsigned char __dirns = 0; // Bit vector marking right turns in the path
87
88 __stl_assert(__pos <= __x._M_root->_M_size);
89 if (__pos >= __x._M_root->_M_size) {
90 __x._M_buf_ptr = 0;
91 return;
92 }
93 __curr_rope = __x._M_root;
94 if (0 != __curr_rope->_M_c_string) {
95 /* Treat the root as a leaf. */
96 __x._M_buf_start = __curr_rope->_M_c_string;
97 __x._M_buf_end = __curr_rope->_M_c_string + __curr_rope->_M_size;
98 __x._M_buf_ptr = __curr_rope->_M_c_string + __pos;
99 __x._M_path_end[0] = __curr_rope;
100 __x._M_leaf_index = 0;
101 __x._M_leaf_pos = 0;
102 return;
103 }
104 for(;;) {
105 ++__curr_depth;
106 __stl_assert(__curr_depth <= _RopeRep::_S_max_rope_depth);
107 __path[__curr_depth] = __curr_rope;
108 switch(__curr_rope->_M_tag) {
109 case _RopeRep::_S_leaf:
110 case _RopeRep::_S_function:
111 case _RopeRep::_S_substringfn:
112 __x._M_leaf_pos = __curr_start_pos;
113 goto done;
114 case _RopeRep::_S_concat:
115 {
116 _Rope_RopeConcatenation<_CharT,_Alloc>* __c =
117 (_Rope_RopeConcatenation<_CharT,_Alloc>*)__curr_rope;
118 _RopeRep* __left = __c->_M_left;
119 size_t __left_len = __left->_M_size;
120
121 __dirns <<= 1;
122 if (__pos >= __curr_start_pos + __left_len) {
123 __dirns |= 1;
124 __curr_rope = __c->_M_right;
125 __curr_start_pos += __left_len;
126 } else {
127 __curr_rope = __left;
128 }
129 }
130 break;
131 }
132 }
133 done:
134 // Copy last section of path into _M_path_end.
135 {
136 int __i = -1;
137 int __j = __curr_depth + 1 - _S_path_cache_len;
138
139 if (__j < 0) __j = 0;
140 while (__j <= __curr_depth) {
141 __x._M_path_end[++__i] = __path[__j++];
142 }
143 __x._M_leaf_index = __i;
144 }
145 __x._M_path_directions = __dirns;
146 _S_setbuf(__x);
147 }
148
149 // Specialized version of the above. Assumes that
150 // the path cache is valid for the previous position.
151 template <class _CharT, class _Alloc>
152 void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache_for_incr
153 (_Rope_iterator_base<_CharT,_Alloc>& __x)
154 {
155 int __current_index = __x._M_leaf_index;
156 const _RopeRep* __current_node = __x._M_path_end[__current_index];
157 size_t __len = __current_node->_M_size;
158 size_t __node_start_pos = __x._M_leaf_pos;
159 unsigned char __dirns = __x._M_path_directions;
160 _Rope_RopeConcatenation<_CharT,_Alloc>* __c;
161
162 __stl_assert(__x._M_current_pos <= __x._M_root->_M_size);
163 if (__x._M_current_pos - __node_start_pos < __len) {
164 /* More stuff in this leaf, we just didn't cache it. */
165 _S_setbuf(__x);
166 return;
167 }
168 __stl_assert(__node_start_pos + __len == __x._M_current_pos);
169 // node_start_pos is starting position of last_node.
170 while (--__current_index >= 0) {
171 if (!(__dirns & 1) /* Path turned left */)
172 break;
173 __current_node = __x._M_path_end[__current_index];
174 __c = (_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node;
175 // Otherwise we were in the right child. Thus we should pop
176 // the concatenation node.
177 __node_start_pos -= __c->_M_left->_M_size;
178 __dirns >>= 1;
179 }
180 if (__current_index < 0) {
181 // We underflowed the cache. Punt.
182 _S_setcache(__x);
183 return;
184 }
185 __current_node = __x._M_path_end[__current_index];
186 __c = (_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node;
187 // current_node is a concatenation node. We are positioned on the first
188 // character in its right child.
189 // node_start_pos is starting position of current_node.
190 __node_start_pos += __c->_M_left->_M_size;
191 __current_node = __c->_M_right;
192 __x._M_path_end[++__current_index] = __current_node;
193 __dirns |= 1;
194 while (_RopeRep::_S_concat == __current_node->_M_tag) {
195 ++__current_index;
196 if (_S_path_cache_len == __current_index) {
197 int __i;
198 for (__i = 0; __i < _S_path_cache_len-1; __i++) {
199 __x._M_path_end[__i] = __x._M_path_end[__i+1];
200 }
201 --__current_index;
202 }
203 __current_node =
204 ((_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node)->_M_left;
205 __x._M_path_end[__current_index] = __current_node;
206 __dirns <<= 1;
207 // node_start_pos is unchanged.
208 }
209 __x._M_leaf_index = __current_index;
210 __x._M_leaf_pos = __node_start_pos;
211 __x._M_path_directions = __dirns;
212 _S_setbuf(__x);
213 }
214
215 template <class _CharT, class _Alloc>
216 void _Rope_iterator_base<_CharT,_Alloc>::_M_incr(size_t __n) {
217 _M_current_pos += __n;
218 if (0 != _M_buf_ptr) {
219 size_t __chars_left = _M_buf_end - _M_buf_ptr;
220 if (__chars_left > __n) {
221 _M_buf_ptr += __n;
222 } else if (__chars_left == __n) {
223 _M_buf_ptr += __n;
224 _S_setcache_for_incr(*this);
225 } else {
226 _M_buf_ptr = 0;
227 }
228 }
229 }
230
231 template <class _CharT, class _Alloc>
232 void _Rope_iterator_base<_CharT,_Alloc>::_M_decr(size_t __n) {
233 if (0 != _M_buf_ptr) {
234 size_t __chars_left = _M_buf_ptr - _M_buf_start;
235 if (__chars_left >= __n) {
236 _M_buf_ptr -= __n;
237 } else {
238 _M_buf_ptr = 0;
239 }
240 }
241 _M_current_pos -= __n;
242 }
243
244 template <class _CharT, class _Alloc>
245 void _Rope_iterator<_CharT,_Alloc>::_M_check() {
246 if (_M_root_rope->_M_tree_ptr != _M_root) {
247 // _Rope was modified. Get things fixed up.
248 _RopeRep::_S_unref(_M_root);
249 _M_root = _M_root_rope->_M_tree_ptr;
250 _RopeRep::_S_ref(_M_root);
251 _M_buf_ptr = 0;
252 }
253 }
254
255 template <class _CharT, class _Alloc>
256 inline
257 _Rope_const_iterator<_CharT, _Alloc>::_Rope_const_iterator(
258 const _Rope_iterator<_CharT,_Alloc>& __x)
259 : _Rope_iterator_base<_CharT,_Alloc>(__x)
260 { }
261
262 template <class _CharT, class _Alloc>
263 inline _Rope_iterator<_CharT,_Alloc>::_Rope_iterator(
264 rope<_CharT,_Alloc>& __r, size_t __pos)
265 : _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos),
266 _M_root_rope(&__r)
267 {
268 _RopeRep::_S_ref(_M_root);
269 }
270
271 template <class _CharT, class _Alloc>
272 inline size_t
273 rope<_CharT,_Alloc>::_S_char_ptr_len(const _CharT* __s)
274 {
275 const _CharT* __p = __s;
276
277 while (!_S_is0(*__p)) { ++__p; }
278 return (__p - __s);
279 }
280
281
282 #ifndef __GC
283
284 template <class _CharT, class _Alloc>
285 inline void _Rope_RopeRep<_CharT,_Alloc>::_M_free_c_string()
286 {
287 _CharT* __cstr = _M_c_string;
288 if (0 != __cstr) {
289 size_t __size = _M_size + 1;
290 destroy(__cstr, __cstr + __size);
291 _Data_deallocate(__cstr, __size);
292 }
293 }
294
295
296 template <class _CharT, class _Alloc>
297 #ifdef __STL_USE_STD_ALLOCATORS
298 inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string(_CharT* __s,
299 size_t __n,
300 allocator_type __a)
301 #else
302 inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string(_CharT* __s,
303 size_t __n)
304 #endif
305 {
306 if (!_S_is_basic_char_type((_CharT*)0)) {
307 destroy(__s, __s + __n);
308 }
309 // This has to be a static member, so this gets a bit messy
310 # ifdef __STL_USE_STD_ALLOCATORS
311 __a.deallocate(
312 __s, _Rope_RopeLeaf<_CharT,_Alloc>::_S_rounded_up_size(__n));
313 # else
314 _Data_deallocate(
315 __s, _Rope_RopeLeaf<_CharT,_Alloc>::_S_rounded_up_size(__n));
316 # endif
317 }
318
319
320 // There are several reasons for not doing this with virtual destructors
321 // and a class specific delete operator:
322 // - A class specific delete operator can't easily get access to
323 // allocator instances if we need them.
324 // - Any virtual function would need a 4 or byte vtable pointer;
325 // this only requires a one byte tag per object.
326 template <class _CharT, class _Alloc>
327 void _Rope_RopeRep<_CharT,_Alloc>::_M_free_tree()
328 {
329 switch(_M_tag) {
330 case _S_leaf:
331 {
332 _Rope_RopeLeaf<_CharT,_Alloc>* __l
333 = (_Rope_RopeLeaf<_CharT,_Alloc>*)this;
334 __l->_Rope_RopeLeaf<_CharT,_Alloc>::~_Rope_RopeLeaf();
335 _L_deallocate(__l, 1);
336 break;
337 }
338 case _S_concat:
339 {
340 _Rope_RopeConcatenation<_CharT,_Alloc>* __c
341 = (_Rope_RopeConcatenation<_CharT,_Alloc>*)this;
342 __c->_Rope_RopeConcatenation<_CharT,_Alloc>::
343 ~_Rope_RopeConcatenation();
344 _C_deallocate(__c, 1);
345 break;
346 }
347 case _S_function:
348 {
349 _Rope_RopeFunction<_CharT,_Alloc>* __f
350 = (_Rope_RopeFunction<_CharT,_Alloc>*)this;
351 __f->_Rope_RopeFunction<_CharT,_Alloc>::~_Rope_RopeFunction();
352 _F_deallocate(__f, 1);
353 break;
354 }
355 case _S_substringfn:
356 {
357 _Rope_RopeSubstring<_CharT,_Alloc>* __ss =
358 (_Rope_RopeSubstring<_CharT,_Alloc>*)this;
359 __ss->_Rope_RopeSubstring<_CharT,_Alloc>::
360 ~_Rope_RopeSubstring();
361 _S_deallocate(__ss, 1);
362 break;
363 }
364 }
365 }
366 #else
367
368 template <class _CharT, class _Alloc>
369 #ifdef __STL_USE_STD_ALLOCATORS
370 inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string
371 (const _CharT*, size_t, allocator_type)
372 #else
373 inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string
374 (const _CharT*, size_t)
375 #endif
376 {}
377
378 #endif
379
380
381 // Concatenate a C string onto a leaf rope by copying the rope data.
382 // Used for short ropes.
383 template <class _CharT, class _Alloc>
384 rope<_CharT,_Alloc>::_RopeLeaf*
385 rope<_CharT,_Alloc>::_S_leaf_concat_char_iter
386 (_RopeLeaf* __r, const _CharT* __iter, size_t __len)
387 {
388 size_t __old_len = __r->_M_size;
389 _CharT* __new_data = (_CharT*)
390 _Data_allocate(_S_rounded_up_size(__old_len + __len));
391 _RopeLeaf* __result;
392
393 uninitialized_copy_n(__r->_M_data, __old_len, __new_data);
394 uninitialized_copy_n(__iter, __len, __new_data + __old_len);
395 _S_cond_store_eos(__new_data[__old_len + __len]);
396 __STL_TRY {
397 __result = _S_new_RopeLeaf(__new_data, __old_len + __len,
398 __r->get_allocator());
399 }
400 __STL_UNWIND(_RopeRep::__STL_FREE_STRING(__new_data, __old_len + __len,
401 __r->get_allocator()));
402 return __result;
403 }
404
405 #ifndef __GC
406 // As above, but it's OK to clobber original if refcount is 1
407 template <class _CharT, class _Alloc>
408 rope<_CharT,_Alloc>::_RopeLeaf*
409 rope<_CharT,_Alloc>::_S_destr_leaf_concat_char_iter
410 (_RopeLeaf* __r, const _CharT* __iter, size_t __len)
411 {
412 __stl_assert(__r->_M_refcount >= 1);
413 if (__r->_M_refcount > 1)
414 return _S_leaf_concat_char_iter(__r, __iter, __len);
415 size_t __old_len = __r->_M_size;
416 if (_S_allocated_capacity(__old_len) >= __old_len + __len) {
417 // The space has been partially initialized for the standard
418 // character types. But that doesn't matter for those types.
419 uninitialized_copy_n(__iter, __len, __r->_M_data + __old_len);
420 if (_S_is_basic_char_type((_CharT*)0)) {
421 _S_cond_store_eos(__r->_M_data[__old_len + __len]);
422 __stl_assert(__r->_M_c_string == __r->_M_data);
423 } else if (__r->_M_c_string != __r->_M_data && 0 != __r->_M_c_string) {
424 __r->_M_free_c_string();
425 __r->_M_c_string = 0;
426 }
427 __r->_M_size = __old_len + __len;
428 __stl_assert(__r->_M_refcount == 1);
429 __r->_M_refcount = 2;
430 return __r;
431 } else {
432 _RopeLeaf* __result = _S_leaf_concat_char_iter(__r, __iter, __len);
433 __stl_assert(__result->_M_refcount == 1);
434 return __result;
435 }
436 }
437 #endif
438
439 // Assumes left and right are not 0.
440 // Does not increment (nor decrement on exception) child reference counts.
441 // Result has ref count 1.
442 template <class _CharT, class _Alloc>
443 rope<_CharT,_Alloc>::_RopeRep*
444 rope<_CharT,_Alloc>::_S_tree_concat (_RopeRep* __left, _RopeRep* __right)
445 {
446 _RopeConcatenation* __result =
447 _S_new_RopeConcatenation(__left, __right, __left->get_allocator());
448 size_t __depth = __result->_M_depth;
449
450 # ifdef __STL_USE_STD_ALLOCATORS
451 __stl_assert(__left->get_allocator() == __right->get_allocator());
452 # endif
453 if (__depth > 20 && (__result->_M_size < 1000 ||
454 __depth > _RopeRep::_S_max_rope_depth)) {
455 _RopeRep* __balanced;
456
457 __STL_TRY {
458 __balanced = _S_balance(__result);
459 # ifndef __GC
460 if (__result != __balanced) {
461 __stl_assert(1 == __result->_M_refcount
462 && 1 == __balanced->_M_refcount);
463 }
464 # endif
465 __result->_M_unref_nonnil();
466 }
467 __STL_UNWIND((_C_deallocate(__result,1)));
468 // In case of exception, we need to deallocate
469 // otherwise dangling result node. But caller
470 // still owns its children. Thus unref is
471 // inappropriate.
472 return __balanced;
473 } else {
474 return __result;
475 }
476 }
477
478 template <class _CharT, class _Alloc>
479 rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_concat_char_iter
480 (_RopeRep* __r, const _CharT*__s, size_t __slen)
481 {
482 _RopeRep* __result;
483 if (0 == __slen) {
484 _S_ref(__r);
485 return __r;
486 }
487 if (0 == __r)
488 return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
489 __r->get_allocator());
490 if (_RopeRep::_S_leaf == __r->_M_tag &&
491 __r->_M_size + __slen <= _S_copy_max) {
492 __result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
493 # ifndef __GC
494 __stl_assert(1 == __result->_M_refcount);
495 # endif
496 return __result;
497 }
498 if (_RopeRep::_S_concat == __r->_M_tag
499 && _RopeRep::_S_leaf == ((_RopeConcatenation*)__r)->_M_right->_M_tag) {
500 _RopeLeaf* __right =
501 (_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right);
502 if (__right->_M_size + __slen <= _S_copy_max) {
503 _RopeRep* __left = ((_RopeConcatenation*)__r)->_M_left;
504 _RopeRep* __nright =
505 _S_leaf_concat_char_iter((_RopeLeaf*)__right, __s, __slen);
506 __left->_M_ref_nonnil();
507 __STL_TRY {
508 __result = _S_tree_concat(__left, __nright);
509 }
510 __STL_UNWIND(_S_unref(__left); _S_unref(__nright));
511 # ifndef __GC
512 __stl_assert(1 == __result->_M_refcount);
513 # endif
514 return __result;
515 }
516 }
517 _RopeRep* __nright =
518 __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
519 __STL_TRY {
520 __r->_M_ref_nonnil();
521 __result = _S_tree_concat(__r, __nright);
522 }
523 __STL_UNWIND(_S_unref(__r); _S_unref(__nright));
524 # ifndef __GC
525 __stl_assert(1 == __result->_M_refcount);
526 # endif
527 return __result;
528 }
529
530 #ifndef __GC
531 template <class _CharT, class _Alloc>
532 rope<_CharT,_Alloc>::_RopeRep*
533 rope<_CharT,_Alloc>::_S_destr_concat_char_iter(
534 _RopeRep* __r, const _CharT* __s, size_t __slen)
535 {
536 _RopeRep* __result;
537 if (0 == __r)
538 return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
539 __r->get_allocator());
540 size_t __count = __r->_M_refcount;
541 size_t __orig_size = __r->_M_size;
542 __stl_assert(__count >= 1);
543 if (__count > 1) return _S_concat_char_iter(__r, __s, __slen);
544 if (0 == __slen) {
545 __r->_M_refcount = 2; // One more than before
546 return __r;
547 }
548 if (__orig_size + __slen <= _S_copy_max &&
549 _RopeRep::_S_leaf == __r->_M_tag) {
550 __result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
551 return __result;
552 }
553 if (_RopeRep::_S_concat == __r->_M_tag) {
554 _RopeLeaf* __right = (_RopeLeaf*)(((_RopeConcatenation*)__r)->_M_right);
555 if (_RopeRep::_S_leaf == __right->_M_tag
556 && __right->_M_size + __slen <= _S_copy_max) {
557 _RopeRep* __new_right =
558 _S_destr_leaf_concat_char_iter(__right, __s, __slen);
559 if (__right == __new_right) {
560 __stl_assert(__new_right->_M_refcount == 2);
561 __new_right->_M_refcount = 1;
562 } else {
563 __stl_assert(__new_right->_M_refcount >= 1);
564 __right->_M_unref_nonnil();
565 }
566 __stl_assert(__r->_M_refcount == 1);
567 __r->_M_refcount = 2; // One more than before.
568 ((_RopeConcatenation*)__r)->_M_right = __new_right;
569 __r->_M_size = __orig_size + __slen;
570 if (0 != __r->_M_c_string) {
571 __r->_M_free_c_string();
572 __r->_M_c_string = 0;
573 }
574 return __r;
575 }
576 }
577 _RopeRep* __right =
578 __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
579 __r->_M_ref_nonnil();
580 __STL_TRY {
581 __result = _S_tree_concat(__r, __right);
582 }
583 __STL_UNWIND(_S_unref(__r); _S_unref(__right))
584 __stl_assert(1 == __result->_M_refcount);
585 return __result;
586 }
587 #endif /* !__GC */
588
589 template <class _CharT, class _Alloc>
590 rope<_CharT,_Alloc>::_RopeRep*
591 rope<_CharT,_Alloc>::_S_concat(_RopeRep* __left, _RopeRep* __right)
592 {
593 if (0 == __left) {
594 _S_ref(__right);
595 return __right;
596 }
597 if (0 == __right) {
598 __left->_M_ref_nonnil();
599 return __left;
600 }
601 if (_RopeRep::_S_leaf == __right->_M_tag) {
602 if (_RopeRep::_S_leaf == __left->_M_tag) {
603 if (__right->_M_size + __left->_M_size <= _S_copy_max) {
604 return _S_leaf_concat_char_iter((_RopeLeaf*)__left,
605 ((_RopeLeaf*)__right)->_M_data,
606 __right->_M_size);
607 }
608 } else if (_RopeRep::_S_concat == __left->_M_tag
609 && _RopeRep::_S_leaf ==
610 ((_RopeConcatenation*)__left)->_M_right->_M_tag) {
611 _RopeLeaf* __leftright =
612 (_RopeLeaf*)(((_RopeConcatenation*)__left)->_M_right);
613 if (__leftright->_M_size + __right->_M_size <= _S_copy_max) {
614 _RopeRep* __leftleft = ((_RopeConcatenation*)__left)->_M_left;
615 _RopeRep* __rest = _S_leaf_concat_char_iter(__leftright,
616 ((_RopeLeaf*)__right)->_M_data,
617 __right->_M_size);
618 __leftleft->_M_ref_nonnil();
619 __STL_TRY {
620 return(_S_tree_concat(__leftleft, __rest));
621 }
622 __STL_UNWIND(_S_unref(__leftleft); _S_unref(__rest))
623 }
624 }
625 }
626 __left->_M_ref_nonnil();
627 __right->_M_ref_nonnil();
628 __STL_TRY {
629 return(_S_tree_concat(__left, __right));
630 }
631 __STL_UNWIND(_S_unref(__left); _S_unref(__right));
632 }
633
634 template <class _CharT, class _Alloc>
635 rope<_CharT,_Alloc>::_RopeRep*
636 rope<_CharT,_Alloc>::_S_substring(_RopeRep* __base,
637 size_t __start, size_t __endp1)
638 {
639 if (0 == __base) return 0;
640 size_t __len = __base->_M_size;
641 size_t __adj_endp1;
642 const size_t __lazy_threshold = 128;
643
644 if (__endp1 >= __len) {
645 if (0 == __start) {
646 __base->_M_ref_nonnil();
647 return __base;
648 } else {
649 __adj_endp1 = __len;
650 }
651 } else {
652 __adj_endp1 = __endp1;
653 }
654 switch(__base->_M_tag) {
655 case _RopeRep::_S_concat:
656 {
657 _RopeConcatenation* __c = (_RopeConcatenation*)__base;
658 _RopeRep* __left = __c->_M_left;
659 _RopeRep* __right = __c->_M_right;
660 size_t __left_len = __left->_M_size;
661 _RopeRep* __result;
662
663 if (__adj_endp1 <= __left_len) {
664 return _S_substring(__left, __start, __endp1);
665 } else if (__start >= __left_len) {
666 return _S_substring(__right, __start - __left_len,
667 __adj_endp1 - __left_len);
668 }
669 _Self_destruct_ptr __left_result(
670 _S_substring(__left, __start, __left_len));
671 _Self_destruct_ptr __right_result(
672 _S_substring(__right, 0, __endp1 - __left_len));
673 __result = _S_concat(__left_result, __right_result);
674 # ifndef __GC
675 __stl_assert(1 == __result->_M_refcount);
676 # endif
677 return __result;
678 }
679 case _RopeRep::_S_leaf:
680 {
681 _RopeLeaf* __l = (_RopeLeaf*)__base;
682 _RopeLeaf* __result;
683 size_t __result_len;
684 if (__start >= __adj_endp1) return 0;
685 __result_len = __adj_endp1 - __start;
686 if (__result_len > __lazy_threshold) goto lazy;
687 # ifdef __GC
688 const _CharT* __section = __l->_M_data + __start;
689 __result = _S_new_RopeLeaf(__section, __result_len,
690 __base->get_allocator());
691 __result->_M_c_string = 0; // Not eos terminated.
692 # else
693 // We should sometimes create substring node instead.
694 __result = __STL_ROPE_FROM_UNOWNED_CHAR_PTR(
695 __l->_M_data + __start, __result_len,
696 __base->get_allocator());
697 # endif
698 return __result;
699 }
700 case _RopeRep::_S_substringfn:
701 // Avoid introducing multiple layers of substring nodes.
702 {
703 _RopeSubstring* __old = (_RopeSubstring*)__base;
704 size_t __result_len;
705 if (__start >= __adj_endp1) return 0;
706 __result_len = __adj_endp1 - __start;
707 if (__result_len > __lazy_threshold) {
708 _RopeSubstring* __result =
709 _S_new_RopeSubstring(__old->_M_base,
710 __start + __old->_M_start,
711 __adj_endp1 - __start,
712 __base->get_allocator());
713 return __result;
714
715 } // *** else fall through: ***
716 }
717 case _RopeRep::_S_function:
718 {
719 _RopeFunction* __f = (_RopeFunction*)__base;
720 _CharT* __section;
721 size_t __result_len;
722 if (__start >= __adj_endp1) return 0;
723 __result_len = __adj_endp1 - __start;
724
725 if (__result_len > __lazy_threshold) goto lazy;
726 __section = (_CharT*)
727 _Data_allocate(_S_rounded_up_size(__result_len));
728 __STL_TRY {
729 (*(__f->_M_fn))(__start, __result_len, __section);
730 }
731 __STL_UNWIND(_RopeRep::__STL_FREE_STRING(
732 __section, __result_len, __base->get_allocator()));
733 _S_cond_store_eos(__section[__result_len]);
734 return _S_new_RopeLeaf(__section, __result_len,
735 __base->get_allocator());
736 }
737 }
738 /*NOTREACHED*/
739 __stl_assert(false);
740 lazy:
741 {
742 // Create substring node.
743 return _S_new_RopeSubstring(__base, __start, __adj_endp1 - __start,
744 __base->get_allocator());
745 }
746 }
747
748 template<class _CharT>
749 class _Rope_flatten_char_consumer : public _Rope_char_consumer<_CharT> {
750 private:
751 _CharT* _M_buf_ptr;
752 public:
753 // _CharT* _M_buffer; // XXX not used
754
755 _Rope_flatten_char_consumer(_CharT* __buffer) {
756 _M_buf_ptr = __buffer;
757 };
758 ~_Rope_flatten_char_consumer() {}
759 bool operator() (const _CharT* __leaf, size_t __n) {
760 uninitialized_copy_n(__leaf, __n, _M_buf_ptr);
761 _M_buf_ptr += __n;
762 return true;
763 }
764 };
765
766 template<class _CharT>
767 class _Rope_find_char_char_consumer : public _Rope_char_consumer<_CharT> {
768 private:
769 _CharT _M_pattern;
770 public:
771 size_t _M_count; // Number of nonmatching characters
772 _Rope_find_char_char_consumer(_CharT __p)
773 : _M_pattern(__p), _M_count(0) {}
774 ~_Rope_find_char_char_consumer() {}
775 bool operator() (const _CharT* __leaf, size_t __n) {
776 size_t __i;
777 for (__i = 0; __i < __n; __i++) {
778 if (__leaf[__i] == _M_pattern) {
779 _M_count += __i; return false;
780 }
781 }
782 _M_count += __n; return true;
783 }
784 };
785
786 template<class _CharT>
787 class _Rope_insert_char_consumer : public _Rope_char_consumer<_CharT> {
788 private:
789 typedef ostream _Insert_ostream;
790 _Insert_ostream& _M_o;
791 public:
792 // _CharT* buffer; // XXX not used
793 _Rope_insert_char_consumer(_Insert_ostream& __writer)
794 : _M_o(__writer) {};
795 ~_Rope_insert_char_consumer() { };
796 // Caller is presumed to own the ostream
797 bool operator() (const _CharT* __leaf, size_t __n);
798 // Returns true to continue traversal.
799 };
800
801 template<class _CharT>
802 bool _Rope_insert_char_consumer<_CharT>::operator()
803 (const _CharT* __leaf, size_t __n)
804 {
805 size_t __i;
806 // We assume that formatting is set up correctly for each element.
807 for (__i = 0; __i < __n; __i++) _M_o << __leaf[__i];
808 return true;
809 }
810
811 inline bool _Rope_insert_char_consumer<char>::operator()
812 (const char* __leaf, size_t __n)
813 {
814 size_t __i;
815 for (__i = 0; __i < __n; __i++) _M_o.put(__leaf[__i]);
816 return true;
817 }
818
819 #if 0
820 // I couldn't get this to work work with the VC++ version of basic_ostream.
821 // It also doesn't really do the right thing unless o is a wide stream.
822 // Given that wchar_t is often 4 bytes, its not clear to me how useful
823 // this stuff is anyway.
824 inline bool _Rope_insert_char_consumer<wchar_t>::operator()
825 (const wchar_t* __leaf, size_t __n)
826 {
827 size_t __i;
828 for (__i = 0; __i < __n; __i++) _M_o.put(__leaf[__i]);
829 return true;
830 }
831 #endif /* !_MSC_VER && !BORLAND */
832
833 template <class _CharT, class _Alloc>
834 bool rope<_CharT, _Alloc>::_S_apply_to_pieces(
835 _Rope_char_consumer<_CharT>& __c,
836 const _RopeRep* __r,
837 size_t __begin, size_t __end)
838 {
839 if (0 == __r) return true;
840 switch(__r->_M_tag) {
841 case _RopeRep::_S_concat:
842 {
843 _RopeConcatenation* __conc = (_RopeConcatenation*)__r;
844 _RopeRep* __left = __conc->_M_left;
845 size_t __left_len = __left->_M_size;
846 if (__begin < __left_len) {
847 size_t __left_end = min(__left_len, __end);
848 if (!_S_apply_to_pieces(__c, __left, __begin, __left_end))
849 return false;
850 }
851 if (__end > __left_len) {
852 _RopeRep* __right = __conc->_M_right;
853 size_t __right_start = max(__left_len, __begin);
854 if (!_S_apply_to_pieces(__c, __right,
855 __right_start - __left_len,
856 __end - __left_len)) {
857 return false;
858 }
859 }
860 }
861 return true;
862 case _RopeRep::_S_leaf:
863 {
864 _RopeLeaf* __l = (_RopeLeaf*)__r;
865 return __c(__l->_M_data + __begin, __end - __begin);
866 }
867 case _RopeRep::_S_function:
868 case _RopeRep::_S_substringfn:
869 {
870 _RopeFunction* __f = (_RopeFunction*)__r;
871 size_t __len = __end - __begin;
872 bool __result;
873 _CharT* __buffer =
874 (_CharT*)alloc::allocate(__len * sizeof(_CharT));
875 __STL_TRY {
876 (*(__f->_M_fn))(__begin, __end, __buffer);
877 __result = __c(__buffer, __len);
878 alloc::deallocate(__buffer, __len * sizeof(_CharT));
879 }
880 __STL_UNWIND((alloc::deallocate(__buffer,
881 __len * sizeof(_CharT))))
882 return __result;
883 }
884 default:
885 __stl_assert(false);
886 /*NOTREACHED*/
887 return false;
888 }
889 }
890
891 inline void _Rope_fill(ostream& __o, size_t __n)
892 {
893 char __f = __o.fill();
894 size_t __i;
895
896 for (__i = 0; __i < __n; __i++) __o.put(__f);
897 }
898
899
900 template <class _CharT> inline bool _Rope_is_simple(_CharT*) { return false; }
901 inline bool _Rope_is_simple(char*) { return true; }
902 inline bool _Rope_is_simple(wchar_t*) { return true; }
903
904
905 template<class _CharT, class _Alloc>
906 ostream& operator<< (ostream& __o, const rope<_CharT, _Alloc>& __r)
907 {
908 size_t __w = __o.width();
909 bool __left = bool(__o.flags() & ios::left);
910 size_t __pad_len;
911 size_t __rope_len = __r.size();
912 _Rope_insert_char_consumer<_CharT> __c(__o);
913 bool __is_simple = _Rope_is_simple((_CharT*)0);
914
915 if (__rope_len < __w) {
916 __pad_len = __w - __rope_len;
917 } else {
918 __pad_len = 0;
919 }
920 if (!__is_simple) __o.width(__w/__rope_len);
921 __STL_TRY {
922 if (__is_simple && !__left && __pad_len > 0) {
923 _Rope_fill(__o, __pad_len);
924 }
925 __r.apply_to_pieces(0, __r.size(), __c);
926 if (__is_simple && __left && __pad_len > 0) {
927 _Rope_fill(__o, __pad_len);
928 }
929 if (!__is_simple)
930 __o.width(__w);
931 }
932 __STL_UNWIND(if (!__is_simple) __o.width(__w))
933 return __o;
934 }
935
936 template <class _CharT, class _Alloc>
937 _CharT*
938 rope<_CharT,_Alloc>::_S_flatten(_RopeRep* __r,
939 size_t __start, size_t __len,
940 _CharT* __buffer)
941 {
942 _Rope_flatten_char_consumer<_CharT> __c(__buffer);
943 _S_apply_to_pieces(__c, __r, __start, __start + __len);
944 return(__buffer + __len);
945 }
946
947 template <class _CharT, class _Alloc>
948 size_t
949 rope<_CharT,_Alloc>::find(_CharT __pattern, size_t __start) const
950 {
951 _Rope_find_char_char_consumer<_CharT> __c(__pattern);
952 _S_apply_to_pieces(__c, _M_tree_ptr, __start, size());
953 size_type __result_pos = __start + __c._M_count;
954 # ifndef __STL_OLD_ROPE_SEMANTICS
955 if (__result_pos == size()) __result_pos = npos;
956 # endif
957 return __result_pos;
958 }
959
960 template <class _CharT, class _Alloc>
961 _CharT*
962 rope<_CharT,_Alloc>::_S_flatten(_RopeRep* __r, _CharT* __buffer)
963 {
964 if (0 == __r) return __buffer;
965 switch(__r->_M_tag) {
966 case _RopeRep::_S_concat:
967 {
968 _RopeConcatenation* __c = (_RopeConcatenation*)__r;
969 _RopeRep* __left = __c->_M_left;
970 _RopeRep* __right = __c->_M_right;
971 _CharT* __rest = _S_flatten(__left, __buffer);
972 return _S_flatten(__right, __rest);
973 }
974 case _RopeRep::_S_leaf:
975 {
976 _RopeLeaf* __l = (_RopeLeaf*)__r;
977 return copy_n(__l->_M_data, __l->_M_size, __buffer).second;
978 }
979 case _RopeRep::_S_function:
980 case _RopeRep::_S_substringfn:
981 // We dont yet do anything with substring nodes.
982 // This needs to be fixed before ropefiles will work well.
983 {
984 _RopeFunction* __f = (_RopeFunction*)__r;
985 (*(__f->_M_fn))(0, __f->_M_size, __buffer);
986 return __buffer + __f->_M_size;
987 }
988 default:
989 __stl_assert(false);
990 /*NOTREACHED*/
991 return 0;
992 }
993 }
994
995
996 // This needs work for _CharT != char
997 template <class _CharT, class _Alloc>
998 void
999 rope<_CharT,_Alloc>::_S_dump(_RopeRep* __r, int __indent)
1000 {
1001 for (int __i = 0; __i < __indent; __i++) putchar(' ');
1002 if (0 == __r) {
1003 printf("NULL\n"); return;
1004 }
1005 if (_RopeRep::_S_concat == __r->_M_tag) {
1006 _RopeConcatenation* __c = (_RopeConcatenation*)__r;
1007 _RopeRep* __left = __c->_M_left;
1008 _RopeRep* __right = __c->_M_right;
1009
1010 # ifdef __GC
1011 printf("Concatenation %p (depth = %d, len = %ld, %s balanced)\n",
1012 __r, __r->_M_depth, __r->_M_size, __r->_M_is_balanced? "" : "not");
1013 # else
1014 printf("Concatenation %p (rc = %ld, depth = %d, "
1015 "len = %ld, %s balanced)\n",
1016 __r, __r->_M_refcount, __r->_M_depth, __r->_M_size,
1017 __r->_M_is_balanced? "" : "not");
1018 # endif
1019 _S_dump(__left, __indent + 2);
1020 _S_dump(__right, __indent + 2);
1021 return;
1022 } else {
1023 char* __kind;
1024
1025 switch (__r->_M_tag) {
1026 case _RopeRep::_S_leaf:
1027 __kind = "Leaf";
1028 break;
1029 case _RopeRep::_S_function:
1030 __kind = "Function";
1031 break;
1032 case _RopeRep::_S_substringfn:
1033 __kind = "Function representing substring";
1034 break;
1035 default:
1036 __kind = "(corrupted kind field!)";
1037 }
1038 # ifdef __GC
1039 printf("%s %p (depth = %d, len = %ld) ",
1040 __kind, __r, __r->_M_depth, __r->_M_size);
1041 # else
1042 printf("%s %p (rc = %ld, depth = %d, len = %ld) ",
1043 __kind, __r, __r->_M_refcount, __r->_M_depth, __r->_M_size);
1044 # endif
1045 if (_S_is_one_byte_char_type((_CharT*)0)) {
1046 const int __max_len = 40;
1047 _Self_destruct_ptr __prefix(_S_substring(__r, 0, __max_len));
1048 _CharT __buffer[__max_len + 1];
1049 bool __too_big = __r->_M_size > __prefix->_M_size;
1050
1051 _S_flatten(__prefix, __buffer);
1052 __buffer[__prefix->_M_size] = _S_eos((_CharT*)0);
1053 printf("%s%s\n",
1054 (char*)__buffer, __too_big? "...\n" : "\n");
1055 } else {
1056 printf("\n");
1057 }
1058 }
1059 }
1060
1061 template <class _CharT, class _Alloc>
1062 const unsigned long
1063 rope<_CharT,_Alloc>::_S_min_len[
1064 _Rope_RopeRep<_CharT,_Alloc>::_S_max_rope_depth + 1] = {
1065 /* 0 */1, /* 1 */2, /* 2 */3, /* 3 */5, /* 4 */8, /* 5 */13, /* 6 */21,
1066 /* 7 */34, /* 8 */55, /* 9 */89, /* 10 */144, /* 11 */233, /* 12 */377,
1067 /* 13 */610, /* 14 */987, /* 15 */1597, /* 16 */2584, /* 17 */4181,
1068 /* 18 */6765, /* 19 */10946, /* 20 */17711, /* 21 */28657, /* 22 */46368,
1069 /* 23 */75025, /* 24 */121393, /* 25 */196418, /* 26 */317811,
1070 /* 27 */514229, /* 28 */832040, /* 29 */1346269, /* 30 */2178309,
1071 /* 31 */3524578, /* 32 */5702887, /* 33 */9227465, /* 34 */14930352,
1072 /* 35 */24157817, /* 36 */39088169, /* 37 */63245986, /* 38 */102334155,
1073 /* 39 */165580141, /* 40 */267914296, /* 41 */433494437,
1074 /* 42 */701408733, /* 43 */1134903170, /* 44 */1836311903,
1075 /* 45 */2971215073u };
1076 // These are Fibonacci numbers < 2**32.
1077
1078 template <class _CharT, class _Alloc>
1079 rope<_CharT,_Alloc>::_RopeRep*
1080 rope<_CharT,_Alloc>::_S_balance(_RopeRep* __r)
1081 {
1082 _RopeRep* __forest[_RopeRep::_S_max_rope_depth + 1];
1083 _RopeRep* __result = 0;
1084 int __i;
1085 // Invariant:
1086 // The concatenation of forest in descending order is equal to __r.
1087 // __forest[__i]._M_size >= _S_min_len[__i]
1088 // __forest[__i]._M_depth = __i
1089 // References from forest are included in refcount.
1090
1091 for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i)
1092 __forest[__i] = 0;
1093 __STL_TRY {
1094 _S_add_to_forest(__r, __forest);
1095 for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i)
1096 if (0 != __forest[__i]) {
1097 # ifndef __GC
1098 _Self_destruct_ptr __old(__result);
1099 # endif
1100 __result = _S_concat(__forest[__i], __result);
1101 __forest[__i]->_M_unref_nonnil();
1102 # if !defined(__GC) && defined(__STL_USE_EXCEPTIONS)
1103 __forest[__i] = 0;
1104 # endif
1105 }
1106 }
1107 __STL_UNWIND(for(__i = 0; __i <= _RopeRep::_S_max_rope_depth; __i++)
1108 _S_unref(__forest[__i]))
1109 if (__result->_M_depth > _RopeRep::_S_max_rope_depth) abort();
1110 return(__result);
1111 }
1112
1113
1114 template <class _CharT, class _Alloc>
1115 void
1116 rope<_CharT,_Alloc>::_S_add_to_forest(_RopeRep* __r, _RopeRep** __forest)
1117 {
1118 if (__r->_M_is_balanced) {
1119 _S_add_leaf_to_forest(__r, __forest);
1120 return;
1121 }
1122 __stl_assert(__r->_M_tag == _RopeRep::_S_concat);
1123 {
1124 _RopeConcatenation* __c = (_RopeConcatenation*)__r;
1125
1126 _S_add_to_forest(__c->_M_left, __forest);
1127 _S_add_to_forest(__c->_M_right, __forest);
1128 }
1129 }
1130
1131
1132 template <class _CharT, class _Alloc>
1133 void
1134 rope<_CharT,_Alloc>::_S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest)
1135 {
1136 _RopeRep* __insertee; // included in refcount
1137 _RopeRep* __too_tiny = 0; // included in refcount
1138 int __i; // forest[0..__i-1] is empty
1139 size_t __s = __r->_M_size;
1140
1141 for (__i = 0; __s >= _S_min_len[__i+1]/* not this bucket */; ++__i) {
1142 if (0 != __forest[__i]) {
1143 # ifndef __GC
1144 _Self_destruct_ptr __old(__too_tiny);
1145 # endif
1146 __too_tiny = _S_concat_and_set_balanced(__forest[__i], __too_tiny);
1147 __forest[__i]->_M_unref_nonnil();
1148 __forest[__i] = 0;
1149 }
1150 }
1151 {
1152 # ifndef __GC
1153 _Self_destruct_ptr __old(__too_tiny);
1154 # endif
1155 __insertee = _S_concat_and_set_balanced(__too_tiny, __r);
1156 }
1157 // Too_tiny dead, and no longer included in refcount.
1158 // Insertee is live and included.
1159 __stl_assert(_S_is_almost_balanced(__insertee));
1160 __stl_assert(__insertee->_M_depth <= __r->_M_depth + 1);
1161 for (;; ++__i) {
1162 if (0 != __forest[__i]) {
1163 # ifndef __GC
1164 _Self_destruct_ptr __old(__insertee);
1165 # endif
1166 __insertee = _S_concat_and_set_balanced(__forest[__i], __insertee);
1167 __forest[__i]->_M_unref_nonnil();
1168 __forest[__i] = 0;
1169 __stl_assert(_S_is_almost_balanced(__insertee));
1170 }
1171 __stl_assert(_S_min_len[__i] <= __insertee->_M_size);
1172 __stl_assert(__forest[__i] == 0);
1173 if (__i == _RopeRep::_S_max_rope_depth ||
1174 __insertee->_M_size < _S_min_len[__i+1]) {
1175 __forest[__i] = __insertee;
1176 // refcount is OK since __insertee is now dead.
1177 return;
1178 }
1179 }
1180 }
1181
1182 template <class _CharT, class _Alloc>
1183 _CharT
1184 rope<_CharT,_Alloc>::_S_fetch(_RopeRep* __r, size_type __i)
1185 {
1186 __GC_CONST _CharT* __cstr = __r->_M_c_string;
1187
1188 __stl_assert(__i < __r->_M_size);
1189 if (0 != __cstr) return __cstr[__i];
1190 for(;;) {
1191 switch(__r->_M_tag) {
1192 case _RopeRep::_S_concat:
1193 {
1194 _RopeConcatenation* __c = (_RopeConcatenation*)__r;
1195 _RopeRep* __left = __c->_M_left;
1196 size_t __left_len = __left->_M_size;
1197
1198 if (__i >= __left_len) {
1199 __i -= __left_len;
1200 __r = __c->_M_right;
1201 } else {
1202 __r = __left;
1203 }
1204 }
1205 break;
1206 case _RopeRep::_S_leaf:
1207 {
1208 _RopeLeaf* __l = (_RopeLeaf*)__r;
1209 return __l->_M_data[__i];
1210 }
1211 case _RopeRep::_S_function:
1212 case _RopeRep::_S_substringfn:
1213 {
1214 _RopeFunction* __f = (_RopeFunction*)__r;
1215 _CharT __result;
1216
1217 (*(__f->_M_fn))(__i, 1, &__result);
1218 return __result;
1219 }
1220 }
1221 }
1222 }
1223
1224 # ifndef __GC
1225 // Return a uniquely referenced character slot for the given
1226 // position, or 0 if that's not possible.
1227 template <class _CharT, class _Alloc>
1228 _CharT*
1229 rope<_CharT,_Alloc>::_S_fetch_ptr(_RopeRep* __r, size_type __i)
1230 {
1231 _RopeRep* __clrstack[_RopeRep::_S_max_rope_depth];
1232 size_t __csptr = 0;
1233
1234 for(;;) {
1235 if (__r->_M_refcount > 1) return 0;
1236 switch(__r->_M_tag) {
1237 case _RopeRep::_S_concat:
1238 {
1239 _RopeConcatenation* __c = (_RopeConcatenation*)__r;
1240 _RopeRep* __left = __c->_M_left;
1241 size_t __left_len = __left->_M_size;
1242
1243 if (__c->_M_c_string != 0) __clrstack[__csptr++] = __c;
1244 if (__i >= __left_len) {
1245 __i -= __left_len;
1246 __r = __c->_M_right;
1247 } else {
1248 __r = __left;
1249 }
1250 }
1251 break;
1252 case _RopeRep::_S_leaf:
1253 {
1254 _RopeLeaf* __l = (_RopeLeaf*)__r;
1255 if (__l->_M_c_string != __l->_M_data && __l->_M_c_string != 0)
1256 __clrstack[__csptr++] = __l;
1257 while (__csptr > 0) {
1258 -- __csptr;
1259 _RopeRep* __d = __clrstack[__csptr];
1260 __d->_M_free_c_string();
1261 __d->_M_c_string = 0;
1262 }
1263 return __l->_M_data + __i;
1264 }
1265 case _RopeRep::_S_function:
1266 case _RopeRep::_S_substringfn:
1267 return 0;
1268 }
1269 }
1270 }
1271 # endif /* __GC */
1272
1273 // The following could be implemented trivially using
1274 // lexicographical_compare_3way.
1275 // We do a little more work to avoid dealing with rope iterators for
1276 // flat strings.
1277 template <class _CharT, class _Alloc>
1278 int
1279 rope<_CharT,_Alloc>::_S_compare (const _RopeRep* __left,
1280 const _RopeRep* __right)
1281 {
1282 size_t __left_len;
1283 size_t __right_len;
1284
1285 if (0 == __right) return 0 != __left;
1286 if (0 == __left) return -1;
1287 __left_len = __left->_M_size;
1288 __right_len = __right->_M_size;
1289 if (_RopeRep::_S_leaf == __left->_M_tag) {
1290 _RopeLeaf* __l = (_RopeLeaf*) __left;
1291 if (_RopeRep::_S_leaf == __right->_M_tag) {
1292 _RopeLeaf* __r = (_RopeLeaf*) __right;
1293 return lexicographical_compare_3way(
1294 __l->_M_data, __l->_M_data + __left_len,
1295 __r->_M_data, __r->_M_data + __right_len);
1296 } else {
1297 const_iterator __rstart(__right, 0);
1298 const_iterator __rend(__right, __right_len);
1299 return lexicographical_compare_3way(
1300 __l->_M_data, __l->_M_data + __left_len,
1301 __rstart, __rend);
1302 }
1303 } else {
1304 const_iterator __lstart(__left, 0);
1305 const_iterator __lend(__left, __left_len);
1306 if (_RopeRep::_S_leaf == __right->_M_tag) {
1307 _RopeLeaf* __r = (_RopeLeaf*) __right;
1308 return lexicographical_compare_3way(
1309 __lstart, __lend,
1310 __r->_M_data, __r->_M_data + __right_len);
1311 } else {
1312 const_iterator __rstart(__right, 0);
1313 const_iterator __rend(__right, __right_len);
1314 return lexicographical_compare_3way(
1315 __lstart, __lend,
1316 __rstart, __rend);
1317 }
1318 }
1319 }
1320
1321 // Assignment to reference proxies.
1322 template <class _CharT, class _Alloc>
1323 _Rope_char_ref_proxy<_CharT, _Alloc>&
1324 _Rope_char_ref_proxy<_CharT, _Alloc>::operator= (_CharT __c) {
1325 _RopeRep* __old = _M_root->_M_tree_ptr;
1326 # ifndef __GC
1327 // First check for the case in which everything is uniquely
1328 // referenced. In that case we can do this destructively.
1329 _CharT* __ptr = _My_rope::_S_fetch_ptr(__old, _M_pos);
1330 if (0 != __ptr) {
1331 *__ptr = __c;
1332 return *this;
1333 }
1334 # endif
1335 _Self_destruct_ptr __left(
1336 _My_rope::_S_substring(__old, 0, _M_pos));
1337 _Self_destruct_ptr __right(
1338 _My_rope::_S_substring(__old, _M_pos+1, __old->_M_size));
1339 _Self_destruct_ptr __result_left(
1340 _My_rope::_S_destr_concat_char_iter(__left, &__c, 1));
1341
1342 # ifndef __GC
1343 __stl_assert(__left == __result_left || 1 == __result_left->_M_refcount);
1344 # endif
1345 _RopeRep* __result =
1346 _My_rope::_S_concat(__result_left, __right);
1347 # ifndef __GC
1348 __stl_assert(1 <= __result->_M_refcount);
1349 _RopeRep::_S_unref(__old);
1350 # endif
1351 _M_root->_M_tree_ptr = __result;
1352 return *this;
1353 }
1354
1355 template <class _CharT, class _Alloc>
1356 inline _Rope_char_ref_proxy<_CharT, _Alloc>::operator _CharT () const
1357 {
1358 if (_M_current_valid) {
1359 return _M_current;
1360 } else {
1361 return _My_rope::_S_fetch(_M_root->_M_tree_ptr, _M_pos);
1362 }
1363 }
1364 template <class _CharT, class _Alloc>
1365 _Rope_char_ptr_proxy<_CharT, _Alloc>
1366 _Rope_char_ref_proxy<_CharT, _Alloc>::operator& () const {
1367 return _Rope_char_ptr_proxy<_CharT, _Alloc>(*this);
1368 }
1369
1370 template <class _CharT, class _Alloc>
1371 rope<_CharT, _Alloc>::rope(size_t __n, _CharT __c,
1372 const allocator_type& __a)
1373 : _Base(__a)
1374 {
1375 rope<_CharT,_Alloc> __result;
1376 const size_t __exponentiate_threshold = 32;
1377 size_t __exponent;
1378 size_t __rest;
1379 _CharT* __rest_buffer;
1380 _RopeRep* __remainder;
1381 rope<_CharT,_Alloc> __remainder_rope;
1382
1383 if (0 == __n)
1384 return;
1385
1386 __exponent = __n / __exponentiate_threshold;
1387 __rest = __n % __exponentiate_threshold;
1388 if (0 == __rest) {
1389 __remainder = 0;
1390 } else {
1391 __rest_buffer = _Data_allocate(_S_rounded_up_size(__rest));
1392 uninitialized_fill_n(__rest_buffer, __rest, __c);
1393 _S_cond_store_eos(__rest_buffer[__rest]);
1394 __STL_TRY {
1395 __remainder = _S_new_RopeLeaf(__rest_buffer, __rest, __a);
1396 }
1397 __STL_UNWIND(_RopeRep::__STL_FREE_STRING(__rest_buffer, __rest, __a))
1398 }
1399 __remainder_rope._M_tree_ptr = __remainder;
1400 if (__exponent != 0) {
1401 _CharT* __base_buffer =
1402 _Data_allocate(_S_rounded_up_size(__exponentiate_threshold));
1403 _RopeLeaf* __base_leaf;
1404 rope __base_rope;
1405 uninitialized_fill_n(__base_buffer, __exponentiate_threshold, __c);
1406 _S_cond_store_eos(__base_buffer[__exponentiate_threshold]);
1407 __STL_TRY {
1408 __base_leaf = _S_new_RopeLeaf(__base_buffer,
1409 __exponentiate_threshold, __a);
1410 }
1411 __STL_UNWIND(_RopeRep::__STL_FREE_STRING(__base_buffer,
1412 __exponentiate_threshold, __a))
1413 __base_rope._M_tree_ptr = __base_leaf;
1414 if (1 == __exponent) {
1415 __result = __base_rope;
1416 # ifndef __GC
1417 __stl_assert(2 == __result._M_tree_ptr->_M_refcount);
1418 // One each for base_rope and __result
1419 # endif
1420 } else {
1421 // XXX what is power()?
1422 __result = power(__base_rope, __exponent, _Concat_fn());
1423 }
1424 if (0 != __remainder) {
1425 __result += __remainder_rope;
1426 }
1427 } else {
1428 __result = __remainder_rope;
1429 }
1430 _M_tree_ptr = __result._M_tree_ptr;
1431 _M_tree_ptr->_M_ref_nonnil();
1432 }
1433
1434 template<class _CharT, class _Alloc>
1435 _CharT rope<_CharT,_Alloc>::_S_empty_c_str[1];
1436
1437 # ifdef __STL_PTHREADS
1438 template<class _CharT, class _Alloc>
1439 pthread_mutex_t
1440 rope<_CharT,_Alloc>::_S_swap_lock = PTHREAD_MUTEX_INITIALIZER;
1441 # endif
1442
1443 template<class _CharT, class _Alloc>
1444 const _CharT* rope<_CharT,_Alloc>::c_str() const {
1445 if (0 == _M_tree_ptr) {
1446 _S_empty_c_str[0] = _S_eos((_CharT*)0); // Possibly redundant,
1447 // but probably fast.
1448 return _S_empty_c_str;
1449 }
1450 __GC_CONST _CharT* __old_c_string = _M_tree_ptr->_M_c_string;
1451 if (0 != __old_c_string) return(__old_c_string);
1452 size_t __s = size();
1453 _CharT* __result = _Data_allocate(__s + 1);
1454 _S_flatten(_M_tree_ptr, __result);
1455 __result[__s] = _S_eos((_CharT*)0);
1456 # ifdef __GC
1457 _M_tree_ptr->_M_c_string = __result;
1458 # else
1459 if ((__old_c_string =
1460 _S_atomic_swap(&(_M_tree_ptr->_M_c_string), __result)) != 0) {
1461 // It must have been added in the interim. Hence it had to have been
1462 // separately allocated. Deallocate the old copy, since we just
1463 // replaced it.
1464 destroy(__old_c_string, __old_c_string + __s + 1);
1465 _Data_deallocate(__old_c_string, __s + 1);
1466 }
1467 # endif
1468 return(__result);
1469 }
1470
1471 template<class _CharT, class _Alloc>
1472 const _CharT* rope<_CharT,_Alloc>::replace_with_c_str() {
1473 if (0 == _M_tree_ptr) {
1474 _S_empty_c_str[0] = _S_eos((_CharT*)0);
1475 return _S_empty_c_str;
1476 }
1477 __GC_CONST _CharT* __old_c_string = _M_tree_ptr->_M_c_string;
1478 if (_RopeRep::_S_leaf == _M_tree_ptr->_M_tag && 0 != __old_c_string) {
1479 return(__old_c_string);
1480 }
1481 size_t __s = size();
1482 _CharT* __result = _Data_allocate(_S_rounded_up_size(__s));
1483 _S_flatten(_M_tree_ptr, __result);
1484 __result[__s] = _S_eos((_CharT*)0);
1485 _M_tree_ptr->_M_unref_nonnil();
1486 _M_tree_ptr = _S_new_RopeLeaf(__result, __s, get_allocator());
1487 return(__result);
1488 }
1489
1490 // Algorithm specializations. More should be added.
1491
1492 #ifndef _MSC_VER
1493 // I couldn't get this to work with VC++
1494 template<class _CharT,class _Alloc>
1495 void
1496 _Rope_rotate(_Rope_iterator<_CharT,_Alloc> __first,
1497 _Rope_iterator<_CharT,_Alloc> __middle,
1498 _Rope_iterator<_CharT,_Alloc> __last)
1499 {
1500 __stl_assert(__first.container() == __middle.container()
1501 && __middle.container() == __last.container());
1502 rope<_CharT,_Alloc>& __r(__first.container());
1503 rope<_CharT,_Alloc> __prefix = __r.substr(0, __first.index());
1504 rope<_CharT,_Alloc> __suffix =
1505 __r.substr(__last.index(), __r.size() - __last.index());
1506 rope<_CharT,_Alloc> __part1 =
1507 __r.substr(__middle.index(), __last.index() - __middle.index());
1508 rope<_CharT,_Alloc> __part2 =
1509 __r.substr(__first.index(), __middle.index() - __first.index());
1510 __r = __prefix;
1511 __r += __part1;
1512 __r += __part2;
1513 __r += __suffix;
1514 }
1515
1516 #if !defined(__GNUC__)
1517 // Appears to confuse g++
1518 inline void rotate(_Rope_iterator<char,__STL_DEFAULT_ALLOCATOR(char)> __first,
1519 _Rope_iterator<char,__STL_DEFAULT_ALLOCATOR(char)> __middle,
1520 _Rope_iterator<char,__STL_DEFAULT_ALLOCATOR(char)> __last) {
1521 _Rope_rotate(__first, __middle, __last);
1522 }
1523 #endif
1524
1525 # if 0
1526 // Probably not useful for several reasons:
1527 // - for SGIs 7.1 compiler and probably some others,
1528 // this forces lots of rope<wchar_t, ...> instantiations, creating a
1529 // code bloat and compile time problem. (Fixed in 7.2.)
1530 // - wchar_t is 4 bytes wide on most UNIX platforms, making it unattractive
1531 // for unicode strings. Unsigned short may be a better character
1532 // type.
1533 inline void rotate(
1534 _Rope_iterator<wchar_t,__STL_DEFAULT_ALLOCATOR(char)> __first,
1535 _Rope_iterator<wchar_t,__STL_DEFAULT_ALLOCATOR(char)> __middle,
1536 _Rope_iterator<wchar_t,__STL_DEFAULT_ALLOCATOR(char)> __last) {
1537 _Rope_rotate(__first, __middle, __last);
1538 }
1539 # endif
1540 #endif /* _MSC_VER */
1541
1542 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
1543 #pragma reset woff 1174
1544 #endif
1545
1546 __STL_END_NAMESPACE
1547
1548 // Local Variables:
1549 // mode:C++
1550 // End:
Clone of Haiku svn repository