home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 November / PCWorld_2000-11_cd.bin / Software / Topware / devc40 / _SETUP.6 / Group14 / ropeimpl.h < prev    next >
C/C++ Source or Header  |  2000-01-21  |  47KB  |  1,551 lines
  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:
  1551.