ropeimpl.h
上传用户:nizebo
上传日期:2022-05-14
资源大小:882k
文件大小:47k
源码类别:

STL

开发平台:

Visual C++

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