This week only. Pastebin PRO Accounts Christmas Special! Don't miss out!Want more features on Pastebin? Sign Up, it's FREE!
Guest

asm_file_part_2

By: a guest on Dec 17th, 2012  |  syntax: None  |  size: 471.25 KB  |  views: 73  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1.  
  2.         mov     DWORD PTR [esi+16], edi
  3.  
  4. ; 517  :                        : this->_Bx._Buf);
  5.  
  6.         jb      SHORT $LN108@assign
  7. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  8.  
  9. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  10.  
  11.         mov     eax, DWORD PTR [esi]
  12. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  13.  
  14. ; 564  :                _Left = _Right;
  15.  
  16.         mov     BYTE PTR [eax+edi], 0
  17.         pop     edi
  18. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  19.  
  20. ; 1138 :                return (*this);
  21.  
  22.         mov     eax, esi
  23.         pop     esi
  24.         pop     ebx
  25.  
  26. ; 1139 :                }
  27.  
  28.         pop     ebp
  29.         ret     8
  30. $LN108@assign:
  31.  
  32. ; 517  :                        : this->_Bx._Buf);
  33.  
  34.         mov     eax, esi
  35. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  36.  
  37. ; 564  :                _Left = _Right;
  38.  
  39.         mov     BYTE PTR [eax+edi], 0
  40. $LN112@assign:
  41.         pop     edi
  42. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  43.  
  44. ; 1138 :                return (*this);
  45.  
  46.         mov     eax, esi
  47.         pop     esi
  48.         pop     ebx
  49.  
  50. ; 1139 :                }
  51.  
  52.         pop     ebp
  53.         ret     8
  54. $LN118@assign:
  55. ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@PBDI@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign
  56. _TEXT   ENDS
  57. ; Function compile flags: /Ogtp
  58. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  59. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  60. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  61. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  62. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  63. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  64. ;       COMDAT ?_Eos@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEXI@Z
  65. _TEXT   SEGMENT
  66. __Newsize$ = 8                                          ; size = 4
  67. ?_Eos@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEXI@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Eos, COMDAT
  68. ; _this$ = ecx
  69.  
  70. ; 2217 :                {       // set new length and null terminator
  71.  
  72.         push    ebp
  73.         mov     ebp, esp
  74.  
  75. ; 517  :                        : this->_Bx._Buf);
  76.  
  77.         cmp     DWORD PTR [ecx+20], 16                  ; 00000010H
  78.  
  79. ; 2218 :                _Traits::assign(this->_Myptr()[this->_Mysize = _Newsize], _Elem());
  80.  
  81.         mov     edx, DWORD PTR __Newsize$[ebp]
  82.         mov     DWORD PTR [ecx+16], edx
  83.  
  84. ; 517  :                        : this->_Bx._Buf);
  85.  
  86.         jb      SHORT $LN5@Eos
  87. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  88.  
  89. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  90.  
  91.         mov     eax, DWORD PTR [ecx]
  92. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  93.  
  94. ; 564  :                _Left = _Right;
  95.  
  96.         mov     BYTE PTR [eax+edx], 0
  97. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  98.  
  99. ; 2219 :                }
  100.  
  101.         pop     ebp
  102.         ret     4
  103. $LN5@Eos:
  104. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  105.  
  106. ; 564  :                _Left = _Right;
  107.  
  108.         mov     BYTE PTR [ecx+edx], 0
  109. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  110.  
  111. ; 2219 :                }
  112.  
  113.         pop     ebp
  114.         ret     4
  115. ?_Eos@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEXI@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Eos
  116. _TEXT   ENDS
  117. ; Function compile flags: /Ogtp
  118. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  119. ;       COMDAT ?_Xran@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEXXZ
  120. _TEXT   SEGMENT
  121. ?_Xran@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEXXZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Xran, COMDAT
  122. ; _this$dead$ = ecx
  123.  
  124. ; 2276 :                _Xout_of_range("invalid string position");
  125.  
  126.         push    OFFSET ??_C@_0BI@CFPLBAOH@invalid?5string?5position?$AA@
  127.         call    DWORD PTR __imp_?_Xout_of_range@std@@YAXPBD@Z
  128. $LN4@Xran:
  129. $LN3@Xran:
  130.         int     3
  131. ?_Xran@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEXXZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Xran
  132. _TEXT   ENDS
  133. ; Function compile flags: /Ogtp
  134. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  135. ;       COMDAT ??0?$_Wrap_alloc@V?$allocator@D@std@@@std@@QAE@XZ
  136. _TEXT   SEGMENT
  137. ??0?$_Wrap_alloc@V?$allocator@D@std@@@std@@QAE@XZ PROC  ; std::_Wrap_alloc<std::allocator<char> >::_Wrap_alloc<std::allocator<char> >, COMDAT
  138. ; _this$ = ecx
  139.  
  140. ; 831  :                }
  141.  
  142.         mov     eax, ecx
  143.         ret     0
  144. ??0?$_Wrap_alloc@V?$allocator@D@std@@@std@@QAE@XZ ENDP  ; std::_Wrap_alloc<std::allocator<char> >::_Wrap_alloc<std::allocator<char> >
  145. _TEXT   ENDS
  146. ; Function compile flags: /Ogtp
  147. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  148. ;       COMDAT ?deallocate@?$_Wrap_alloc@V?$allocator@D@std@@@std@@QAEXPADI@Z
  149. _TEXT   SEGMENT
  150. __Ptr$ = 8                                              ; size = 4
  151. __Count$dead$ = 12                                      ; size = 4
  152. ?deallocate@?$_Wrap_alloc@V?$allocator@D@std@@@std@@QAEXPADI@Z PROC ; std::_Wrap_alloc<std::allocator<char> >::deallocate, COMDAT
  153. ; _this$dead$ = ecx
  154.  
  155. ; 886  :                {       // deallocate object at _Ptr, ignore size
  156.  
  157.         push    ebp
  158.         mov     ebp, esp
  159.  
  160. ; 586  :                ::operator delete(_Ptr);
  161.  
  162.         push    DWORD PTR __Ptr$[ebp]
  163.         call    DWORD PTR __imp_??3@YAXPAX@Z
  164.         add     esp, 4
  165.  
  166. ; 887  :                _Mybase::deallocate(_Ptr, _Count);
  167. ; 888  :                }
  168.  
  169.         pop     ebp
  170.         ret     8
  171. ?deallocate@?$_Wrap_alloc@V?$allocator@D@std@@@std@@QAEXPADI@Z ENDP ; std::_Wrap_alloc<std::allocator<char> >::deallocate
  172. _TEXT   ENDS
  173. ; Function compile flags: /Ogtp
  174. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  175. ;       COMDAT ??0?$_String_val@U?$_Simple_types@D@std@@@std@@QAE@XZ
  176. _TEXT   SEGMENT
  177. ??0?$_String_val@U?$_Simple_types@D@std@@@std@@QAE@XZ PROC ; std::_String_val<std::_Simple_types<char> >::_String_val<std::_Simple_types<char> >, COMDAT
  178. ; _this$ = ecx
  179.  
  180. ; 497  :                {       // initialize values
  181. ; 498  :                _Mysize = 0;
  182.  
  183.         mov     DWORD PTR [ecx+16], 0
  184.  
  185. ; 499  :                _Myres = 0;
  186.  
  187.         mov     DWORD PTR [ecx+20], 0
  188.  
  189. ; 500  :                }
  190.  
  191.         mov     eax, ecx
  192.         ret     0
  193. ??0?$_String_val@U?$_Simple_types@D@std@@@std@@QAE@XZ ENDP ; std::_String_val<std::_Simple_types<char> >::_String_val<std::_Simple_types<char> >
  194. _TEXT   ENDS
  195. ; Function compile flags: /Ogtp
  196. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  197. ;       COMDAT ?_Destroy@?$vector@HV?$allocator@H@std@@@std@@IAEXPAH0@Z
  198. _TEXT   SEGMENT
  199. __First$dead$ = 8                                       ; size = 4
  200. __Last$dead$ = 12                                       ; size = 4
  201. ?_Destroy@?$vector@HV?$allocator@H@std@@@std@@IAEXPAH0@Z PROC ; std::vector<int,std::allocator<int> >::_Destroy, COMDAT
  202. ; _this$dead$ = ecx
  203.  
  204. ; 1479 :                _Alty _Alval(this->_Getal());
  205. ; 1480 :                _Destroy_range(_First, _Last, _Alval);
  206. ; 1481 :                }
  207.  
  208.         ret     8
  209. ?_Destroy@?$vector@HV?$allocator@H@std@@@std@@IAEXPAH0@Z ENDP ; std::vector<int,std::allocator<int> >::_Destroy
  210. _TEXT   ENDS
  211. ; Function compile flags: /Ogtp
  212. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  213. ;       COMDAT ?_Getal@?$_Vector_alloc@$0A@U?$_Vec_base_types@HV?$allocator@H@std@@@std@@@std@@QBE?AU?$_Wrap_alloc@V?$allocator@H@std@@@2@XZ
  214. _TEXT   SEGMENT
  215. ___$ReturnUdt$ = 8                                      ; size = 4
  216. ?_Getal@?$_Vector_alloc@$0A@U?$_Vec_base_types@HV?$allocator@H@std@@@std@@@std@@QBE?AU?$_Wrap_alloc@V?$allocator@H@std@@@2@XZ PROC ; std::_Vector_alloc<0,std::_Vec_base_types<int,std::allocator<int> > >::_Getal, COMDAT
  217. ; _this$dead$ = ecx
  218.  
  219. ; 646  :                {       // get reference to allocator
  220.  
  221.         push    ebp
  222.         mov     ebp, esp
  223.  
  224. ; 647  :                return (_Alty());
  225.  
  226.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  227.  
  228. ; 648  :                }
  229.  
  230.         pop     ebp
  231.         ret     4
  232. ?_Getal@?$_Vector_alloc@$0A@U?$_Vec_base_types@HV?$allocator@H@std@@@std@@@std@@QBE?AU?$_Wrap_alloc@V?$allocator@H@std@@@2@XZ ENDP ; std::_Vector_alloc<0,std::_Vec_base_types<int,std::allocator<int> > >::_Getal
  233. _TEXT   ENDS
  234. ; Function compile flags: /Ogtp
  235. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  236. ;       COMDAT ?deallocate@?$_Wrap_alloc@V?$allocator@H@std@@@std@@QAEXPAHI@Z
  237. _TEXT   SEGMENT
  238. __Ptr$ = 8                                              ; size = 4
  239. __Count$dead$ = 12                                      ; size = 4
  240. ?deallocate@?$_Wrap_alloc@V?$allocator@H@std@@@std@@QAEXPAHI@Z PROC ; std::_Wrap_alloc<std::allocator<int> >::deallocate, COMDAT
  241. ; _this$dead$ = ecx
  242.  
  243. ; 886  :                {       // deallocate object at _Ptr, ignore size
  244.  
  245.         push    ebp
  246.         mov     ebp, esp
  247.  
  248. ; 586  :                ::operator delete(_Ptr);
  249.  
  250.         push    DWORD PTR __Ptr$[ebp]
  251.         call    DWORD PTR __imp_??3@YAXPAX@Z
  252.         add     esp, 4
  253.  
  254. ; 887  :                _Mybase::deallocate(_Ptr, _Count);
  255. ; 888  :                }
  256.  
  257.         pop     ebp
  258.         ret     8
  259. ?deallocate@?$_Wrap_alloc@V?$allocator@H@std@@@std@@QAEXPAHI@Z ENDP ; std::_Wrap_alloc<std::allocator<int> >::deallocate
  260. _TEXT   ENDS
  261. ; Function compile flags: /Ogtp
  262. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  263. ;       COMDAT ??0?$_Vector_val@U?$_Simple_types@H@std@@@std@@QAE@XZ
  264. _TEXT   SEGMENT
  265. ??0?$_Vector_val@U?$_Simple_types@H@std@@@std@@QAE@XZ PROC ; std::_Vector_val<std::_Simple_types<int> >::_Vector_val<std::_Simple_types<int> >, COMDAT
  266. ; _this$ = ecx
  267.  
  268. ; 485  :                {       // initialize values
  269. ; 486  :                _Myfirst = pointer();
  270.  
  271.         mov     DWORD PTR [ecx], 0
  272.  
  273. ; 487  :                _Mylast = pointer();
  274.  
  275.         mov     DWORD PTR [ecx+4], 0
  276.  
  277. ; 488  :                _Myend = pointer();
  278.  
  279.         mov     DWORD PTR [ecx+8], 0
  280.  
  281. ; 489  :                }
  282.  
  283.         mov     eax, ecx
  284.         ret     0
  285. ??0?$_Vector_val@U?$_Simple_types@H@std@@@std@@QAE@XZ ENDP ; std::_Vector_val<std::_Simple_types<int> >::_Vector_val<std::_Simple_types<int> >
  286. _TEXT   ENDS
  287. ; Function compile flags: /Ogtp
  288. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  289. ;       COMDAT ?begin@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@XZ
  290. _TEXT   SEGMENT
  291. ___$ReturnUdt$ = 8                                      ; size = 4
  292. ?begin@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@XZ PROC ; std::vector<double,std::allocator<double> >::begin, COMDAT
  293. ; _this$ = ecx
  294.  
  295. ; 981  :                {       // return iterator for beginning of mutable sequence
  296.  
  297.         push    ebp
  298.         mov     ebp, esp
  299.  
  300. ; 47   :                {       // construct with pointer _Parg
  301.  
  302.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  303.         mov     ecx, DWORD PTR [ecx]
  304.         mov     DWORD PTR [eax], ecx
  305.  
  306. ; 982  :                return (iterator(this->_Myfirst, this));
  307. ; 983  :                }
  308.  
  309.         pop     ebp
  310.         ret     4
  311. ?begin@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@XZ ENDP ; std::vector<double,std::allocator<double> >::begin
  312. _TEXT   ENDS
  313. ; Function compile flags: /Ogtp
  314. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  315. ;       COMDAT ?end@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@XZ
  316. _TEXT   SEGMENT
  317. ___$ReturnUdt$ = 8                                      ; size = 4
  318. ?end@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@XZ PROC ; std::vector<double,std::allocator<double> >::end, COMDAT
  319. ; _this$ = ecx
  320.  
  321. ; 991  :                {       // return iterator for end of mutable sequence
  322.  
  323.         push    ebp
  324.         mov     ebp, esp
  325.  
  326. ; 47   :                {       // construct with pointer _Parg
  327.  
  328.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  329.         mov     ecx, DWORD PTR [ecx+4]
  330.         mov     DWORD PTR [eax], ecx
  331.  
  332. ; 992  :                return (iterator(this->_Mylast, this));
  333. ; 993  :                }
  334.  
  335.         pop     ebp
  336.         ret     4
  337. ?end@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@XZ ENDP ; std::vector<double,std::allocator<double> >::end
  338. _TEXT   ENDS
  339. ; Function compile flags: /Ogtp
  340. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  341. ;       COMDAT ?size@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ
  342. _TEXT   SEGMENT
  343. ?size@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ PROC   ; std::vector<double,std::allocator<double> >::size, COMDAT
  344. ; _this$ = ecx
  345.  
  346. ; 1087 :                return (this->_Mylast - this->_Myfirst);
  347.  
  348.         mov     eax, DWORD PTR [ecx+4]
  349.         sub     eax, DWORD PTR [ecx]
  350.         sar     eax, 3
  351.  
  352. ; 1088 :                }
  353.  
  354.         ret     0
  355. ?size@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ ENDP   ; std::vector<double,std::allocator<double> >::size
  356. _TEXT   ENDS
  357. ; Function compile flags: /Ogtp
  358. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  359. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xutility
  360. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  361. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xutility
  362. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  363. ;       COMDAT ?erase@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@V?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@0@Z
  364. _TEXT   SEGMENT
  365. ___$ReturnUdt$ = 8                                      ; size = 4
  366. __First_arg$ = 12                                       ; size = 4
  367. __Last_arg$ = 16                                        ; size = 4
  368. ?erase@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@V?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@0@Z PROC ; std::vector<double,std::allocator<double> >::erase, COMDAT
  369. ; _this$ = ecx
  370.  
  371. ; 1381 :                {       // erase [_First, _Last)
  372.  
  373.         push    ebp
  374.         mov     ebp, esp
  375.  
  376. ; 1382 :                if (_First_arg == begin() && _Last_arg == end())
  377.  
  378.         mov     eax, DWORD PTR __Last_arg$[ebp]
  379.         push    ebx
  380.         mov     ebx, ecx
  381.         push    edi
  382.  
  383. ; 48   :                this->_Adopt(_Pvector);
  384. ; 49   :                }
  385. ; 50   :
  386. ; 51   :        typedef pointer _Unchecked_type;
  387. ; 52   :
  388. ; 53   :        _Myiter& _Rechecked(_Unchecked_type _Right)
  389. ; 54   :                {       // reset from unchecked iterator
  390. ; 55   :                this->_Ptr = (_Tptr)_Right;
  391. ; 56   :                return (*this);
  392. ; 57   :                }
  393. ; 58   :
  394. ; 59   :        _Unchecked_type _Unchecked() const
  395. ; 60   :                {       // make an unchecked iterator
  396. ; 61   :                return (_Unchecked_type(this->_Ptr));
  397. ; 62   :                }
  398. ; 63   :
  399. ; 64   :        reference operator*() const
  400. ; 65   :                {       // return designated object
  401. ; 66   :  #if _ITERATOR_DEBUG_LEVEL == 2
  402. ; 67   :                if (this->_Getcont() == 0
  403. ; 68   :                        || this->_Ptr == 0
  404. ; 69   :                        || this->_Ptr < ((_Myvec *)this->_Getcont())->_Myfirst
  405. ; 70   :                        || ((_Myvec *)this->_Getcont())->_Mylast <= this->_Ptr)
  406. ; 71   :                        {       // report error
  407. ; 72   :                        _DEBUG_ERROR("vector iterator not dereferencable");
  408. ; 73   :                        _SCL_SECURE_OUT_OF_RANGE;
  409. ; 74   :                        }
  410. ; 75   :
  411. ; 76   :  #elif _ITERATOR_DEBUG_LEVEL == 1
  412. ; 77   :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  413. ; 78   :                _SCL_SECURE_VALIDATE_RANGE(
  414. ; 79   :                        this->_Ptr != _Tptr()
  415. ; 80   :                        && ((_Myvec *)this->_Getcont())->_Myfirst <= this->_Ptr
  416. ; 81   :                        && this->_Ptr < ((_Myvec *)this->_Getcont())->_Mylast);
  417. ; 82   :  #endif /* _ITERATOR_DEBUG_LEVEL */
  418. ; 83   :
  419. ; 84   :                _Analysis_assume_(this->_Ptr != _Tptr());
  420. ; 85   :
  421. ; 86   :                return (*this->_Ptr);
  422. ; 87   :                }
  423. ; 88   :
  424. ; 89   :        pointer operator->() const
  425. ; 90   :                {       // return pointer to class object
  426. ; 91   :                return (_STD pointer_traits<pointer>::pointer_to(**this));
  427. ; 92   :                }
  428. ; 93   :
  429. ; 94   :        _Myiter& operator++()
  430. ; 95   :                {       // preincrement
  431. ; 96   :  #if _ITERATOR_DEBUG_LEVEL == 2
  432. ; 97   :                if (this->_Getcont() == 0
  433. ; 98   :                        || this->_Ptr == 0
  434. ; 99   :                        || ((_Myvec *)this->_Getcont())->_Mylast <= this->_Ptr)
  435. ; 100  :                        {       // report error
  436. ; 101  :                        _DEBUG_ERROR("vector iterator not incrementable");
  437. ; 102  :                        _SCL_SECURE_OUT_OF_RANGE;
  438. ; 103  :                        }
  439. ; 104  :
  440. ; 105  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  441. ; 106  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  442. ; 107  :                _SCL_SECURE_VALIDATE_RANGE(
  443. ; 108  :                        this->_Ptr != _Tptr()
  444. ; 109  :                        && this->_Ptr < ((_Myvec *)this->_Getcont())->_Mylast);
  445. ; 110  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  446. ; 111  :
  447. ; 112  :                ++this->_Ptr;
  448. ; 113  :                return (*this);
  449. ; 114  :                }
  450. ; 115  :
  451. ; 116  :        _Myiter operator++(int)
  452. ; 117  :                {       // postincrement
  453. ; 118  :                _Myiter _Tmp = *this;
  454. ; 119  :                ++*this;
  455. ; 120  :                return (_Tmp);
  456. ; 121  :                }
  457. ; 122  :
  458. ; 123  :        _Myiter& operator--()
  459. ; 124  :                {       // predecrement
  460. ; 125  :  #if _ITERATOR_DEBUG_LEVEL == 2
  461. ; 126  :                if (this->_Getcont() == 0
  462. ; 127  :                        || this->_Ptr == 0
  463. ; 128  :                        || this->_Ptr <= ((_Myvec *)this->_Getcont())->_Myfirst)
  464. ; 129  :                        {       // report error
  465. ; 130  :                        _DEBUG_ERROR("vector iterator not decrementable");
  466. ; 131  :                        _SCL_SECURE_OUT_OF_RANGE;
  467. ; 132  :                        }
  468. ; 133  :
  469. ; 134  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  470. ; 135  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  471. ; 136  :                _SCL_SECURE_VALIDATE_RANGE(
  472. ; 137  :                        this->_Ptr != _Tptr()
  473. ; 138  :                        && ((_Myvec *)this->_Getcont())->_Myfirst < this->_Ptr);
  474. ; 139  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  475. ; 140  :
  476. ; 141  :                --this->_Ptr;
  477. ; 142  :                return (*this);
  478. ; 143  :                }
  479. ; 144  :
  480. ; 145  :        _Myiter operator--(int)
  481. ; 146  :                {       // postdecrement
  482. ; 147  :                _Myiter _Tmp = *this;
  483. ; 148  :                --*this;
  484. ; 149  :                return (_Tmp);
  485. ; 150  :                }
  486. ; 151  :
  487. ; 152  :        _Myiter& operator+=(difference_type _Off)
  488. ; 153  :                {       // increment by integer
  489. ; 154  :  #if _ITERATOR_DEBUG_LEVEL == 2
  490. ; 155  :                if (this->_Getcont() == 0
  491. ; 156  :                        || this->_Ptr + _Off < ((_Myvec *)this->_Getcont())->_Myfirst
  492. ; 157  :                        || ((_Myvec *)this->_Getcont())->_Mylast < this->_Ptr + _Off)
  493. ; 158  :                        {       // report error
  494. ; 159  :                        _DEBUG_ERROR("vector iterator + offset out of range");
  495. ; 160  :                        _SCL_SECURE_OUT_OF_RANGE;
  496. ; 161  :                        }
  497. ; 162  :
  498. ; 163  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  499. ; 164  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  500. ; 165  :                _SCL_SECURE_VALIDATE_RANGE(
  501. ; 166  :                        ((_Myvec *)this->_Getcont())->_Myfirst <= this->_Ptr + _Off
  502. ; 167  :                        && this->_Ptr + _Off <= ((_Myvec *)this->_Getcont())->_Mylast);
  503. ; 168  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  504. ; 169  :
  505. ; 170  :                _Ptr += _Off;
  506. ; 171  :                return (*this);
  507. ; 172  :                }
  508. ; 173  :
  509. ; 174  :        _Myiter operator+(difference_type _Off) const
  510. ; 175  :                {       // return this + integer
  511. ; 176  :                _Myiter _Tmp = *this;
  512. ; 177  :                return (_Tmp += _Off);
  513. ; 178  :                }
  514. ; 179  :
  515. ; 180  :        _Myiter& operator-=(difference_type _Off)
  516. ; 181  :                {       // decrement by integer
  517. ; 182  :                return (*this += -_Off);
  518. ; 183  :                }
  519. ; 184  :
  520. ; 185  :        _Myiter operator-(difference_type _Off) const
  521. ; 186  :                {       // return this - integer
  522. ; 187  :                _Myiter _Tmp = *this;
  523. ; 188  :                return (_Tmp -= _Off);
  524. ; 189  :                }
  525. ; 190  :
  526. ; 191  :        difference_type operator-(const _Myiter& _Right) const
  527. ; 192  :                {       // return difference of iterators
  528. ; 193  :                _Compat(_Right);
  529. ; 194  :                return (this->_Ptr - _Right._Ptr);
  530. ; 195  :                }
  531. ; 196  :
  532. ; 197  :        reference operator[](difference_type _Off) const
  533. ; 198  :                {       // subscript
  534. ; 199  :                return (*(*this + _Off));
  535. ; 200  :                }
  536. ; 201  :
  537. ; 202  :        bool operator==(const _Myiter& _Right) const
  538. ; 203  :                {       // test for iterator equality
  539. ; 204  :                _Compat(_Right);
  540. ; 205  :                return (this->_Ptr == _Right._Ptr);
  541.  
  542.         mov     ecx, DWORD PTR [ebx]
  543.         mov     edi, DWORD PTR __First_arg$[ebp]
  544.         cmp     edi, ecx
  545.  
  546. ; 1382 :                if (_First_arg == begin() && _Last_arg == end())
  547.  
  548.         jne     SHORT $LN4@erase
  549.  
  550. ; 48   :                this->_Adopt(_Pvector);
  551. ; 49   :                }
  552. ; 50   :
  553. ; 51   :        typedef pointer _Unchecked_type;
  554. ; 52   :
  555. ; 53   :        _Myiter& _Rechecked(_Unchecked_type _Right)
  556. ; 54   :                {       // reset from unchecked iterator
  557. ; 55   :                this->_Ptr = (_Tptr)_Right;
  558. ; 56   :                return (*this);
  559. ; 57   :                }
  560. ; 58   :
  561. ; 59   :        _Unchecked_type _Unchecked() const
  562. ; 60   :                {       // make an unchecked iterator
  563. ; 61   :                return (_Unchecked_type(this->_Ptr));
  564. ; 62   :                }
  565. ; 63   :
  566. ; 64   :        reference operator*() const
  567. ; 65   :                {       // return designated object
  568. ; 66   :  #if _ITERATOR_DEBUG_LEVEL == 2
  569. ; 67   :                if (this->_Getcont() == 0
  570. ; 68   :                        || this->_Ptr == 0
  571. ; 69   :                        || this->_Ptr < ((_Myvec *)this->_Getcont())->_Myfirst
  572. ; 70   :                        || ((_Myvec *)this->_Getcont())->_Mylast <= this->_Ptr)
  573. ; 71   :                        {       // report error
  574. ; 72   :                        _DEBUG_ERROR("vector iterator not dereferencable");
  575. ; 73   :                        _SCL_SECURE_OUT_OF_RANGE;
  576. ; 74   :                        }
  577. ; 75   :
  578. ; 76   :  #elif _ITERATOR_DEBUG_LEVEL == 1
  579. ; 77   :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  580. ; 78   :                _SCL_SECURE_VALIDATE_RANGE(
  581. ; 79   :                        this->_Ptr != _Tptr()
  582. ; 80   :                        && ((_Myvec *)this->_Getcont())->_Myfirst <= this->_Ptr
  583. ; 81   :                        && this->_Ptr < ((_Myvec *)this->_Getcont())->_Mylast);
  584. ; 82   :  #endif /* _ITERATOR_DEBUG_LEVEL */
  585. ; 83   :
  586. ; 84   :                _Analysis_assume_(this->_Ptr != _Tptr());
  587. ; 85   :
  588. ; 86   :                return (*this->_Ptr);
  589. ; 87   :                }
  590. ; 88   :
  591. ; 89   :        pointer operator->() const
  592. ; 90   :                {       // return pointer to class object
  593. ; 91   :                return (_STD pointer_traits<pointer>::pointer_to(**this));
  594. ; 92   :                }
  595. ; 93   :
  596. ; 94   :        _Myiter& operator++()
  597. ; 95   :                {       // preincrement
  598. ; 96   :  #if _ITERATOR_DEBUG_LEVEL == 2
  599. ; 97   :                if (this->_Getcont() == 0
  600. ; 98   :                        || this->_Ptr == 0
  601. ; 99   :                        || ((_Myvec *)this->_Getcont())->_Mylast <= this->_Ptr)
  602. ; 100  :                        {       // report error
  603. ; 101  :                        _DEBUG_ERROR("vector iterator not incrementable");
  604. ; 102  :                        _SCL_SECURE_OUT_OF_RANGE;
  605. ; 103  :                        }
  606. ; 104  :
  607. ; 105  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  608. ; 106  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  609. ; 107  :                _SCL_SECURE_VALIDATE_RANGE(
  610. ; 108  :                        this->_Ptr != _Tptr()
  611. ; 109  :                        && this->_Ptr < ((_Myvec *)this->_Getcont())->_Mylast);
  612. ; 110  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  613. ; 111  :
  614. ; 112  :                ++this->_Ptr;
  615. ; 113  :                return (*this);
  616. ; 114  :                }
  617. ; 115  :
  618. ; 116  :        _Myiter operator++(int)
  619. ; 117  :                {       // postincrement
  620. ; 118  :                _Myiter _Tmp = *this;
  621. ; 119  :                ++*this;
  622. ; 120  :                return (_Tmp);
  623. ; 121  :                }
  624. ; 122  :
  625. ; 123  :        _Myiter& operator--()
  626. ; 124  :                {       // predecrement
  627. ; 125  :  #if _ITERATOR_DEBUG_LEVEL == 2
  628. ; 126  :                if (this->_Getcont() == 0
  629. ; 127  :                        || this->_Ptr == 0
  630. ; 128  :                        || this->_Ptr <= ((_Myvec *)this->_Getcont())->_Myfirst)
  631. ; 129  :                        {       // report error
  632. ; 130  :                        _DEBUG_ERROR("vector iterator not decrementable");
  633. ; 131  :                        _SCL_SECURE_OUT_OF_RANGE;
  634. ; 132  :                        }
  635. ; 133  :
  636. ; 134  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  637. ; 135  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  638. ; 136  :                _SCL_SECURE_VALIDATE_RANGE(
  639. ; 137  :                        this->_Ptr != _Tptr()
  640. ; 138  :                        && ((_Myvec *)this->_Getcont())->_Myfirst < this->_Ptr);
  641. ; 139  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  642. ; 140  :
  643. ; 141  :                --this->_Ptr;
  644. ; 142  :                return (*this);
  645. ; 143  :                }
  646. ; 144  :
  647. ; 145  :        _Myiter operator--(int)
  648. ; 146  :                {       // postdecrement
  649. ; 147  :                _Myiter _Tmp = *this;
  650. ; 148  :                --*this;
  651. ; 149  :                return (_Tmp);
  652. ; 150  :                }
  653. ; 151  :
  654. ; 152  :        _Myiter& operator+=(difference_type _Off)
  655. ; 153  :                {       // increment by integer
  656. ; 154  :  #if _ITERATOR_DEBUG_LEVEL == 2
  657. ; 155  :                if (this->_Getcont() == 0
  658. ; 156  :                        || this->_Ptr + _Off < ((_Myvec *)this->_Getcont())->_Myfirst
  659. ; 157  :                        || ((_Myvec *)this->_Getcont())->_Mylast < this->_Ptr + _Off)
  660. ; 158  :                        {       // report error
  661. ; 159  :                        _DEBUG_ERROR("vector iterator + offset out of range");
  662. ; 160  :                        _SCL_SECURE_OUT_OF_RANGE;
  663. ; 161  :                        }
  664. ; 162  :
  665. ; 163  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  666. ; 164  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  667. ; 165  :                _SCL_SECURE_VALIDATE_RANGE(
  668. ; 166  :                        ((_Myvec *)this->_Getcont())->_Myfirst <= this->_Ptr + _Off
  669. ; 167  :                        && this->_Ptr + _Off <= ((_Myvec *)this->_Getcont())->_Mylast);
  670. ; 168  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  671. ; 169  :
  672. ; 170  :                _Ptr += _Off;
  673. ; 171  :                return (*this);
  674. ; 172  :                }
  675. ; 173  :
  676. ; 174  :        _Myiter operator+(difference_type _Off) const
  677. ; 175  :                {       // return this + integer
  678. ; 176  :                _Myiter _Tmp = *this;
  679. ; 177  :                return (_Tmp += _Off);
  680. ; 178  :                }
  681. ; 179  :
  682. ; 180  :        _Myiter& operator-=(difference_type _Off)
  683. ; 181  :                {       // decrement by integer
  684. ; 182  :                return (*this += -_Off);
  685. ; 183  :                }
  686. ; 184  :
  687. ; 185  :        _Myiter operator-(difference_type _Off) const
  688. ; 186  :                {       // return this - integer
  689. ; 187  :                _Myiter _Tmp = *this;
  690. ; 188  :                return (_Tmp -= _Off);
  691. ; 189  :                }
  692. ; 190  :
  693. ; 191  :        difference_type operator-(const _Myiter& _Right) const
  694. ; 192  :                {       // return difference of iterators
  695. ; 193  :                _Compat(_Right);
  696. ; 194  :                return (this->_Ptr - _Right._Ptr);
  697. ; 195  :                }
  698. ; 196  :
  699. ; 197  :        reference operator[](difference_type _Off) const
  700. ; 198  :                {       // subscript
  701. ; 199  :                return (*(*this + _Off));
  702. ; 200  :                }
  703. ; 201  :
  704. ; 202  :        bool operator==(const _Myiter& _Right) const
  705. ; 203  :                {       // test for iterator equality
  706. ; 204  :                _Compat(_Right);
  707. ; 205  :                return (this->_Ptr == _Right._Ptr);
  708.  
  709.         cmp     eax, DWORD PTR [ebx+4]
  710.  
  711. ; 1382 :                if (_First_arg == begin() && _Last_arg == end())
  712.  
  713.         jne     SHORT $LN4@erase
  714.  
  715. ; 1411 :
  716. ; 1412 :        void clear() _NOEXCEPT
  717. ; 1413 :                {       // erase all
  718. ; 1414 :                this->_Orphan_all();
  719. ; 1415 :                _Destroy(this->_Myfirst, this->_Mylast);
  720. ; 1416 :                this->_Mylast = this->_Myfirst;
  721.  
  722.         mov     DWORD PTR [ebx+4], ecx
  723. $LN77@erase:
  724.  
  725. ; 47   :                {       // construct with pointer _Parg
  726.  
  727.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  728.         mov     DWORD PTR [eax], edi
  729.         pop     edi
  730.         pop     ebx
  731.  
  732. ; 1407 :                                }
  733. ; 1408 :                        }
  734. ; 1409 :                return (_Make_iter(_First_arg));
  735. ; 1410 :                }
  736.  
  737.         pop     ebp
  738.         ret     12                                      ; 0000000cH
  739. $LN4@erase:
  740.  
  741. ; 48   :                this->_Adopt(_Pvector);
  742. ; 49   :                }
  743. ; 50   :
  744. ; 51   :        typedef pointer _Unchecked_type;
  745. ; 52   :
  746. ; 53   :        _Myiter& _Rechecked(_Unchecked_type _Right)
  747. ; 54   :                {       // reset from unchecked iterator
  748. ; 55   :                this->_Ptr = (_Tptr)_Right;
  749. ; 56   :                return (*this);
  750. ; 57   :                }
  751. ; 58   :
  752. ; 59   :        _Unchecked_type _Unchecked() const
  753. ; 60   :                {       // make an unchecked iterator
  754. ; 61   :                return (_Unchecked_type(this->_Ptr));
  755. ; 62   :                }
  756. ; 63   :
  757. ; 64   :        reference operator*() const
  758. ; 65   :                {       // return designated object
  759. ; 66   :  #if _ITERATOR_DEBUG_LEVEL == 2
  760. ; 67   :                if (this->_Getcont() == 0
  761. ; 68   :                        || this->_Ptr == 0
  762. ; 69   :                        || this->_Ptr < ((_Myvec *)this->_Getcont())->_Myfirst
  763. ; 70   :                        || ((_Myvec *)this->_Getcont())->_Mylast <= this->_Ptr)
  764. ; 71   :                        {       // report error
  765. ; 72   :                        _DEBUG_ERROR("vector iterator not dereferencable");
  766. ; 73   :                        _SCL_SECURE_OUT_OF_RANGE;
  767. ; 74   :                        }
  768. ; 75   :
  769. ; 76   :  #elif _ITERATOR_DEBUG_LEVEL == 1
  770. ; 77   :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  771. ; 78   :                _SCL_SECURE_VALIDATE_RANGE(
  772. ; 79   :                        this->_Ptr != _Tptr()
  773. ; 80   :                        && ((_Myvec *)this->_Getcont())->_Myfirst <= this->_Ptr
  774. ; 81   :                        && this->_Ptr < ((_Myvec *)this->_Getcont())->_Mylast);
  775. ; 82   :  #endif /* _ITERATOR_DEBUG_LEVEL */
  776. ; 83   :
  777. ; 84   :                _Analysis_assume_(this->_Ptr != _Tptr());
  778. ; 85   :
  779. ; 86   :                return (*this->_Ptr);
  780. ; 87   :                }
  781. ; 88   :
  782. ; 89   :        pointer operator->() const
  783. ; 90   :                {       // return pointer to class object
  784. ; 91   :                return (_STD pointer_traits<pointer>::pointer_to(**this));
  785. ; 92   :                }
  786. ; 93   :
  787. ; 94   :        _Myiter& operator++()
  788. ; 95   :                {       // preincrement
  789. ; 96   :  #if _ITERATOR_DEBUG_LEVEL == 2
  790. ; 97   :                if (this->_Getcont() == 0
  791. ; 98   :                        || this->_Ptr == 0
  792. ; 99   :                        || ((_Myvec *)this->_Getcont())->_Mylast <= this->_Ptr)
  793. ; 100  :                        {       // report error
  794. ; 101  :                        _DEBUG_ERROR("vector iterator not incrementable");
  795. ; 102  :                        _SCL_SECURE_OUT_OF_RANGE;
  796. ; 103  :                        }
  797. ; 104  :
  798. ; 105  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  799. ; 106  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  800. ; 107  :                _SCL_SECURE_VALIDATE_RANGE(
  801. ; 108  :                        this->_Ptr != _Tptr()
  802. ; 109  :                        && this->_Ptr < ((_Myvec *)this->_Getcont())->_Mylast);
  803. ; 110  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  804. ; 111  :
  805. ; 112  :                ++this->_Ptr;
  806. ; 113  :                return (*this);
  807. ; 114  :                }
  808. ; 115  :
  809. ; 116  :        _Myiter operator++(int)
  810. ; 117  :                {       // postincrement
  811. ; 118  :                _Myiter _Tmp = *this;
  812. ; 119  :                ++*this;
  813. ; 120  :                return (_Tmp);
  814. ; 121  :                }
  815. ; 122  :
  816. ; 123  :        _Myiter& operator--()
  817. ; 124  :                {       // predecrement
  818. ; 125  :  #if _ITERATOR_DEBUG_LEVEL == 2
  819. ; 126  :                if (this->_Getcont() == 0
  820. ; 127  :                        || this->_Ptr == 0
  821. ; 128  :                        || this->_Ptr <= ((_Myvec *)this->_Getcont())->_Myfirst)
  822. ; 129  :                        {       // report error
  823. ; 130  :                        _DEBUG_ERROR("vector iterator not decrementable");
  824. ; 131  :                        _SCL_SECURE_OUT_OF_RANGE;
  825. ; 132  :                        }
  826. ; 133  :
  827. ; 134  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  828. ; 135  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  829. ; 136  :                _SCL_SECURE_VALIDATE_RANGE(
  830. ; 137  :                        this->_Ptr != _Tptr()
  831. ; 138  :                        && ((_Myvec *)this->_Getcont())->_Myfirst < this->_Ptr);
  832. ; 139  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  833. ; 140  :
  834. ; 141  :                --this->_Ptr;
  835. ; 142  :                return (*this);
  836. ; 143  :                }
  837. ; 144  :
  838. ; 145  :        _Myiter operator--(int)
  839. ; 146  :                {       // postdecrement
  840. ; 147  :                _Myiter _Tmp = *this;
  841. ; 148  :                --*this;
  842. ; 149  :                return (_Tmp);
  843. ; 150  :                }
  844. ; 151  :
  845. ; 152  :        _Myiter& operator+=(difference_type _Off)
  846. ; 153  :                {       // increment by integer
  847. ; 154  :  #if _ITERATOR_DEBUG_LEVEL == 2
  848. ; 155  :                if (this->_Getcont() == 0
  849. ; 156  :                        || this->_Ptr + _Off < ((_Myvec *)this->_Getcont())->_Myfirst
  850. ; 157  :                        || ((_Myvec *)this->_Getcont())->_Mylast < this->_Ptr + _Off)
  851. ; 158  :                        {       // report error
  852. ; 159  :                        _DEBUG_ERROR("vector iterator + offset out of range");
  853. ; 160  :                        _SCL_SECURE_OUT_OF_RANGE;
  854. ; 161  :                        }
  855. ; 162  :
  856. ; 163  :  #elif _ITERATOR_DEBUG_LEVEL == 1
  857. ; 164  :                _SCL_SECURE_VALIDATE(this->_Getcont() != 0);
  858. ; 165  :                _SCL_SECURE_VALIDATE_RANGE(
  859. ; 166  :                        ((_Myvec *)this->_Getcont())->_Myfirst <= this->_Ptr + _Off
  860. ; 167  :                        && this->_Ptr + _Off <= ((_Myvec *)this->_Getcont())->_Mylast);
  861. ; 168  :  #endif /* _ITERATOR_DEBUG_LEVEL */
  862. ; 169  :
  863. ; 170  :                _Ptr += _Off;
  864. ; 171  :                return (*this);
  865. ; 172  :                }
  866. ; 173  :
  867. ; 174  :        _Myiter operator+(difference_type _Off) const
  868. ; 175  :                {       // return this + integer
  869. ; 176  :                _Myiter _Tmp = *this;
  870. ; 177  :                return (_Tmp += _Off);
  871. ; 178  :                }
  872. ; 179  :
  873. ; 180  :        _Myiter& operator-=(difference_type _Off)
  874. ; 181  :                {       // decrement by integer
  875. ; 182  :                return (*this += -_Off);
  876. ; 183  :                }
  877. ; 184  :
  878. ; 185  :        _Myiter operator-(difference_type _Off) const
  879. ; 186  :                {       // return this - integer
  880. ; 187  :                _Myiter _Tmp = *this;
  881. ; 188  :                return (_Tmp -= _Off);
  882. ; 189  :                }
  883. ; 190  :
  884. ; 191  :        difference_type operator-(const _Myiter& _Right) const
  885. ; 192  :                {       // return difference of iterators
  886. ; 193  :                _Compat(_Right);
  887. ; 194  :                return (this->_Ptr - _Right._Ptr);
  888. ; 195  :                }
  889. ; 196  :
  890. ; 197  :        reference operator[](difference_type _Off) const
  891. ; 198  :                {       // subscript
  892. ; 199  :                return (*(*this + _Off));
  893. ; 200  :                }
  894. ; 201  :
  895. ; 202  :        bool operator==(const _Myiter& _Right) const
  896. ; 203  :                {       // test for iterator equality
  897. ; 204  :                _Compat(_Right);
  898. ; 205  :                return (this->_Ptr == _Right._Ptr);
  899.  
  900.         cmp     edi, eax
  901.  
  902. ; 1383 :                        clear();
  903. ; 1384 :                else if (_First_arg != _Last_arg)
  904.  
  905.         je      SHORT $LN77@erase
  906. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xutility
  907.  
  908. ; 2475 :        ptrdiff_t _Count = _Last - _First;
  909.  
  910.         mov     ecx, DWORD PTR [ebx+4]
  911.         sub     ecx, eax
  912.         push    esi
  913.         sar     ecx, 3
  914.  
  915. ; 2477 :                _Count * sizeof (*_First));
  916.  
  917.         lea     esi, DWORD PTR [ecx*8]
  918.         push    esi
  919.         push    eax
  920.         push    edi
  921.         call    DWORD PTR __imp__memmove
  922. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  923.  
  924. ; 47   :                {       // construct with pointer _Parg
  925.  
  926.         mov     ecx, DWORD PTR __First_arg$[ebp]
  927. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xutility
  928.  
  929. ; 2477 :                _Count * sizeof (*_First));
  930.  
  931.         add     esp, 12                                 ; 0000000cH
  932.  
  933. ; 2478 :        return (_Dest + _Count);
  934.  
  935.         lea     eax, DWORD PTR [esi+edi]
  936. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  937.  
  938. ; 1406 :                                this->_Mylast = _Ptr;
  939.  
  940.         mov     DWORD PTR [ebx+4], eax
  941.  
  942. ; 47   :                {       // construct with pointer _Parg
  943.  
  944.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  945.         pop     esi
  946.         pop     edi
  947.         mov     DWORD PTR [eax], ecx
  948.         pop     ebx
  949.  
  950. ; 1407 :                                }
  951. ; 1408 :                        }
  952. ; 1409 :                return (_Make_iter(_First_arg));
  953. ; 1410 :                }
  954.  
  955.         pop     ebp
  956.         ret     12                                      ; 0000000cH
  957. ?erase@?$vector@NV?$allocator@N@std@@@std@@QAE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@V?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@0@Z ENDP ; std::vector<double,std::allocator<double> >::erase
  958. _TEXT   ENDS
  959. ; Function compile flags: /Ogtp
  960. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  961. ;       COMDAT ?_Destroy@?$vector@NV?$allocator@N@std@@@std@@IAEXPAN0@Z
  962. _TEXT   SEGMENT
  963. __First$dead$ = 8                                       ; size = 4
  964. __Last$dead$ = 12                                       ; size = 4
  965. ?_Destroy@?$vector@NV?$allocator@N@std@@@std@@IAEXPAN0@Z PROC ; std::vector<double,std::allocator<double> >::_Destroy, COMDAT
  966. ; _this$dead$ = ecx
  967.  
  968. ; 1479 :                _Alty _Alval(this->_Getal());
  969. ; 1480 :                _Destroy_range(_First, _Last, _Alval);
  970. ; 1481 :                }
  971.  
  972.         ret     8
  973. ?_Destroy@?$vector@NV?$allocator@N@std@@@std@@IAEXPAN0@Z ENDP ; std::vector<double,std::allocator<double> >::_Destroy
  974. _TEXT   ENDS
  975. ; Function compile flags: /Ogtp
  976. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  977. ;       COMDAT ?_Reserve@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z
  978. _TEXT   SEGMENT
  979. __Count$ = 8                                            ; size = 4
  980. ?_Reserve@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z PROC ; std::vector<double,std::allocator<double> >::_Reserve, COMDAT
  981. ; _this$ = ecx
  982.  
  983. ; 1525 :                {       // ensure room for _Count new elements, grow exponentially
  984.  
  985.         push    ebp
  986.         mov     ebp, esp
  987.  
  988. ; 968  :                }
  989. ; 969  :
  990. ; 970  :        size_type _Unused_capacity() const _NOEXCEPT
  991. ; 971  :                {       // micro-optimization for capacity() - size()
  992. ; 972  :                return (this->_Myend - this->_Mylast);
  993.  
  994.         mov     edx, DWORD PTR [ecx+8]
  995.         push    esi
  996.         mov     esi, DWORD PTR [ecx+4]
  997.         mov     eax, edx
  998.         sub     eax, esi
  999.         push    edi
  1000.  
  1001. ; 1526 :                if (_Unused_capacity() < _Count)
  1002.  
  1003.         mov     edi, DWORD PTR __Count$[ebp]
  1004.  
  1005. ; 968  :                }
  1006. ; 969  :
  1007. ; 970  :        size_type _Unused_capacity() const _NOEXCEPT
  1008. ; 971  :                {       // micro-optimization for capacity() - size()
  1009. ; 972  :                return (this->_Myend - this->_Mylast);
  1010.  
  1011.         sar     eax, 3
  1012.  
  1013. ; 1526 :                if (_Unused_capacity() < _Count)
  1014.  
  1015.         cmp     eax, edi
  1016.         jae     SHORT $LN2@Reserve
  1017.  
  1018. ; 973  :                }
  1019. ; 974  :
  1020. ; 975  :        size_type _Has_unused_capacity() const _NOEXCEPT
  1021. ; 976  :                {       // micro-optimization for capacity() != size()
  1022. ; 977  :                return (this->_Myend != this->_Mylast);
  1023. ; 978  :                }
  1024. ; 979  :
  1025. ; 980  :        iterator begin() _NOEXCEPT
  1026. ; 981  :                {       // return iterator for beginning of mutable sequence
  1027. ; 982  :                return (iterator(this->_Myfirst, this));
  1028. ; 983  :                }
  1029. ; 984  :
  1030. ; 985  :        const_iterator begin() const _NOEXCEPT
  1031. ; 986  :                {       // return iterator for beginning of nonmutable sequence
  1032. ; 987  :                return (const_iterator(this->_Myfirst, this));
  1033. ; 988  :                }
  1034. ; 989  :
  1035. ; 990  :        iterator end() _NOEXCEPT
  1036. ; 991  :                {       // return iterator for end of mutable sequence
  1037. ; 992  :                return (iterator(this->_Mylast, this));
  1038. ; 993  :                }
  1039. ; 994  :
  1040. ; 995  :        const_iterator end() const _NOEXCEPT
  1041. ; 996  :                {       // return iterator for end of nonmutable sequence
  1042. ; 997  :                return (const_iterator(this->_Mylast, this));
  1043. ; 998  :                }
  1044. ; 999  :
  1045. ; 1000 :        iterator _Make_iter(const_iterator _Where) const
  1046. ; 1001 :                {       // make iterator from const_iterator
  1047. ; 1002 :                return (iterator(_Where._Ptr, this));
  1048. ; 1003 :                }
  1049. ; 1004 :
  1050. ; 1005 :        reverse_iterator rbegin() _NOEXCEPT
  1051. ; 1006 :                {       // return iterator for beginning of reversed mutable sequence
  1052. ; 1007 :                return (reverse_iterator(end()));
  1053. ; 1008 :                }
  1054. ; 1009 :
  1055. ; 1010 :        const_reverse_iterator rbegin() const _NOEXCEPT
  1056. ; 1011 :                {       // return iterator for beginning of reversed nonmutable sequence
  1057. ; 1012 :                return (const_reverse_iterator(end()));
  1058. ; 1013 :                }
  1059. ; 1014 :
  1060. ; 1015 :        reverse_iterator rend() _NOEXCEPT
  1061. ; 1016 :                {       // return iterator for end of reversed mutable sequence
  1062. ; 1017 :                return (reverse_iterator(begin()));
  1063. ; 1018 :                }
  1064. ; 1019 :
  1065. ; 1020 :        const_reverse_iterator rend() const _NOEXCEPT
  1066. ; 1021 :                {       // return iterator for end of reversed nonmutable sequence
  1067. ; 1022 :                return (const_reverse_iterator(begin()));
  1068. ; 1023 :                }
  1069. ; 1024 :
  1070. ; 1025 :  #if _HAS_CPP0X
  1071. ; 1026 :        const_iterator cbegin() const _NOEXCEPT
  1072. ; 1027 :                {       // return iterator for beginning of nonmutable sequence
  1073. ; 1028 :                return (((const _Myt *)this)->begin());
  1074. ; 1029 :                }
  1075. ; 1030 :
  1076. ; 1031 :        const_iterator cend() const _NOEXCEPT
  1077. ; 1032 :                {       // return iterator for end of nonmutable sequence
  1078. ; 1033 :                return (((const _Myt *)this)->end());
  1079. ; 1034 :                }
  1080. ; 1035 :
  1081. ; 1036 :        const_reverse_iterator crbegin() const _NOEXCEPT
  1082. ; 1037 :                {       // return iterator for beginning of reversed nonmutable sequence
  1083. ; 1038 :                return (((const _Myt *)this)->rbegin());
  1084. ; 1039 :                }
  1085. ; 1040 :
  1086. ; 1041 :        const_reverse_iterator crend() const _NOEXCEPT
  1087. ; 1042 :                {       // return iterator for end of reversed nonmutable sequence
  1088. ; 1043 :                return (((const _Myt *)this)->rend());
  1089. ; 1044 :                }
  1090. ; 1045 :
  1091. ; 1046 :        void shrink_to_fit()
  1092. ; 1047 :                {       // reduce capacity
  1093. ; 1048 :                if (_Has_unused_capacity())
  1094. ; 1049 :                        {       // worth shrinking, do it
  1095. ; 1050 :                        if (empty())
  1096. ; 1051 :                                _Tidy();
  1097. ; 1052 :                        else
  1098. ; 1053 :                                _Reallocate(size());
  1099. ; 1054 :                        }
  1100. ; 1055 :                }
  1101. ; 1056 :  #endif /* _HAS_CPP0X */
  1102. ; 1057 :
  1103. ; 1058 :        void resize(size_type _Newsize)
  1104. ; 1059 :                {       // determine new length, padding as needed
  1105. ; 1060 :                if (_Newsize < size())
  1106. ; 1061 :                        erase(begin() + _Newsize, end());
  1107. ; 1062 :                else if (size() < _Newsize)
  1108. ; 1063 :                        {       // pad as needed
  1109. ; 1064 :                        _Alty _Alval(this->_Getal());
  1110. ; 1065 :                        _Reserve(_Newsize - size());
  1111. ; 1066 :                        _TRY_BEGIN
  1112. ; 1067 :                        _Uninitialized_default_fill_n(this->_Mylast, _Newsize - size(),
  1113. ; 1068 :                                _Alval);
  1114. ; 1069 :                        _CATCH_ALL
  1115. ; 1070 :                        _Tidy();
  1116. ; 1071 :                        _RERAISE;
  1117. ; 1072 :                        _CATCH_END
  1118. ; 1073 :                        this->_Mylast += _Newsize - size();
  1119. ; 1074 :                        }
  1120. ; 1075 :                }
  1121. ; 1076 :
  1122. ; 1077 :        void resize(size_type _Newsize, const value_type& _Val)
  1123. ; 1078 :                {       // determine new length, padding with _Val elements as needed
  1124. ; 1079 :                if (_Newsize < size())
  1125. ; 1080 :                        erase(begin() + _Newsize, end());
  1126. ; 1081 :                else if (size() < _Newsize)
  1127. ; 1082 :                        _Insert_n(end(), _Newsize - size(), _Val);
  1128. ; 1083 :                }
  1129. ; 1084 :
  1130. ; 1085 :        size_type size() const _NOEXCEPT
  1131. ; 1086 :                {       // return length of sequence
  1132. ; 1087 :                return (this->_Mylast - this->_Myfirst);
  1133.  
  1134.         sub     esi, DWORD PTR [ecx]
  1135.         push    ebx
  1136.  
  1137. ; 1527 :                        {       // need more room, try to get it
  1138. ; 1528 :                        if (max_size() - size() < _Count)
  1139.  
  1140.         mov     ebx, 536870911                          ; 1fffffffH
  1141.  
  1142. ; 973  :                }
  1143. ; 974  :
  1144. ; 975  :        size_type _Has_unused_capacity() const _NOEXCEPT
  1145. ; 976  :                {       // micro-optimization for capacity() != size()
  1146. ; 977  :                return (this->_Myend != this->_Mylast);
  1147. ; 978  :                }
  1148. ; 979  :
  1149. ; 980  :        iterator begin() _NOEXCEPT
  1150. ; 981  :                {       // return iterator for beginning of mutable sequence
  1151. ; 982  :                return (iterator(this->_Myfirst, this));
  1152. ; 983  :                }
  1153. ; 984  :
  1154. ; 985  :        const_iterator begin() const _NOEXCEPT
  1155. ; 986  :                {       // return iterator for beginning of nonmutable sequence
  1156. ; 987  :                return (const_iterator(this->_Myfirst, this));
  1157. ; 988  :                }
  1158. ; 989  :
  1159. ; 990  :        iterator end() _NOEXCEPT
  1160. ; 991  :                {       // return iterator for end of mutable sequence
  1161. ; 992  :                return (iterator(this->_Mylast, this));
  1162. ; 993  :                }
  1163. ; 994  :
  1164. ; 995  :        const_iterator end() const _NOEXCEPT
  1165. ; 996  :                {       // return iterator for end of nonmutable sequence
  1166. ; 997  :                return (const_iterator(this->_Mylast, this));
  1167. ; 998  :                }
  1168. ; 999  :
  1169. ; 1000 :        iterator _Make_iter(const_iterator _Where) const
  1170. ; 1001 :                {       // make iterator from const_iterator
  1171. ; 1002 :                return (iterator(_Where._Ptr, this));
  1172. ; 1003 :                }
  1173. ; 1004 :
  1174. ; 1005 :        reverse_iterator rbegin() _NOEXCEPT
  1175. ; 1006 :                {       // return iterator for beginning of reversed mutable sequence
  1176. ; 1007 :                return (reverse_iterator(end()));
  1177. ; 1008 :                }
  1178. ; 1009 :
  1179. ; 1010 :        const_reverse_iterator rbegin() const _NOEXCEPT
  1180. ; 1011 :                {       // return iterator for beginning of reversed nonmutable sequence
  1181. ; 1012 :                return (const_reverse_iterator(end()));
  1182. ; 1013 :                }
  1183. ; 1014 :
  1184. ; 1015 :        reverse_iterator rend() _NOEXCEPT
  1185. ; 1016 :                {       // return iterator for end of reversed mutable sequence
  1186. ; 1017 :                return (reverse_iterator(begin()));
  1187. ; 1018 :                }
  1188. ; 1019 :
  1189. ; 1020 :        const_reverse_iterator rend() const _NOEXCEPT
  1190. ; 1021 :                {       // return iterator for end of reversed nonmutable sequence
  1191. ; 1022 :                return (const_reverse_iterator(begin()));
  1192. ; 1023 :                }
  1193. ; 1024 :
  1194. ; 1025 :  #if _HAS_CPP0X
  1195. ; 1026 :        const_iterator cbegin() const _NOEXCEPT
  1196. ; 1027 :                {       // return iterator for beginning of nonmutable sequence
  1197. ; 1028 :                return (((const _Myt *)this)->begin());
  1198. ; 1029 :                }
  1199. ; 1030 :
  1200. ; 1031 :        const_iterator cend() const _NOEXCEPT
  1201. ; 1032 :                {       // return iterator for end of nonmutable sequence
  1202. ; 1033 :                return (((const _Myt *)this)->end());
  1203. ; 1034 :                }
  1204. ; 1035 :
  1205. ; 1036 :        const_reverse_iterator crbegin() const _NOEXCEPT
  1206. ; 1037 :                {       // return iterator for beginning of reversed nonmutable sequence
  1207. ; 1038 :                return (((const _Myt *)this)->rbegin());
  1208. ; 1039 :                }
  1209. ; 1040 :
  1210. ; 1041 :        const_reverse_iterator crend() const _NOEXCEPT
  1211. ; 1042 :                {       // return iterator for end of reversed nonmutable sequence
  1212. ; 1043 :                return (((const _Myt *)this)->rend());
  1213. ; 1044 :                }
  1214. ; 1045 :
  1215. ; 1046 :        void shrink_to_fit()
  1216. ; 1047 :                {       // reduce capacity
  1217. ; 1048 :                if (_Has_unused_capacity())
  1218. ; 1049 :                        {       // worth shrinking, do it
  1219. ; 1050 :                        if (empty())
  1220. ; 1051 :                                _Tidy();
  1221. ; 1052 :                        else
  1222. ; 1053 :                                _Reallocate(size());
  1223. ; 1054 :                        }
  1224. ; 1055 :                }
  1225. ; 1056 :  #endif /* _HAS_CPP0X */
  1226. ; 1057 :
  1227. ; 1058 :        void resize(size_type _Newsize)
  1228. ; 1059 :                {       // determine new length, padding as needed
  1229. ; 1060 :                if (_Newsize < size())
  1230. ; 1061 :                        erase(begin() + _Newsize, end());
  1231. ; 1062 :                else if (size() < _Newsize)
  1232. ; 1063 :                        {       // pad as needed
  1233. ; 1064 :                        _Alty _Alval(this->_Getal());
  1234. ; 1065 :                        _Reserve(_Newsize - size());
  1235. ; 1066 :                        _TRY_BEGIN
  1236. ; 1067 :                        _Uninitialized_default_fill_n(this->_Mylast, _Newsize - size(),
  1237. ; 1068 :                                _Alval);
  1238. ; 1069 :                        _CATCH_ALL
  1239. ; 1070 :                        _Tidy();
  1240. ; 1071 :                        _RERAISE;
  1241. ; 1072 :                        _CATCH_END
  1242. ; 1073 :                        this->_Mylast += _Newsize - size();
  1243. ; 1074 :                        }
  1244. ; 1075 :                }
  1245. ; 1076 :
  1246. ; 1077 :        void resize(size_type _Newsize, const value_type& _Val)
  1247. ; 1078 :                {       // determine new length, padding with _Val elements as needed
  1248. ; 1079 :                if (_Newsize < size())
  1249. ; 1080 :                        erase(begin() + _Newsize, end());
  1250. ; 1081 :                else if (size() < _Newsize)
  1251. ; 1082 :                        _Insert_n(end(), _Newsize - size(), _Val);
  1252. ; 1083 :                }
  1253. ; 1084 :
  1254. ; 1085 :        size_type size() const _NOEXCEPT
  1255. ; 1086 :                {       // return length of sequence
  1256. ; 1087 :                return (this->_Mylast - this->_Myfirst);
  1257.  
  1258.         sar     esi, 3
  1259.  
  1260. ; 1527 :                        {       // need more room, try to get it
  1261. ; 1528 :                        if (max_size() - size() < _Count)
  1262.  
  1263.         mov     eax, ebx
  1264.         sub     eax, esi
  1265.         cmp     eax, edi
  1266.         jae     SHORT $LN1@Reserve
  1267.  
  1268. ; 1533 :
  1269. ; 1534 :        void _Tidy()
  1270. ; 1535 :                {       // free all storage
  1271. ; 1536 :                if (this->_Myfirst != pointer())
  1272. ; 1537 :                        {       // something to free, destroy and deallocate it
  1273. ; 1538 :                        this->_Orphan_all();
  1274. ; 1539 :                        _Destroy(this->_Myfirst, this->_Mylast);
  1275. ; 1540 :                        this->_Getal().deallocate(this->_Myfirst,
  1276. ; 1541 :                                this->_Myend - this->_Myfirst);
  1277. ; 1542 :                        this->_Myfirst = pointer();
  1278. ; 1543 :                        this->_Mylast = pointer();
  1279. ; 1544 :                        this->_Myend = pointer();
  1280. ; 1545 :                        }
  1281. ; 1546 :                }
  1282. ; 1547 :
  1283. ; 1548 :        template<class _Iter>
  1284. ; 1549 :                pointer _Ucopy(_Iter _First, _Iter _Last, pointer _Ptr)
  1285. ; 1550 :                {       // copy initializing [_First, _Last), using allocator
  1286. ; 1551 :                _Alty _Alval(this->_Getal());
  1287. ; 1552 :                return (_Uninitialized_copy(_First, _Last,
  1288. ; 1553 :                        _Ptr, _Alval));
  1289. ; 1554 :                }
  1290. ; 1555 :
  1291. ; 1556 :        template<class _Iter>
  1292. ; 1557 :                pointer _Umove(_Iter _First, _Iter _Last, pointer _Ptr)
  1293. ; 1558 :                {       // move initializing [_First, _Last), using allocator
  1294. ; 1559 :                _Alty _Alval(this->_Getal());
  1295. ; 1560 :                return (_Uninitialized_move(_First, _Last,
  1296. ; 1561 :                        _Ptr, _Alval));
  1297. ; 1562 :                }
  1298. ; 1563 :
  1299. ; 1564 :        iterator _Insert_n(const_iterator _Where,
  1300. ; 1565 :                size_type _Count, const value_type& _Val)
  1301. ; 1566 :                {       // insert _Count * _Val at _Where
  1302. ; 1567 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1303. ; 1568 :                if (_VICONT(_Where) != this
  1304. ; 1569 :                        || _VIPTR(_Where) < this->_Myfirst
  1305. ; 1570 :                        || this->_Mylast < _VIPTR(_Where))
  1306. ; 1571 :                        _DEBUG_ERROR("vector insert iterator outside range");
  1307. ; 1572 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  1308. ; 1573 :
  1309. ; 1574 :                size_type _Off = _VIPTR(_Where) - this->_Myfirst;
  1310. ; 1575 :                if (_Count == 0)
  1311. ; 1576 :                        ;
  1312. ; 1577 :                else if (_Unused_capacity() < _Count)
  1313. ; 1578 :                        {       // not enough room, reallocate
  1314. ; 1579 :                        if (max_size() - size() < _Count)
  1315. ; 1580 :                                _Xlen();        // result too long
  1316. ; 1581 :
  1317. ; 1582 :                        size_type _Capacity = _Grow_to(size() + _Count);
  1318. ; 1583 :                        pointer _Newvec = this->_Getal().allocate(_Capacity);
  1319. ; 1584 :                        size_type _Whereoff = _VIPTR(_Where) - this->_Myfirst;
  1320. ; 1585 :                        int _Ncopied = 0;
  1321. ; 1586 :
  1322. ; 1587 :                        _TRY_BEGIN
  1323. ; 1588 :                        _Ufill(_Newvec + _Whereoff, _Count,
  1324. ; 1589 :                                _STD addressof(_Val));  // add new stuff
  1325. ; 1590 :                        ++_Ncopied;
  1326. ; 1591 :                        _Umove(this->_Myfirst, _VIPTR(_Where),
  1327. ; 1592 :                                _Newvec);       // copy prefix
  1328. ; 1593 :                        ++_Ncopied;
  1329. ; 1594 :                        _Umove(_VIPTR(_Where), this->_Mylast,
  1330. ; 1595 :                                _Newvec + (_Whereoff + _Count));        // copy suffix
  1331. ; 1596 :                        _CATCH_ALL
  1332. ; 1597 :                        if (1 < _Ncopied)
  1333. ; 1598 :                                _Destroy(_Newvec, _Newvec + _Whereoff);
  1334. ; 1599 :                        if (0 < _Ncopied)
  1335. ; 1600 :                                _Destroy(_Newvec + _Whereoff, _Newvec + _Whereoff + _Count);
  1336. ; 1601 :                        this->_Getal().deallocate(_Newvec, _Capacity);
  1337. ; 1602 :                        _RERAISE;
  1338. ; 1603 :                        _CATCH_END
  1339. ; 1604 :
  1340. ; 1605 :                        _Count += size();
  1341. ; 1606 :                        if (this->_Myfirst != pointer())
  1342. ; 1607 :                                {       // destroy and deallocate old array
  1343. ; 1608 :                                _Destroy(this->_Myfirst, this->_Mylast);
  1344. ; 1609 :                                this->_Getal().deallocate(this->_Myfirst,
  1345. ; 1610 :                                        this->_Myend - this->_Myfirst);
  1346. ; 1611 :                                }
  1347. ; 1612 :
  1348. ; 1613 :                        this->_Orphan_all();
  1349. ; 1614 :                        this->_Myend = _Newvec + _Capacity;
  1350. ; 1615 :                        this->_Mylast = _Newvec + _Count;
  1351. ; 1616 :                        this->_Myfirst = _Newvec;
  1352. ; 1617 :                        }
  1353. ; 1618 :                else if ((size_type)(this->_Mylast - _VIPTR(_Where))
  1354. ; 1619 :                        < _Count)
  1355. ; 1620 :                        {       // new stuff spills off end
  1356. ; 1621 :                        value_type _Tmp = _Val; // in case _Val is in sequence
  1357. ; 1622 :
  1358. ; 1623 :                        _Umove(_VIPTR(_Where), this->_Mylast,
  1359. ; 1624 :                                _VIPTR(_Where) + _Count);       // copy suffix
  1360. ; 1625 :
  1361. ; 1626 :                        _TRY_BEGIN
  1362. ; 1627 :                        _Ufill(this->_Mylast,
  1363. ; 1628 :                                _Count - (this->_Mylast - _VIPTR(_Where)),
  1364. ; 1629 :                                _STD addressof(_Tmp));  // insert new stuff off end
  1365. ; 1630 :                        _CATCH_ALL
  1366. ; 1631 :                        _Destroy(_VIPTR(_Where) + _Count,
  1367. ; 1632 :                                this->_Mylast + _Count);
  1368. ; 1633 :                        _RERAISE;
  1369. ; 1634 :                        _CATCH_END
  1370. ; 1635 :
  1371. ; 1636 :                        this->_Mylast += _Count;
  1372. ; 1637 :                        _Orphan_range(_VIPTR(_Where), this->_Mylast);
  1373. ; 1638 :                        _STD fill(_VIPTR(_Where), this->_Mylast - _Count,
  1374. ; 1639 :                                _Tmp);  // insert up to old end
  1375. ; 1640 :                        }
  1376. ; 1641 :                else
  1377. ; 1642 :                        {       // new stuff can all be assigned
  1378. ; 1643 :                        value_type _Tmp = _Val; // in case _Val is in sequence
  1379. ; 1644 :
  1380. ; 1645 :                        pointer _Oldend = this->_Mylast;
  1381. ; 1646 :                        this->_Mylast = _Umove(_Oldend - _Count, _Oldend,
  1382. ; 1647 :                                this->_Mylast); // copy suffix
  1383. ; 1648 :
  1384. ; 1649 :                        _Orphan_range(_VIPTR(_Where), this->_Mylast);
  1385. ; 1650 :                        _Copy_backward(_VIPTR(_Where), _Oldend - _Count,
  1386. ; 1651 :                                _Oldend);       // copy hole
  1387. ; 1652 :                        _STD fill(_VIPTR(_Where),
  1388. ; 1653 :                                _VIPTR(_Where) + _Count, _Tmp); // insert into hole
  1389. ; 1654 :                        }
  1390. ; 1655 :                return (begin() + _Off);
  1391. ; 1656 :                }
  1392. ; 1657 :
  1393. ; 1658 :        pointer _Ufill(pointer _Ptr, size_type _Count, const value_type *_Pval)
  1394. ; 1659 :                {       // copy initializing _Count * _Val, using allocator
  1395. ; 1660 :                _Alty _Alval(this->_Getal());
  1396. ; 1661 :                _Uninitialized_fill_n(_Ptr, _Count, _Pval, _Alval);
  1397. ; 1662 :                return (_Ptr + _Count);
  1398. ; 1663 :                }
  1399. ; 1664 :
  1400. ; 1665 :        __declspec(noreturn) void _Xlen() const
  1401. ; 1666 :                {       // report a length_error
  1402. ; 1667 :                _Xlength_error("vector<T> too long");
  1403.  
  1404.         push    OFFSET ??_C@_0BD@OLBABOEK@vector?$DMT?$DO?5too?5long?$AA@
  1405.         call    DWORD PTR __imp_?_Xlength_error@std@@YAXPBD@Z
  1406. $LN44@Reserve:
  1407. $LN1@Reserve:
  1408.  
  1409. ; 967  :                return (this->_Myend - this->_Myfirst);
  1410.  
  1411.         sub     edx, DWORD PTR [ecx]
  1412.  
  1413. ; 1529 :                                _Xlen();
  1414. ; 1530 :                        _Reallocate(_Grow_to(size() + _Count));
  1415.  
  1416.         add     esi, edi
  1417.  
  1418. ; 967  :                return (this->_Myend - this->_Myfirst);
  1419.  
  1420.         sar     edx, 3
  1421.  
  1422. ; 1088 :                }
  1423. ; 1089 :
  1424. ; 1090 :        size_type max_size() const _NOEXCEPT
  1425. ; 1091 :                {       // return maximum possible length of sequence
  1426. ; 1092 :                return (this->_Getal().max_size());
  1427. ; 1093 :                }
  1428. ; 1094 :
  1429. ; 1095 :        bool empty() const _NOEXCEPT
  1430. ; 1096 :                {       // test if sequence is empty
  1431. ; 1097 :                return (this->_Myfirst == this->_Mylast);
  1432. ; 1098 :                }
  1433. ; 1099 :
  1434. ; 1100 :        _Alloc get_allocator() const _NOEXCEPT
  1435. ; 1101 :                {       // return allocator object for values
  1436. ; 1102 :                return (this->_Getal());
  1437. ; 1103 :                }
  1438. ; 1104 :
  1439. ; 1105 :        const_reference at(size_type _Pos) const
  1440. ; 1106 :                {       // subscript nonmutable sequence with checking
  1441. ; 1107 :                if (size() <= _Pos)
  1442. ; 1108 :                        _Xran();
  1443. ; 1109 :                return (*(this->_Myfirst + _Pos));
  1444. ; 1110 :                }
  1445. ; 1111 :
  1446. ; 1112 :        reference at(size_type _Pos)
  1447. ; 1113 :                {       // subscript mutable sequence with checking
  1448. ; 1114 :                if (size() <= _Pos)
  1449. ; 1115 :                        _Xran();
  1450. ; 1116 :                return (*(this->_Myfirst + _Pos));
  1451. ; 1117 :                }
  1452. ; 1118 :
  1453. ; 1119 :        const_reference operator[](size_type _Pos) const
  1454. ; 1120 :                {       // subscript nonmutable sequence
  1455. ; 1121 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1456. ; 1122 :                if (size() <= _Pos)
  1457. ; 1123 :                        {       // report error
  1458. ; 1124 :                        _DEBUG_ERROR("vector subscript out of range");
  1459. ; 1125 :                        _SCL_SECURE_OUT_OF_RANGE;
  1460. ; 1126 :                        }
  1461. ; 1127 :
  1462. ; 1128 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  1463. ; 1129 :                _SCL_SECURE_VALIDATE_RANGE(_Pos < size());
  1464. ; 1130 :  #endif /* _ITERATOR_DEBUG_LEVEL */
  1465. ; 1131 :
  1466. ; 1132 :                return (*(this->_Myfirst + _Pos));
  1467. ; 1133 :                }
  1468. ; 1134 :
  1469. ; 1135 :        reference operator[](size_type _Pos)
  1470. ; 1136 :                {       // subscript mutable sequence
  1471. ; 1137 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1472. ; 1138 :                if (size() <= _Pos)
  1473. ; 1139 :                        {       // report error
  1474. ; 1140 :                        _DEBUG_ERROR("vector subscript out of range");
  1475. ; 1141 :                        _SCL_SECURE_OUT_OF_RANGE;
  1476. ; 1142 :                        }
  1477. ; 1143 :
  1478. ; 1144 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  1479. ; 1145 :                _SCL_SECURE_VALIDATE_RANGE(_Pos < size());
  1480. ; 1146 :  #endif /* _ITERATOR_DEBUG_LEVEL */
  1481. ; 1147 :
  1482. ; 1148 :                return (*(this->_Myfirst + _Pos));
  1483. ; 1149 :                }
  1484. ; 1150 :
  1485. ; 1151 :  #if _HAS_CPP0X
  1486. ; 1152 :        pointer data() _NOEXCEPT
  1487. ; 1153 :                {       // return address of first element
  1488. ; 1154 :                return (this->_Myfirst);
  1489. ; 1155 :                }
  1490. ; 1156 :
  1491. ; 1157 :        const_pointer data() const _NOEXCEPT
  1492. ; 1158 :                {       // return address of first element
  1493. ; 1159 :                return (this->_Myfirst);
  1494. ; 1160 :                }
  1495. ; 1161 :  #endif /* _HAS_CPP0X */
  1496. ; 1162 :
  1497. ; 1163 :        reference front()
  1498. ; 1164 :                {       // return first element of mutable sequence
  1499. ; 1165 :                return (*begin());
  1500. ; 1166 :                }
  1501. ; 1167 :
  1502. ; 1168 :        const_reference front() const
  1503. ; 1169 :                {       // return first element of nonmutable sequence
  1504. ; 1170 :                return (*begin());
  1505. ; 1171 :                }
  1506. ; 1172 :
  1507. ; 1173 :        reference back()
  1508. ; 1174 :                {       // return last element of mutable sequence
  1509. ; 1175 :                return (*(end() - 1));
  1510. ; 1176 :                }
  1511. ; 1177 :
  1512. ; 1178 :        const_reference back() const
  1513. ; 1179 :                {       // return last element of nonmutable sequence
  1514. ; 1180 :                return (*(end() - 1));
  1515. ; 1181 :                }
  1516. ; 1182 :
  1517. ; 1183 :        void push_back(const value_type& _Val)
  1518. ; 1184 :                {       // insert element at end
  1519. ; 1185 :                if (_Inside(_STD addressof(_Val)))
  1520. ; 1186 :                        {       // push back an element
  1521. ; 1187 :                        size_type _Idx = _STD addressof(_Val) - this->_Myfirst;
  1522. ; 1188 :                        if (this->_Mylast == this->_Myend)
  1523. ; 1189 :                                _Reserve(1);
  1524. ; 1190 :                        _Orphan_range(this->_Mylast, this->_Mylast);
  1525. ; 1191 :                        this->_Getal().construct(this->_Mylast,
  1526. ; 1192 :                                this->_Myfirst[_Idx]);
  1527. ; 1193 :                        ++this->_Mylast;
  1528. ; 1194 :                        }
  1529. ; 1195 :                else
  1530. ; 1196 :                        {       // push back a non-element
  1531. ; 1197 :                        if (this->_Mylast == this->_Myend)
  1532. ; 1198 :                                _Reserve(1);
  1533. ; 1199 :                        _Orphan_range(this->_Mylast, this->_Mylast);
  1534. ; 1200 :                        this->_Getal().construct(this->_Mylast,
  1535. ; 1201 :                                _Val);
  1536. ; 1202 :                        ++this->_Mylast;
  1537. ; 1203 :                        }
  1538. ; 1204 :                }
  1539. ; 1205 :
  1540. ; 1206 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1541. ; 1207 :        void pop_back()
  1542. ; 1208 :                {       // erase element at end
  1543. ; 1209 :                if (empty())
  1544. ; 1210 :                        _DEBUG_ERROR("vector empty before pop");
  1545. ; 1211 :                else
  1546. ; 1212 :                        {       // erase last element
  1547. ; 1213 :                        _Orphan_range(this->_Mylast - 1, this->_Mylast);
  1548. ; 1214 :                        this->_Getal().destroy(this->_Mylast - 1);
  1549. ; 1215 :                        --this->_Mylast;
  1550. ; 1216 :                        }
  1551. ; 1217 :                }
  1552. ; 1218 :
  1553. ; 1219 :  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
  1554. ; 1220 :        void pop_back()
  1555. ; 1221 :                {       // erase element at end
  1556. ; 1222 :                if (!empty())
  1557. ; 1223 :                        {       // erase last element
  1558. ; 1224 :                        this->_Getal().destroy(this->_Mylast - 1);
  1559. ; 1225 :                        --this->_Mylast;
  1560. ; 1226 :                        }
  1561. ; 1227 :                }
  1562. ; 1228 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  1563. ; 1229 :
  1564. ; 1230 :        template<class _Iter>
  1565. ; 1231 :                typename enable_if<_Is_iterator<_Iter>::value,
  1566. ; 1232 :                        void>::type
  1567. ; 1233 :                assign(_Iter _First, _Iter _Last)
  1568. ; 1234 :                {       // assign [_First, _Last), input iterators
  1569. ; 1235 :                erase(begin(), end());
  1570. ; 1236 :                insert(begin(), _First, _Last);
  1571. ; 1237 :                }
  1572. ; 1238 :
  1573. ; 1239 :        void assign(size_type _Count, const value_type& _Val)
  1574. ; 1240 :                {       // assign _Count * _Val
  1575. ; 1241 :                _Assign_n(_Count, _Val);
  1576. ; 1242 :                }
  1577. ; 1243 :
  1578. ; 1244 :        iterator insert(const_iterator _Where, const _Ty& _Val)
  1579. ; 1245 :                {       // insert _Val at _Where
  1580. ; 1246 :                return (_Insert_n(_Where, (size_type)1, _Val));
  1581. ; 1247 :                }
  1582. ; 1248 :
  1583. ; 1249 :        iterator insert(const_iterator _Where, size_type _Count,
  1584. ; 1250 :                const _Ty& _Val)
  1585. ; 1251 :                {       // insert _Count * _Val at _Where
  1586. ; 1252 :                return (_Insert_n(_Where, _Count, _Val));
  1587. ; 1253 :                }
  1588. ; 1254 :
  1589. ; 1255 :        template<class _Iter>
  1590. ; 1256 :                typename enable_if<_Is_iterator<_Iter>::value,
  1591. ; 1257 :                        iterator>::type
  1592. ; 1258 :                insert(const_iterator _Where, _Iter _First, _Iter _Last)
  1593. ; 1259 :                {       // insert [_First, _Last) at _Where
  1594. ; 1260 :                size_type _Off = _VIPTR(_Where) - this->_Myfirst;
  1595. ; 1261 :                _Insert(_Where, _First, _Last, _Iter_cat(_First));
  1596. ; 1262 :                return (begin() + _Off);
  1597. ; 1263 :                }
  1598. ; 1264 :
  1599. ; 1265 :        template<class _Iter>
  1600. ; 1266 :                void _Insert(const_iterator _Where, _Iter _First, _Iter _Last,
  1601. ; 1267 :                        input_iterator_tag)
  1602. ; 1268 :                {       // insert [_First, _Last) at _Where, input iterators
  1603. ; 1269 :                size_type _Off = _VIPTR(_Where) - this->_Myfirst;
  1604. ; 1270 :
  1605. ; 1271 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1606. ; 1272 :                if (size() < _Off)
  1607. ; 1273 :                        _DEBUG_ERROR("vector insert iterator outside range");
  1608. ; 1274 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  1609. ; 1275 :
  1610. ; 1276 :                if (_First != _Last)
  1611. ; 1277 :                        {       // worth doing, gather at end and rotate into place
  1612. ; 1278 :                        size_type _Oldsize = size();
  1613. ; 1279 :
  1614. ; 1280 :                        _TRY_BEGIN
  1615. ; 1281 :                        for (; _First != _Last; ++_First)
  1616. ; 1282 :                                push_back(*_First);     // append
  1617. ; 1283 :
  1618. ; 1284 :                        _CATCH_ALL
  1619. ; 1285 :                        erase(begin() + _Oldsize, end());
  1620. ; 1286 :                        _RERAISE;
  1621. ; 1287 :                        _CATCH_END
  1622. ; 1288 :
  1623. ; 1289 :                        _STD rotate(begin() + _Off, begin() + _Oldsize, end());
  1624. ; 1290 :                        }
  1625. ; 1291 :                }
  1626. ; 1292 :
  1627. ; 1293 :        template<class _Iter>
  1628. ; 1294 :                void _Insert(const_iterator _Where, _Iter _First, _Iter _Last,
  1629. ; 1295 :                        forward_iterator_tag)
  1630. ; 1296 :                {       // insert [_First, _Last) at _Where, forward iterators
  1631. ; 1297 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1632. ; 1298 :                if (_VICONT(_Where) != this
  1633. ; 1299 :                        || _VIPTR(_Where) < this->_Myfirst
  1634. ; 1300 :                        || this->_Mylast < _VIPTR(_Where))
  1635. ; 1301 :                        _DEBUG_ERROR("vector insert iterator outside range");
  1636. ; 1302 :                _DEBUG_RANGE(_First, _Last);
  1637. ; 1303 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  1638. ; 1304 :
  1639. ; 1305 :                size_type _Count = 0;
  1640. ; 1306 :                _Distance(_First, _Last, _Count);
  1641. ; 1307 :
  1642. ; 1308 :                if (_Count == 0)
  1643. ; 1309 :                        ;
  1644. ; 1310 :                else if (_Unused_capacity() < _Count)
  1645. ; 1311 :                        {       // not enough room, reallocate
  1646. ; 1312 :                        if (max_size() - size() < _Count)
  1647. ; 1313 :                                _Xlen();        // result too long
  1648. ; 1314 :
  1649. ; 1315 :                        size_type _Capacity = _Grow_to(size() + _Count);
  1650. ; 1316 :                        pointer _Newvec = this->_Getal().allocate(_Capacity);
  1651. ; 1317 :                        pointer _Ptr = _Newvec;
  1652. ; 1318 :
  1653. ; 1319 :                        _TRY_BEGIN
  1654. ; 1320 :                        _Ptr = _Umove(this->_Myfirst, _VIPTR(_Where),
  1655. ; 1321 :                                _Newvec);       // copy prefix
  1656. ; 1322 :                        _Ptr = _Ucopy(_First, _Last, _Ptr);     // add new stuff
  1657. ; 1323 :                        _Umove(_VIPTR(_Where), this->_Mylast,
  1658. ; 1324 :                                _Ptr);  // copy suffix
  1659. ; 1325 :                        _CATCH_ALL
  1660. ; 1326 :                        _Destroy(_Newvec, _Ptr);
  1661. ; 1327 :                        this->_Getal().deallocate(_Newvec, _Capacity);
  1662. ; 1328 :                        _RERAISE;
  1663. ; 1329 :                        _CATCH_END
  1664. ; 1330 :
  1665. ; 1331 :                        _Count += size();
  1666. ; 1332 :                        if (this->_Myfirst != pointer())
  1667. ; 1333 :                                {       // destroy and deallocate old array
  1668. ; 1334 :                                _Destroy(this->_Myfirst, this->_Mylast);
  1669. ; 1335 :                                this->_Getal().deallocate(this->_Myfirst,
  1670. ; 1336 :                                        this->_Myend - this->_Myfirst);
  1671. ; 1337 :                                }
  1672. ; 1338 :
  1673. ; 1339 :                        this->_Orphan_all();
  1674. ; 1340 :                        this->_Myend = _Newvec + _Capacity;
  1675. ; 1341 :                        this->_Mylast = _Newvec + _Count;
  1676. ; 1342 :                        this->_Myfirst = _Newvec;
  1677. ; 1343 :                        }
  1678. ; 1344 :                else
  1679. ; 1345 :                        {       // new stuff fits, append and rotate into place
  1680. ; 1346 :                        _Ucopy(_First, _Last, this->_Mylast);
  1681. ; 1347 :                        _STD rotate(_VIPTR(_Where), this->_Mylast,
  1682. ; 1348 :                                this->_Mylast + _Count);
  1683. ; 1349 :                        this->_Mylast += _Count;
  1684. ; 1350 :                        _Orphan_range(_VIPTR(_Where), this->_Mylast);
  1685. ; 1351 :                        }
  1686. ; 1352 :                }
  1687. ; 1353 :
  1688. ; 1354 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1689. ; 1355 :        iterator erase(const_iterator _Where)
  1690. ; 1356 :                {       // erase element at where
  1691. ; 1357 :                if (_VICONT(_Where) != this
  1692. ; 1358 :                        || _VIPTR(_Where) < this->_Myfirst
  1693. ; 1359 :                        || this->_Mylast <= _VIPTR(_Where))
  1694. ; 1360 :                        _DEBUG_ERROR("vector erase iterator outside range");
  1695. ; 1361 :                _Move(_VIPTR(_Where) + 1, this->_Mylast, _VIPTR(_Where));
  1696. ; 1362 :                _Destroy(this->_Mylast - 1, this->_Mylast);
  1697. ; 1363 :                _Orphan_range(_VIPTR(_Where), this->_Mylast);
  1698. ; 1364 :                --this->_Mylast;
  1699. ; 1365 :                return (_Make_iter(_Where));
  1700. ; 1366 :                }
  1701. ; 1367 :
  1702. ; 1368 :  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
  1703. ; 1369 :        iterator erase(const_iterator _Where)
  1704. ; 1370 :                {       // erase element at where
  1705. ; 1371 :                _Move(_VIPTR(_Where) + 1, this->_Mylast,
  1706. ; 1372 :                        _VIPTR(_Where));
  1707. ; 1373 :                _Destroy(this->_Mylast - 1, this->_Mylast);
  1708. ; 1374 :                --this->_Mylast;
  1709. ; 1375 :                return (_Make_iter(_Where));
  1710. ; 1376 :                }
  1711. ; 1377 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  1712. ; 1378 :
  1713. ; 1379 :        iterator erase(const_iterator _First_arg,
  1714. ; 1380 :                const_iterator _Last_arg)
  1715. ; 1381 :                {       // erase [_First, _Last)
  1716. ; 1382 :                if (_First_arg == begin() && _Last_arg == end())
  1717. ; 1383 :                        clear();
  1718. ; 1384 :                else if (_First_arg != _Last_arg)
  1719. ; 1385 :                        {       // clear partial
  1720. ; 1386 :                        iterator _First = _Make_iter(_First_arg);
  1721. ; 1387 :                        iterator _Last = _Make_iter(_Last_arg);
  1722. ; 1388 :
  1723. ; 1389 :                        if (_First != _Last)
  1724. ; 1390 :                                {       // worth doing, copy down over hole
  1725. ; 1391 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1726. ; 1392 :                                if (_Last < _First || _VICONT(_First) != this
  1727. ; 1393 :                                        || _VIPTR(_First) < this->_Myfirst
  1728. ; 1394 :                                        || this->_Mylast < _VIPTR(_Last))
  1729. ; 1395 :                                        _DEBUG_ERROR("vector erase iterator outside range");
  1730. ; 1396 :                                pointer _Ptr = _Move(_VIPTR(_Last), this->_Mylast,
  1731. ; 1397 :                                        _VIPTR(_First));
  1732. ; 1398 :                                _Orphan_range(_VIPTR(_First), this->_Mylast);
  1733. ; 1399 :
  1734. ; 1400 :  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
  1735. ; 1401 :                                pointer _Ptr = _Move(_VIPTR(_Last), this->_Mylast,
  1736. ; 1402 :                                        _VIPTR(_First));
  1737. ; 1403 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  1738. ; 1404 :
  1739. ; 1405 :                                _Destroy(_Ptr, this->_Mylast);
  1740. ; 1406 :                                this->_Mylast = _Ptr;
  1741. ; 1407 :                                }
  1742. ; 1408 :                        }
  1743. ; 1409 :                return (_Make_iter(_First_arg));
  1744. ; 1410 :                }
  1745. ; 1411 :
  1746. ; 1412 :        void clear() _NOEXCEPT
  1747. ; 1413 :                {       // erase all
  1748. ; 1414 :                this->_Orphan_all();
  1749. ; 1415 :                _Destroy(this->_Myfirst, this->_Mylast);
  1750. ; 1416 :                this->_Mylast = this->_Myfirst;
  1751. ; 1417 :                }
  1752. ; 1418 :
  1753. ; 1419 :        void swap(_Myt& _Right)
  1754. ; 1420 :                {       // exchange contents with _Right
  1755. ; 1421 :                if (this == &_Right)
  1756. ; 1422 :                        ;       // same object, do nothing
  1757. ; 1423 :                else if (this->_Getal() == _Right._Getal())
  1758. ; 1424 :                        {       // same allocator, swap control information
  1759. ; 1425 :                        this->_Swap_all(_Right);
  1760. ; 1426 :                        _Swap_adl(this->_Myfirst, _Right._Myfirst);
  1761. ; 1427 :                        _Swap_adl(this->_Mylast, _Right._Mylast);
  1762. ; 1428 :                        _Swap_adl(this->_Myend, _Right._Myend);
  1763. ; 1429 :                        }
  1764. ; 1430 :
  1765. ; 1431 :  #if _HAS_CPP0X
  1766. ; 1432 :                else if (_Alty::propagate_on_container_swap::value)
  1767. ; 1433 :                        {       // swap allocators and control information
  1768. ; 1434 :                        this->_Swap_alloc(_Right);
  1769. ; 1435 :                        _Swap_adl(this->_Myfirst, _Right._Myfirst);
  1770. ; 1436 :                        _Swap_adl(this->_Mylast, _Right._Mylast);
  1771. ; 1437 :                        _Swap_adl(this->_Myend, _Right._Myend);
  1772. ; 1438 :                        }
  1773. ; 1439 :  #endif /* _HAS_CPP0X */
  1774. ; 1440 :
  1775. ; 1441 :                else
  1776. ; 1442 :                        {       // different allocator, do multiple moves
  1777. ; 1443 :                        _Myt _Ts = _Move(*this);
  1778. ; 1444 :
  1779. ; 1445 :                        *this = _Move(_Right);
  1780. ; 1446 :                        _Right = _Move(_Ts);
  1781. ; 1447 :                        }
  1782. ; 1448 :                }
  1783. ; 1449 :
  1784. ; 1450 : protected:
  1785. ; 1451 :        void _Assign_n(size_type _Count, const value_type& _Val)
  1786. ; 1452 :                {       // assign _Count * _Val
  1787. ; 1453 :                value_type _Tmp = _Val; // in case _Val is in sequence
  1788. ; 1454 :                erase(begin(), end());
  1789. ; 1455 :                insert(begin(), _Count, _Tmp);
  1790. ; 1456 :                }
  1791. ; 1457 :
  1792. ; 1458 :        bool _Buy(size_type _Capacity)
  1793. ; 1459 :                {       // allocate array with _Capacity elements
  1794. ; 1460 :                this->_Myfirst = pointer();
  1795. ; 1461 :                this->_Mylast = pointer();
  1796. ; 1462 :                this->_Myend = pointer();
  1797. ; 1463 :
  1798. ; 1464 :                if (_Capacity == 0)
  1799. ; 1465 :                        return (false);
  1800. ; 1466 :                else if (max_size() < _Capacity)
  1801. ; 1467 :                        _Xlen();        // result too long
  1802. ; 1468 :                else
  1803. ; 1469 :                        {       // nonempty array, allocate storage
  1804. ; 1470 :                        this->_Myfirst = this->_Getal().allocate(_Capacity);
  1805. ; 1471 :                        this->_Mylast = this->_Myfirst;
  1806. ; 1472 :                        this->_Myend = this->_Myfirst + _Capacity;
  1807. ; 1473 :                        }
  1808. ; 1474 :                return (true);
  1809. ; 1475 :                }
  1810. ; 1476 :
  1811. ; 1477 :        void _Destroy(pointer _First, pointer _Last)
  1812. ; 1478 :                {       // destroy [_First, _Last) using allocator
  1813. ; 1479 :                _Alty _Alval(this->_Getal());
  1814. ; 1480 :                _Destroy_range(_First, _Last, _Alval);
  1815. ; 1481 :                }
  1816. ; 1482 :
  1817. ; 1483 :        size_type _Grow_to(size_type _Count) const
  1818. ; 1484 :                {       // grow by 50% or at least to _Count
  1819. ; 1485 :                size_type _Capacity = capacity();
  1820. ; 1486 :
  1821. ; 1487 :                _Capacity = max_size() - _Capacity / 2 < _Capacity
  1822. ; 1488 :                        ? 0 : _Capacity + _Capacity / 2;        // try to grow by 50%
  1823.  
  1824.         mov     eax, edx
  1825.         shr     eax, 1
  1826.         sub     ebx, eax
  1827.         cmp     ebx, edx
  1828.         pop     ebx
  1829.         jae     SHORT $LN27@Reserve
  1830.         xor     edx, edx
  1831.  
  1832. ; 1489 :                if (_Capacity < _Count)
  1833.  
  1834.         cmp     edx, esi
  1835.         pop     edi
  1836.         cmovb   edx, esi
  1837.         pop     esi
  1838.  
  1839. ; 1529 :                                _Xlen();
  1840. ; 1530 :                        _Reallocate(_Grow_to(size() + _Count));
  1841.  
  1842.         mov     DWORD PTR __Count$[ebp], edx
  1843.  
  1844. ; 1531 :                        }
  1845. ; 1532 :                }
  1846.  
  1847.         pop     ebp
  1848.  
  1849. ; 1529 :                                _Xlen();
  1850. ; 1530 :                        _Reallocate(_Grow_to(size() + _Count));
  1851.  
  1852.         jmp     ?_Reallocate@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z ; std::vector<double,std::allocator<double> >::_Reallocate
  1853. $LN27@Reserve:
  1854.  
  1855. ; 1088 :                }
  1856. ; 1089 :
  1857. ; 1090 :        size_type max_size() const _NOEXCEPT
  1858. ; 1091 :                {       // return maximum possible length of sequence
  1859. ; 1092 :                return (this->_Getal().max_size());
  1860. ; 1093 :                }
  1861. ; 1094 :
  1862. ; 1095 :        bool empty() const _NOEXCEPT
  1863. ; 1096 :                {       // test if sequence is empty
  1864. ; 1097 :                return (this->_Myfirst == this->_Mylast);
  1865. ; 1098 :                }
  1866. ; 1099 :
  1867. ; 1100 :        _Alloc get_allocator() const _NOEXCEPT
  1868. ; 1101 :                {       // return allocator object for values
  1869. ; 1102 :                return (this->_Getal());
  1870. ; 1103 :                }
  1871. ; 1104 :
  1872. ; 1105 :        const_reference at(size_type _Pos) const
  1873. ; 1106 :                {       // subscript nonmutable sequence with checking
  1874. ; 1107 :                if (size() <= _Pos)
  1875. ; 1108 :                        _Xran();
  1876. ; 1109 :                return (*(this->_Myfirst + _Pos));
  1877. ; 1110 :                }
  1878. ; 1111 :
  1879. ; 1112 :        reference at(size_type _Pos)
  1880. ; 1113 :                {       // subscript mutable sequence with checking
  1881. ; 1114 :                if (size() <= _Pos)
  1882. ; 1115 :                        _Xran();
  1883. ; 1116 :                return (*(this->_Myfirst + _Pos));
  1884. ; 1117 :                }
  1885. ; 1118 :
  1886. ; 1119 :        const_reference operator[](size_type _Pos) const
  1887. ; 1120 :                {       // subscript nonmutable sequence
  1888. ; 1121 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1889. ; 1122 :                if (size() <= _Pos)
  1890. ; 1123 :                        {       // report error
  1891. ; 1124 :                        _DEBUG_ERROR("vector subscript out of range");
  1892. ; 1125 :                        _SCL_SECURE_OUT_OF_RANGE;
  1893. ; 1126 :                        }
  1894. ; 1127 :
  1895. ; 1128 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  1896. ; 1129 :                _SCL_SECURE_VALIDATE_RANGE(_Pos < size());
  1897. ; 1130 :  #endif /* _ITERATOR_DEBUG_LEVEL */
  1898. ; 1131 :
  1899. ; 1132 :                return (*(this->_Myfirst + _Pos));
  1900. ; 1133 :                }
  1901. ; 1134 :
  1902. ; 1135 :        reference operator[](size_type _Pos)
  1903. ; 1136 :                {       // subscript mutable sequence
  1904. ; 1137 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1905. ; 1138 :                if (size() <= _Pos)
  1906. ; 1139 :                        {       // report error
  1907. ; 1140 :                        _DEBUG_ERROR("vector subscript out of range");
  1908. ; 1141 :                        _SCL_SECURE_OUT_OF_RANGE;
  1909. ; 1142 :                        }
  1910. ; 1143 :
  1911. ; 1144 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  1912. ; 1145 :                _SCL_SECURE_VALIDATE_RANGE(_Pos < size());
  1913. ; 1146 :  #endif /* _ITERATOR_DEBUG_LEVEL */
  1914. ; 1147 :
  1915. ; 1148 :                return (*(this->_Myfirst + _Pos));
  1916. ; 1149 :                }
  1917. ; 1150 :
  1918. ; 1151 :  #if _HAS_CPP0X
  1919. ; 1152 :        pointer data() _NOEXCEPT
  1920. ; 1153 :                {       // return address of first element
  1921. ; 1154 :                return (this->_Myfirst);
  1922. ; 1155 :                }
  1923. ; 1156 :
  1924. ; 1157 :        const_pointer data() const _NOEXCEPT
  1925. ; 1158 :                {       // return address of first element
  1926. ; 1159 :                return (this->_Myfirst);
  1927. ; 1160 :                }
  1928. ; 1161 :  #endif /* _HAS_CPP0X */
  1929. ; 1162 :
  1930. ; 1163 :        reference front()
  1931. ; 1164 :                {       // return first element of mutable sequence
  1932. ; 1165 :                return (*begin());
  1933. ; 1166 :                }
  1934. ; 1167 :
  1935. ; 1168 :        const_reference front() const
  1936. ; 1169 :                {       // return first element of nonmutable sequence
  1937. ; 1170 :                return (*begin());
  1938. ; 1171 :                }
  1939. ; 1172 :
  1940. ; 1173 :        reference back()
  1941. ; 1174 :                {       // return last element of mutable sequence
  1942. ; 1175 :                return (*(end() - 1));
  1943. ; 1176 :                }
  1944. ; 1177 :
  1945. ; 1178 :        const_reference back() const
  1946. ; 1179 :                {       // return last element of nonmutable sequence
  1947. ; 1180 :                return (*(end() - 1));
  1948. ; 1181 :                }
  1949. ; 1182 :
  1950. ; 1183 :        void push_back(const value_type& _Val)
  1951. ; 1184 :                {       // insert element at end
  1952. ; 1185 :                if (_Inside(_STD addressof(_Val)))
  1953. ; 1186 :                        {       // push back an element
  1954. ; 1187 :                        size_type _Idx = _STD addressof(_Val) - this->_Myfirst;
  1955. ; 1188 :                        if (this->_Mylast == this->_Myend)
  1956. ; 1189 :                                _Reserve(1);
  1957. ; 1190 :                        _Orphan_range(this->_Mylast, this->_Mylast);
  1958. ; 1191 :                        this->_Getal().construct(this->_Mylast,
  1959. ; 1192 :                                this->_Myfirst[_Idx]);
  1960. ; 1193 :                        ++this->_Mylast;
  1961. ; 1194 :                        }
  1962. ; 1195 :                else
  1963. ; 1196 :                        {       // push back a non-element
  1964. ; 1197 :                        if (this->_Mylast == this->_Myend)
  1965. ; 1198 :                                _Reserve(1);
  1966. ; 1199 :                        _Orphan_range(this->_Mylast, this->_Mylast);
  1967. ; 1200 :                        this->_Getal().construct(this->_Mylast,
  1968. ; 1201 :                                _Val);
  1969. ; 1202 :                        ++this->_Mylast;
  1970. ; 1203 :                        }
  1971. ; 1204 :                }
  1972. ; 1205 :
  1973. ; 1206 :  #if _ITERATOR_DEBUG_LEVEL == 2
  1974. ; 1207 :        void pop_back()
  1975. ; 1208 :                {       // erase element at end
  1976. ; 1209 :                if (empty())
  1977. ; 1210 :                        _DEBUG_ERROR("vector empty before pop");
  1978. ; 1211 :                else
  1979. ; 1212 :                        {       // erase last element
  1980. ; 1213 :                        _Orphan_range(this->_Mylast - 1, this->_Mylast);
  1981. ; 1214 :                        this->_Getal().destroy(this->_Mylast - 1);
  1982. ; 1215 :                        --this->_Mylast;
  1983. ; 1216 :                        }
  1984. ; 1217 :                }
  1985. ; 1218 :
  1986. ; 1219 :  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
  1987. ; 1220 :        void pop_back()
  1988. ; 1221 :                {       // erase element at end
  1989. ; 1222 :                if (!empty())
  1990. ; 1223 :                        {       // erase last element
  1991. ; 1224 :                        this->_Getal().destroy(this->_Mylast - 1);
  1992. ; 1225 :                        --this->_Mylast;
  1993. ; 1226 :                        }
  1994. ; 1227 :                }
  1995. ; 1228 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  1996. ; 1229 :
  1997. ; 1230 :        template<class _Iter>
  1998. ; 1231 :                typename enable_if<_Is_iterator<_Iter>::value,
  1999. ; 1232 :                        void>::type
  2000. ; 1233 :                assign(_Iter _First, _Iter _Last)
  2001. ; 1234 :                {       // assign [_First, _Last), input iterators
  2002. ; 1235 :                erase(begin(), end());
  2003. ; 1236 :                insert(begin(), _First, _Last);
  2004. ; 1237 :                }
  2005. ; 1238 :
  2006. ; 1239 :        void assign(size_type _Count, const value_type& _Val)
  2007. ; 1240 :                {       // assign _Count * _Val
  2008. ; 1241 :                _Assign_n(_Count, _Val);
  2009. ; 1242 :                }
  2010. ; 1243 :
  2011. ; 1244 :        iterator insert(const_iterator _Where, const _Ty& _Val)
  2012. ; 1245 :                {       // insert _Val at _Where
  2013. ; 1246 :                return (_Insert_n(_Where, (size_type)1, _Val));
  2014. ; 1247 :                }
  2015. ; 1248 :
  2016. ; 1249 :        iterator insert(const_iterator _Where, size_type _Count,
  2017. ; 1250 :                const _Ty& _Val)
  2018. ; 1251 :                {       // insert _Count * _Val at _Where
  2019. ; 1252 :                return (_Insert_n(_Where, _Count, _Val));
  2020. ; 1253 :                }
  2021. ; 1254 :
  2022. ; 1255 :        template<class _Iter>
  2023. ; 1256 :                typename enable_if<_Is_iterator<_Iter>::value,
  2024. ; 1257 :                        iterator>::type
  2025. ; 1258 :                insert(const_iterator _Where, _Iter _First, _Iter _Last)
  2026. ; 1259 :                {       // insert [_First, _Last) at _Where
  2027. ; 1260 :                size_type _Off = _VIPTR(_Where) - this->_Myfirst;
  2028. ; 1261 :                _Insert(_Where, _First, _Last, _Iter_cat(_First));
  2029. ; 1262 :                return (begin() + _Off);
  2030. ; 1263 :                }
  2031. ; 1264 :
  2032. ; 1265 :        template<class _Iter>
  2033. ; 1266 :                void _Insert(const_iterator _Where, _Iter _First, _Iter _Last,
  2034. ; 1267 :                        input_iterator_tag)
  2035. ; 1268 :                {       // insert [_First, _Last) at _Where, input iterators
  2036. ; 1269 :                size_type _Off = _VIPTR(_Where) - this->_Myfirst;
  2037. ; 1270 :
  2038. ; 1271 :  #if _ITERATOR_DEBUG_LEVEL == 2
  2039. ; 1272 :                if (size() < _Off)
  2040. ; 1273 :                        _DEBUG_ERROR("vector insert iterator outside range");
  2041. ; 1274 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  2042. ; 1275 :
  2043. ; 1276 :                if (_First != _Last)
  2044. ; 1277 :                        {       // worth doing, gather at end and rotate into place
  2045. ; 1278 :                        size_type _Oldsize = size();
  2046. ; 1279 :
  2047. ; 1280 :                        _TRY_BEGIN
  2048. ; 1281 :                        for (; _First != _Last; ++_First)
  2049. ; 1282 :                                push_back(*_First);     // append
  2050. ; 1283 :
  2051. ; 1284 :                        _CATCH_ALL
  2052. ; 1285 :                        erase(begin() + _Oldsize, end());
  2053. ; 1286 :                        _RERAISE;
  2054. ; 1287 :                        _CATCH_END
  2055. ; 1288 :
  2056. ; 1289 :                        _STD rotate(begin() + _Off, begin() + _Oldsize, end());
  2057. ; 1290 :                        }
  2058. ; 1291 :                }
  2059. ; 1292 :
  2060. ; 1293 :        template<class _Iter>
  2061. ; 1294 :                void _Insert(const_iterator _Where, _Iter _First, _Iter _Last,
  2062. ; 1295 :                        forward_iterator_tag)
  2063. ; 1296 :                {       // insert [_First, _Last) at _Where, forward iterators
  2064. ; 1297 :  #if _ITERATOR_DEBUG_LEVEL == 2
  2065. ; 1298 :                if (_VICONT(_Where) != this
  2066. ; 1299 :                        || _VIPTR(_Where) < this->_Myfirst
  2067. ; 1300 :                        || this->_Mylast < _VIPTR(_Where))
  2068. ; 1301 :                        _DEBUG_ERROR("vector insert iterator outside range");
  2069. ; 1302 :                _DEBUG_RANGE(_First, _Last);
  2070. ; 1303 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  2071. ; 1304 :
  2072. ; 1305 :                size_type _Count = 0;
  2073. ; 1306 :                _Distance(_First, _Last, _Count);
  2074. ; 1307 :
  2075. ; 1308 :                if (_Count == 0)
  2076. ; 1309 :                        ;
  2077. ; 1310 :                else if (_Unused_capacity() < _Count)
  2078. ; 1311 :                        {       // not enough room, reallocate
  2079. ; 1312 :                        if (max_size() - size() < _Count)
  2080. ; 1313 :                                _Xlen();        // result too long
  2081. ; 1314 :
  2082. ; 1315 :                        size_type _Capacity = _Grow_to(size() + _Count);
  2083. ; 1316 :                        pointer _Newvec = this->_Getal().allocate(_Capacity);
  2084. ; 1317 :                        pointer _Ptr = _Newvec;
  2085. ; 1318 :
  2086. ; 1319 :                        _TRY_BEGIN
  2087. ; 1320 :                        _Ptr = _Umove(this->_Myfirst, _VIPTR(_Where),
  2088. ; 1321 :                                _Newvec);       // copy prefix
  2089. ; 1322 :                        _Ptr = _Ucopy(_First, _Last, _Ptr);     // add new stuff
  2090. ; 1323 :                        _Umove(_VIPTR(_Where), this->_Mylast,
  2091. ; 1324 :                                _Ptr);  // copy suffix
  2092. ; 1325 :                        _CATCH_ALL
  2093. ; 1326 :                        _Destroy(_Newvec, _Ptr);
  2094. ; 1327 :                        this->_Getal().deallocate(_Newvec, _Capacity);
  2095. ; 1328 :                        _RERAISE;
  2096. ; 1329 :                        _CATCH_END
  2097. ; 1330 :
  2098. ; 1331 :                        _Count += size();
  2099. ; 1332 :                        if (this->_Myfirst != pointer())
  2100. ; 1333 :                                {       // destroy and deallocate old array
  2101. ; 1334 :                                _Destroy(this->_Myfirst, this->_Mylast);
  2102. ; 1335 :                                this->_Getal().deallocate(this->_Myfirst,
  2103. ; 1336 :                                        this->_Myend - this->_Myfirst);
  2104. ; 1337 :                                }
  2105. ; 1338 :
  2106. ; 1339 :                        this->_Orphan_all();
  2107. ; 1340 :                        this->_Myend = _Newvec + _Capacity;
  2108. ; 1341 :                        this->_Mylast = _Newvec + _Count;
  2109. ; 1342 :                        this->_Myfirst = _Newvec;
  2110. ; 1343 :                        }
  2111. ; 1344 :                else
  2112. ; 1345 :                        {       // new stuff fits, append and rotate into place
  2113. ; 1346 :                        _Ucopy(_First, _Last, this->_Mylast);
  2114. ; 1347 :                        _STD rotate(_VIPTR(_Where), this->_Mylast,
  2115. ; 1348 :                                this->_Mylast + _Count);
  2116. ; 1349 :                        this->_Mylast += _Count;
  2117. ; 1350 :                        _Orphan_range(_VIPTR(_Where), this->_Mylast);
  2118. ; 1351 :                        }
  2119. ; 1352 :                }
  2120. ; 1353 :
  2121. ; 1354 :  #if _ITERATOR_DEBUG_LEVEL == 2
  2122. ; 1355 :        iterator erase(const_iterator _Where)
  2123. ; 1356 :                {       // erase element at where
  2124. ; 1357 :                if (_VICONT(_Where) != this
  2125. ; 1358 :                        || _VIPTR(_Where) < this->_Myfirst
  2126. ; 1359 :                        || this->_Mylast <= _VIPTR(_Where))
  2127. ; 1360 :                        _DEBUG_ERROR("vector erase iterator outside range");
  2128. ; 1361 :                _Move(_VIPTR(_Where) + 1, this->_Mylast, _VIPTR(_Where));
  2129. ; 1362 :                _Destroy(this->_Mylast - 1, this->_Mylast);
  2130. ; 1363 :                _Orphan_range(_VIPTR(_Where), this->_Mylast);
  2131. ; 1364 :                --this->_Mylast;
  2132. ; 1365 :                return (_Make_iter(_Where));
  2133. ; 1366 :                }
  2134. ; 1367 :
  2135. ; 1368 :  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
  2136. ; 1369 :        iterator erase(const_iterator _Where)
  2137. ; 1370 :                {       // erase element at where
  2138. ; 1371 :                _Move(_VIPTR(_Where) + 1, this->_Mylast,
  2139. ; 1372 :                        _VIPTR(_Where));
  2140. ; 1373 :                _Destroy(this->_Mylast - 1, this->_Mylast);
  2141. ; 1374 :                --this->_Mylast;
  2142. ; 1375 :                return (_Make_iter(_Where));
  2143. ; 1376 :                }
  2144. ; 1377 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  2145. ; 1378 :
  2146. ; 1379 :        iterator erase(const_iterator _First_arg,
  2147. ; 1380 :                const_iterator _Last_arg)
  2148. ; 1381 :                {       // erase [_First, _Last)
  2149. ; 1382 :                if (_First_arg == begin() && _Last_arg == end())
  2150. ; 1383 :                        clear();
  2151. ; 1384 :                else if (_First_arg != _Last_arg)
  2152. ; 1385 :                        {       // clear partial
  2153. ; 1386 :                        iterator _First = _Make_iter(_First_arg);
  2154. ; 1387 :                        iterator _Last = _Make_iter(_Last_arg);
  2155. ; 1388 :
  2156. ; 1389 :                        if (_First != _Last)
  2157. ; 1390 :                                {       // worth doing, copy down over hole
  2158. ; 1391 :  #if _ITERATOR_DEBUG_LEVEL == 2
  2159. ; 1392 :                                if (_Last < _First || _VICONT(_First) != this
  2160. ; 1393 :                                        || _VIPTR(_First) < this->_Myfirst
  2161. ; 1394 :                                        || this->_Mylast < _VIPTR(_Last))
  2162. ; 1395 :                                        _DEBUG_ERROR("vector erase iterator outside range");
  2163. ; 1396 :                                pointer _Ptr = _Move(_VIPTR(_Last), this->_Mylast,
  2164. ; 1397 :                                        _VIPTR(_First));
  2165. ; 1398 :                                _Orphan_range(_VIPTR(_First), this->_Mylast);
  2166. ; 1399 :
  2167. ; 1400 :  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
  2168. ; 1401 :                                pointer _Ptr = _Move(_VIPTR(_Last), this->_Mylast,
  2169. ; 1402 :                                        _VIPTR(_First));
  2170. ; 1403 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  2171. ; 1404 :
  2172. ; 1405 :                                _Destroy(_Ptr, this->_Mylast);
  2173. ; 1406 :                                this->_Mylast = _Ptr;
  2174. ; 1407 :                                }
  2175. ; 1408 :                        }
  2176. ; 1409 :                return (_Make_iter(_First_arg));
  2177. ; 1410 :                }
  2178. ; 1411 :
  2179. ; 1412 :        void clear() _NOEXCEPT
  2180. ; 1413 :                {       // erase all
  2181. ; 1414 :                this->_Orphan_all();
  2182. ; 1415 :                _Destroy(this->_Myfirst, this->_Mylast);
  2183. ; 1416 :                this->_Mylast = this->_Myfirst;
  2184. ; 1417 :                }
  2185. ; 1418 :
  2186. ; 1419 :        void swap(_Myt& _Right)
  2187. ; 1420 :                {       // exchange contents with _Right
  2188. ; 1421 :                if (this == &_Right)
  2189. ; 1422 :                        ;       // same object, do nothing
  2190. ; 1423 :                else if (this->_Getal() == _Right._Getal())
  2191. ; 1424 :                        {       // same allocator, swap control information
  2192. ; 1425 :                        this->_Swap_all(_Right);
  2193. ; 1426 :                        _Swap_adl(this->_Myfirst, _Right._Myfirst);
  2194. ; 1427 :                        _Swap_adl(this->_Mylast, _Right._Mylast);
  2195. ; 1428 :                        _Swap_adl(this->_Myend, _Right._Myend);
  2196. ; 1429 :                        }
  2197. ; 1430 :
  2198. ; 1431 :  #if _HAS_CPP0X
  2199. ; 1432 :                else if (_Alty::propagate_on_container_swap::value)
  2200. ; 1433 :                        {       // swap allocators and control information
  2201. ; 1434 :                        this->_Swap_alloc(_Right);
  2202. ; 1435 :                        _Swap_adl(this->_Myfirst, _Right._Myfirst);
  2203. ; 1436 :                        _Swap_adl(this->_Mylast, _Right._Mylast);
  2204. ; 1437 :                        _Swap_adl(this->_Myend, _Right._Myend);
  2205. ; 1438 :                        }
  2206. ; 1439 :  #endif /* _HAS_CPP0X */
  2207. ; 1440 :
  2208. ; 1441 :                else
  2209. ; 1442 :                        {       // different allocator, do multiple moves
  2210. ; 1443 :                        _Myt _Ts = _Move(*this);
  2211. ; 1444 :
  2212. ; 1445 :                        *this = _Move(_Right);
  2213. ; 1446 :                        _Right = _Move(_Ts);
  2214. ; 1447 :                        }
  2215. ; 1448 :                }
  2216. ; 1449 :
  2217. ; 1450 : protected:
  2218. ; 1451 :        void _Assign_n(size_type _Count, const value_type& _Val)
  2219. ; 1452 :                {       // assign _Count * _Val
  2220. ; 1453 :                value_type _Tmp = _Val; // in case _Val is in sequence
  2221. ; 1454 :                erase(begin(), end());
  2222. ; 1455 :                insert(begin(), _Count, _Tmp);
  2223. ; 1456 :                }
  2224. ; 1457 :
  2225. ; 1458 :        bool _Buy(size_type _Capacity)
  2226. ; 1459 :                {       // allocate array with _Capacity elements
  2227. ; 1460 :                this->_Myfirst = pointer();
  2228. ; 1461 :                this->_Mylast = pointer();
  2229. ; 1462 :                this->_Myend = pointer();
  2230. ; 1463 :
  2231. ; 1464 :                if (_Capacity == 0)
  2232. ; 1465 :                        return (false);
  2233. ; 1466 :                else if (max_size() < _Capacity)
  2234. ; 1467 :                        _Xlen();        // result too long
  2235. ; 1468 :                else
  2236. ; 1469 :                        {       // nonempty array, allocate storage
  2237. ; 1470 :                        this->_Myfirst = this->_Getal().allocate(_Capacity);
  2238. ; 1471 :                        this->_Mylast = this->_Myfirst;
  2239. ; 1472 :                        this->_Myend = this->_Myfirst + _Capacity;
  2240. ; 1473 :                        }
  2241. ; 1474 :                return (true);
  2242. ; 1475 :                }
  2243. ; 1476 :
  2244. ; 1477 :        void _Destroy(pointer _First, pointer _Last)
  2245. ; 1478 :                {       // destroy [_First, _Last) using allocator
  2246. ; 1479 :                _Alty _Alval(this->_Getal());
  2247. ; 1480 :                _Destroy_range(_First, _Last, _Alval);
  2248. ; 1481 :                }
  2249. ; 1482 :
  2250. ; 1483 :        size_type _Grow_to(size_type _Count) const
  2251. ; 1484 :                {       // grow by 50% or at least to _Count
  2252. ; 1485 :                size_type _Capacity = capacity();
  2253. ; 1486 :
  2254. ; 1487 :                _Capacity = max_size() - _Capacity / 2 < _Capacity
  2255. ; 1488 :                        ? 0 : _Capacity + _Capacity / 2;        // try to grow by 50%
  2256.  
  2257.         add     edx, eax
  2258.  
  2259. ; 1489 :                if (_Capacity < _Count)
  2260.  
  2261.         cmp     edx, esi
  2262.         pop     edi
  2263.         cmovb   edx, esi
  2264.         pop     esi
  2265.  
  2266. ; 1529 :                                _Xlen();
  2267. ; 1530 :                        _Reallocate(_Grow_to(size() + _Count));
  2268.  
  2269.         mov     DWORD PTR __Count$[ebp], edx
  2270.  
  2271. ; 1531 :                        }
  2272. ; 1532 :                }
  2273.  
  2274.         pop     ebp
  2275.  
  2276. ; 1529 :                                _Xlen();
  2277. ; 1530 :                        _Reallocate(_Grow_to(size() + _Count));
  2278.  
  2279.         jmp     ?_Reallocate@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z ; std::vector<double,std::allocator<double> >::_Reallocate
  2280. $LN2@Reserve:
  2281.         pop     edi
  2282.         pop     esi
  2283.  
  2284. ; 1531 :                        }
  2285. ; 1532 :                }
  2286.  
  2287.         pop     ebp
  2288.         ret     4
  2289. $LN43@Reserve:
  2290. ?_Reserve@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z ENDP ; std::vector<double,std::allocator<double> >::_Reserve
  2291. _TEXT   ENDS
  2292. ; Function compile flags: /Ogtp
  2293. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  2294. ;       COMDAT ?_Getal@?$_Vector_alloc@$0A@U?$_Vec_base_types@NV?$allocator@N@std@@@std@@@std@@QBE?AU?$_Wrap_alloc@V?$allocator@N@std@@@2@XZ
  2295. _TEXT   SEGMENT
  2296. ___$ReturnUdt$ = 8                                      ; size = 4
  2297. ?_Getal@?$_Vector_alloc@$0A@U?$_Vec_base_types@NV?$allocator@N@std@@@std@@@std@@QBE?AU?$_Wrap_alloc@V?$allocator@N@std@@@2@XZ PROC ; std::_Vector_alloc<0,std::_Vec_base_types<double,std::allocator<double> > >::_Getal, COMDAT
  2298. ; _this$dead$ = ecx
  2299.  
  2300. ; 646  :                {       // get reference to allocator
  2301.  
  2302.         push    ebp
  2303.         mov     ebp, esp
  2304.  
  2305. ; 647  :                return (_Alty());
  2306.  
  2307.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  2308.  
  2309. ; 648  :                }
  2310.  
  2311.         pop     ebp
  2312.         ret     4
  2313. ?_Getal@?$_Vector_alloc@$0A@U?$_Vec_base_types@NV?$allocator@N@std@@@std@@@std@@QBE?AU?$_Wrap_alloc@V?$allocator@N@std@@@2@XZ ENDP ; std::_Vector_alloc<0,std::_Vec_base_types<double,std::allocator<double> > >::_Getal
  2314. _TEXT   ENDS
  2315. ; Function compile flags: /Ogtp
  2316. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  2317. ;       COMDAT ?deallocate@?$_Wrap_alloc@V?$allocator@N@std@@@std@@QAEXPANI@Z
  2318. _TEXT   SEGMENT
  2319. __Ptr$ = 8                                              ; size = 4
  2320. __Count$dead$ = 12                                      ; size = 4
  2321. ?deallocate@?$_Wrap_alloc@V?$allocator@N@std@@@std@@QAEXPANI@Z PROC ; std::_Wrap_alloc<std::allocator<double> >::deallocate, COMDAT
  2322. ; _this$dead$ = ecx
  2323.  
  2324. ; 886  :                {       // deallocate object at _Ptr, ignore size
  2325.  
  2326.         push    ebp
  2327.         mov     ebp, esp
  2328.  
  2329. ; 586  :                ::operator delete(_Ptr);
  2330.  
  2331.         push    DWORD PTR __Ptr$[ebp]
  2332.         call    DWORD PTR __imp_??3@YAXPAX@Z
  2333.         add     esp, 4
  2334.  
  2335. ; 887  :                _Mybase::deallocate(_Ptr, _Count);
  2336. ; 888  :                }
  2337.  
  2338.         pop     ebp
  2339.         ret     8
  2340. ?deallocate@?$_Wrap_alloc@V?$allocator@N@std@@@std@@QAEXPANI@Z ENDP ; std::_Wrap_alloc<std::allocator<double> >::deallocate
  2341. _TEXT   ENDS
  2342. ; Function compile flags: /Ogtp
  2343. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  2344. ;       COMDAT ??0?$_Vector_val@U?$_Simple_types@N@std@@@std@@QAE@XZ
  2345. _TEXT   SEGMENT
  2346. ??0?$_Vector_val@U?$_Simple_types@N@std@@@std@@QAE@XZ PROC ; std::_Vector_val<std::_Simple_types<double> >::_Vector_val<std::_Simple_types<double> >, COMDAT
  2347. ; _this$ = ecx
  2348.  
  2349. ; 485  :                {       // initialize values
  2350. ; 486  :                _Myfirst = pointer();
  2351.  
  2352.         mov     DWORD PTR [ecx], 0
  2353.  
  2354. ; 487  :                _Mylast = pointer();
  2355.  
  2356.         mov     DWORD PTR [ecx+4], 0
  2357.  
  2358. ; 488  :                _Myend = pointer();
  2359.  
  2360.         mov     DWORD PTR [ecx+8], 0
  2361.  
  2362. ; 489  :                }
  2363.  
  2364.         mov     eax, ecx
  2365.         ret     0
  2366. ??0?$_Vector_val@U?$_Simple_types@N@std@@@std@@QAE@XZ ENDP ; std::_Vector_val<std::_Simple_types<double> >::_Vector_val<std::_Simple_types<double> >
  2367. _TEXT   ENDS
  2368. ; Function compile flags: /Ogtp
  2369. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  2370. ;       COMDAT ??H?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE?AV01@H@Z
  2371. _TEXT   SEGMENT
  2372. ___$ReturnUdt$ = 8                                      ; size = 4
  2373. __Off$ = 12                                             ; size = 4
  2374. ??H?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE?AV01@H@Z PROC ; std::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator+, COMDAT
  2375. ; _this$ = ecx
  2376.  
  2377. ; 365  :                {       // return this + integer
  2378.  
  2379.         push    ebp
  2380.         mov     ebp, esp
  2381.  
  2382. ; 170  :                _Ptr += _Off;
  2383.  
  2384.         mov     eax, DWORD PTR __Off$[ebp]
  2385.         mov     ecx, DWORD PTR [ecx]
  2386.         lea     ecx, DWORD PTR [ecx+eax*8]
  2387.  
  2388. ; 366  :                _Myiter _Tmp = *this;
  2389. ; 367  :                return (_Tmp += _Off);
  2390.  
  2391.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  2392.         mov     DWORD PTR [eax], ecx
  2393.  
  2394. ; 368  :                }
  2395.  
  2396.         pop     ebp
  2397.         ret     8
  2398. ??H?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE?AV01@H@Z ENDP ; std::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator+
  2399. _TEXT   ENDS
  2400. ; Function compile flags: /Ogtp
  2401. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2402. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  2403. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2404. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  2405. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2406. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  2407. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2408. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  2409. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2410. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  2411. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2412. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  2413. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2414. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  2415. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2416. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  2417. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2418. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  2419. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  2420. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2421. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  2422. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  2423. ;       COMDAT ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@ABV12@II@Z
  2424. _TEXT   SEGMENT
  2425. __Right$ = 8                                            ; size = 4
  2426. __Roff$ = 12                                            ; size = 4
  2427. __Count$ = 16                                           ; size = 4
  2428. ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@ABV12@II@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign, COMDAT
  2429. ; _this$ = ecx
  2430.  
  2431. ; 1104 :                {       // assign _Right [_Roff, _Roff + _Count)
  2432.  
  2433.         push    ebp
  2434.         mov     ebp, esp
  2435.         push    ebx
  2436.  
  2437. ; 1105 :                if (_Right.size() < _Roff)
  2438.  
  2439.         mov     ebx, DWORD PTR __Right$[ebp]
  2440.         push    esi
  2441.         push    edi
  2442.         mov     edi, DWORD PTR [ebx+16]
  2443.         mov     esi, ecx
  2444.         mov     ecx, DWORD PTR __Roff$[ebp]
  2445.         cmp     edi, ecx
  2446.         jae     SHORT $LN5@assign
  2447.  
  2448. ; 2219 :                }
  2449. ; 2220 :
  2450. ; 2221 :        bool _Grow(size_type _Newsize,
  2451. ; 2222 :                bool _Trim = false)
  2452. ; 2223 :                {       // ensure buffer is big enough, trim to size if _Trim is true
  2453. ; 2224 :                if (max_size() < _Newsize)
  2454. ; 2225 :                        _Xlen();        // result too long
  2455. ; 2226 :                if (this->_Myres < _Newsize)
  2456. ; 2227 :                        _Copy(_Newsize, this->_Mysize); // reallocate to grow
  2457. ; 2228 :                else if (_Trim && _Newsize < this->_BUF_SIZE)
  2458. ; 2229 :                        _Tidy(true,     // copy and deallocate if trimming to small string
  2459. ; 2230 :                                _Newsize < this->_Mysize ? _Newsize : this->_Mysize);
  2460. ; 2231 :                else if (_Newsize == 0)
  2461. ; 2232 :                        _Eos(0);        // new size is zero, just null terminate
  2462. ; 2233 :                return (0 < _Newsize);  // return true only if more work to do
  2463. ; 2234 :                }
  2464. ; 2235 :
  2465. ; 2236 :        bool _Inside(const _Elem *_Ptr)
  2466. ; 2237 :                {       // test if _Ptr points inside string
  2467. ; 2238 :                if (_Ptr == 0 || _Ptr < this->_Myptr()
  2468. ; 2239 :                        || this->_Myptr() + this->_Mysize <= _Ptr)
  2469. ; 2240 :                        return (false); // don't ask
  2470. ; 2241 :                else
  2471. ; 2242 :                        return (true);
  2472. ; 2243 :                }
  2473. ; 2244 :
  2474. ; 2245 :        static size_type _Pdif(const_iterator _P2,
  2475. ; 2246 :                const_iterator _P1)
  2476. ; 2247 :                {       // compute safe iterator difference
  2477. ; 2248 :                return (_STRING_ITER_BASE(_P2) == 0 ? 0 : _P2 - _P1);
  2478. ; 2249 :                }
  2479. ; 2250 :
  2480. ; 2251 :        void _Tidy(bool _Built = false,
  2481. ; 2252 :                size_type _Newsize = 0)
  2482. ; 2253 :                {       // initialize buffer, deallocating any storage
  2483. ; 2254 :                if (!_Built)
  2484. ; 2255 :                        ;
  2485. ; 2256 :                else if (this->_BUF_SIZE <= this->_Myres)
  2486. ; 2257 :                        {       // copy any leftovers to small buffer and deallocate
  2487. ; 2258 :                        pointer _Ptr = this->_Bx._Ptr;
  2488. ; 2259 :                        this->_Getal().destroy(&this->_Bx._Ptr);
  2489. ; 2260 :                        if (0 < _Newsize)
  2490. ; 2261 :                                _Traits::copy(this->_Bx._Buf,
  2491. ; 2262 :                                        _STD addressof(*_Ptr), _Newsize);
  2492. ; 2263 :                        this->_Getal().deallocate(_Ptr, this->_Myres + 1);
  2493. ; 2264 :                        }
  2494. ; 2265 :                this->_Myres = this->_BUF_SIZE - 1;
  2495. ; 2266 :                _Eos(_Newsize);
  2496. ; 2267 :                }
  2497. ; 2268 :
  2498. ; 2269 :        __declspec(noreturn) void _Xlen() const
  2499. ; 2270 :                {       // report a length_error
  2500. ; 2271 :                _Xlength_error("string too long");
  2501. ; 2272 :                }
  2502. ; 2273 :
  2503. ; 2274 :        __declspec(noreturn) void _Xran() const
  2504. ; 2275 :                {       // report an out_of_range error
  2505. ; 2276 :                _Xout_of_range("invalid string position");
  2506.  
  2507.         push    OFFSET ??_C@_0BI@CFPLBAOH@invalid?5string?5position?$AA@
  2508.         call    DWORD PTR __imp_?_Xout_of_range@std@@YAXPBD@Z
  2509. $LN59@assign:
  2510. $LN5@assign:
  2511.  
  2512. ; 1106 :                        _Xran();        // _Roff off end
  2513. ; 1107 :                size_type _Num = _Right.size() - _Roff;
  2514.  
  2515.         sub     edi, ecx
  2516.  
  2517. ; 1108 :                if (_Count < _Num)
  2518.  
  2519.         cmp     DWORD PTR __Count$[ebp], edi
  2520.         cmovb   edi, DWORD PTR __Count$[ebp]
  2521.  
  2522. ; 1109 :                        _Num = _Count;  // trim _Num to size
  2523. ; 1110 :
  2524. ; 1111 :                if (this == &_Right)
  2525.  
  2526.         cmp     esi, ebx
  2527.         jne     SHORT $LN3@assign
  2528.  
  2529. ; 1112 :                        erase((size_type)(_Roff + _Num)), erase(0, _Roff);      // substring
  2530.  
  2531.         lea     eax, DWORD PTR [edi+ecx]
  2532.  
  2533. ; 1121 :
  2534. ; 1122 :        _Myt& assign(const _Elem *_Ptr, size_type _Count)
  2535. ; 1123 :                {       // assign [_Ptr, _Ptr + _Count)
  2536. ; 1124 :  #if _ITERATOR_DEBUG_LEVEL == 2
  2537. ; 1125 :                if (_Count != 0)
  2538. ; 1126 :                        _DEBUG_POINTER(_Ptr);
  2539. ; 1127 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  2540. ; 1128 :
  2541. ; 1129 :                if (_Inside(_Ptr))
  2542. ; 1130 :                        return (assign(*this,
  2543. ; 1131 :                                _Ptr - this->_Myptr(), _Count));        // substring
  2544. ; 1132 :
  2545. ; 1133 :                if (_Grow(_Count))
  2546. ; 1134 :                        {       // make room and assign new stuff
  2547. ; 1135 :                        _Traits::copy(this->_Myptr(), _Ptr, _Count);
  2548. ; 1136 :                        _Eos(_Count);
  2549. ; 1137 :                        }
  2550. ; 1138 :                return (*this);
  2551. ; 1139 :                }
  2552. ; 1140 :
  2553. ; 1141 :        _Myt& assign(const _Elem *_Ptr)
  2554. ; 1142 :                {       // assign [_Ptr, <null>)
  2555. ; 1143 :                _DEBUG_POINTER(_Ptr);
  2556. ; 1144 :                return (assign(_Ptr, _Traits::length(_Ptr)));
  2557. ; 1145 :                }
  2558. ; 1146 :
  2559. ; 1147 :        _Myt& assign(size_type _Count, _Elem _Ch)
  2560. ; 1148 :                {       // assign _Count * _Ch
  2561. ; 1149 :                if (_Count == npos)
  2562. ; 1150 :                        _Xlen();        // result too long
  2563. ; 1151 :
  2564. ; 1152 :                if (_Grow(_Count))
  2565. ; 1153 :                        {       // make room and assign new stuff
  2566. ; 1154 :                        _Chassign(0, _Count, _Ch);
  2567. ; 1155 :                        _Eos(_Count);
  2568. ; 1156 :                        }
  2569. ; 1157 :                return (*this);
  2570. ; 1158 :                }
  2571. ; 1159 :
  2572. ; 1160 :        template<class _Iter>
  2573. ; 1161 :                typename enable_if<_Is_iterator<_Iter>::value,
  2574. ; 1162 :                        _Myt&>::type
  2575. ; 1163 :                assign(_Iter _First, _Iter _Last)
  2576. ; 1164 :                {       // assign [First, _Last), input iterators
  2577. ; 1165 :                return (replace(begin(), end(), _First, _Last));
  2578. ; 1166 :                }
  2579. ; 1167 :
  2580. ; 1168 :        _Myt& assign(const_pointer _First, const_pointer _Last)
  2581. ; 1169 :                {       // assign [First, _Last), const pointers
  2582. ; 1170 :                return (replace(begin(), end(), _First, _Last));
  2583. ; 1171 :                }
  2584. ; 1172 :
  2585. ; 1173 :        _Myt& assign(const_iterator _First, const_iterator _Last)
  2586. ; 1174 :                {       // assign [First, _Last), const_iterators
  2587. ; 1175 :                return (replace(begin(), end(), _First, _Last));
  2588. ; 1176 :                }
  2589. ; 1177 :
  2590. ; 1178 :        _Myt& insert(size_type _Off, const _Myt& _Right)
  2591. ; 1179 :                {       // insert _Right at _Off
  2592. ; 1180 :                return (insert(_Off, _Right, 0, npos));
  2593. ; 1181 :                }
  2594. ; 1182 :
  2595. ; 1183 :        _Myt& insert(size_type _Off,
  2596. ; 1184 :                const _Myt& _Right, size_type _Roff, size_type _Count)
  2597. ; 1185 :                {       // insert _Right [_Roff, _Roff + _Count) at _Off
  2598. ; 1186 :                if (this->_Mysize < _Off || _Right.size() < _Roff)
  2599. ; 1187 :                        _Xran();        // _Off or _Roff off end
  2600. ; 1188 :                size_type _Num = _Right.size() - _Roff;
  2601. ; 1189 :                if (_Num < _Count)
  2602. ; 1190 :                        _Count = _Num;  // trim _Count to size
  2603. ; 1191 :                if (npos - this->_Mysize <= _Count)
  2604. ; 1192 :                        _Xlen();        // result too long
  2605. ; 1193 :
  2606. ; 1194 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  2607. ; 1195 :                        {       // make room and insert new stuff
  2608. ; 1196 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2609. ; 1197 :                                this->_Myptr() + _Off,
  2610. ; 1198 :                                this->_Mysize - _Off);  // empty out hole
  2611. ; 1199 :                        if (this == &_Right)
  2612. ; 1200 :                                _Traits::move(this->_Myptr() + _Off,
  2613. ; 1201 :                                        this->_Myptr() + (_Off < _Roff ? _Roff + _Count : _Roff),
  2614. ; 1202 :                                                _Count);        // substring
  2615. ; 1203 :                        else
  2616. ; 1204 :                                _Traits::copy(this->_Myptr() + _Off,
  2617. ; 1205 :                                        _Right._Myptr() + _Roff, _Count);       // fill hole
  2618. ; 1206 :                        _Eos(_Num);
  2619. ; 1207 :                        }
  2620. ; 1208 :                return (*this);
  2621. ; 1209 :                }
  2622. ; 1210 :
  2623. ; 1211 :        _Myt& insert(size_type _Off,
  2624. ; 1212 :                const _Elem *_Ptr, size_type _Count)
  2625. ; 1213 :                {       // insert [_Ptr, _Ptr + _Count) at _Off
  2626. ; 1214 :  #if _ITERATOR_DEBUG_LEVEL == 2
  2627. ; 1215 :                if (_Count != 0)
  2628. ; 1216 :                        _DEBUG_POINTER(_Ptr);
  2629. ; 1217 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  2630. ; 1218 :
  2631. ; 1219 :                if (_Inside(_Ptr))
  2632. ; 1220 :                        return (insert(_Off, *this,
  2633. ; 1221 :                                _Ptr - this->_Myptr(), _Count));        // substring
  2634. ; 1222 :                if (this->_Mysize < _Off)
  2635. ; 1223 :                        _Xran();        // _Off off end
  2636. ; 1224 :                if (npos - this->_Mysize <= _Count)
  2637. ; 1225 :                        _Xlen();        // result too long
  2638. ; 1226 :                size_type _Num;
  2639. ; 1227 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  2640. ; 1228 :                        {       // make room and insert new stuff
  2641. ; 1229 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2642. ; 1230 :                                this->_Myptr() + _Off,
  2643. ; 1231 :                                this->_Mysize - _Off);  // empty out hole
  2644. ; 1232 :                        _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count);     // fill hole
  2645. ; 1233 :                        _Eos(_Num);
  2646. ; 1234 :                        }
  2647. ; 1235 :                return (*this);
  2648. ; 1236 :                }
  2649. ; 1237 :
  2650. ; 1238 :        _Myt& insert(size_type _Off, const _Elem *_Ptr)
  2651. ; 1239 :                {       // insert [_Ptr, <null>) at _Off
  2652. ; 1240 :                _DEBUG_POINTER(_Ptr);
  2653. ; 1241 :                return (insert(_Off, _Ptr, _Traits::length(_Ptr)));
  2654. ; 1242 :                }
  2655. ; 1243 :
  2656. ; 1244 :        _Myt& insert(size_type _Off,
  2657. ; 1245 :                size_type _Count, _Elem _Ch)
  2658. ; 1246 :                {       // insert _Count * _Ch at _Off
  2659. ; 1247 :                if (this->_Mysize < _Off)
  2660. ; 1248 :                        _Xran();        // _Off off end
  2661. ; 1249 :                if (npos - this->_Mysize <= _Count)
  2662. ; 1250 :                        _Xlen();        // result too long
  2663. ; 1251 :                size_type _Num;
  2664. ; 1252 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  2665. ; 1253 :                        {       // make room and insert new stuff
  2666. ; 1254 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2667. ; 1255 :                                this->_Myptr() + _Off,
  2668. ; 1256 :                                this->_Mysize - _Off);  // empty out hole
  2669. ; 1257 :                        _Chassign(_Off, _Count, _Ch);   // fill hole
  2670. ; 1258 :                        _Eos(_Num);
  2671. ; 1259 :                        }
  2672. ; 1260 :                return (*this);
  2673. ; 1261 :                }
  2674. ; 1262 :
  2675. ; 1263 :        iterator insert(const_iterator _Where)
  2676. ; 1264 :                {       // insert <null> at _Where
  2677. ; 1265 :                return (insert(_Where, _Elem()));
  2678. ; 1266 :                }
  2679. ; 1267 :
  2680. ; 1268 :        iterator insert(const_iterator _Where, _Elem _Ch)
  2681. ; 1269 :                {       // insert _Ch at _Where
  2682. ; 1270 :                size_type _Off = _Pdif(_Where, begin());
  2683. ; 1271 :                insert(_Off, 1, _Ch);
  2684. ; 1272 :                return (begin() + _Off);
  2685. ; 1273 :                }
  2686. ; 1274 :
  2687. ; 1275 :        iterator insert(const_iterator _Where, size_type _Count, _Elem _Ch)
  2688. ; 1276 :                {       // insert _Count * _Elem at _Where
  2689. ; 1277 :                size_type _Off = _Pdif(_Where, begin());
  2690. ; 1278 :                insert(_Off, _Count, _Ch);
  2691. ; 1279 :                return (begin() + _Off);
  2692. ; 1280 :                }
  2693. ; 1281 :
  2694. ; 1282 :        template<class _Iter>
  2695. ; 1283 :                typename enable_if<_Is_iterator<_Iter>::value,
  2696. ; 1284 :                        iterator>::type
  2697. ; 1285 :                insert(const_iterator _Where, _Iter _First, _Iter _Last)
  2698. ; 1286 :                {       // insert [_First, _Last) at _Where, input iterators
  2699. ; 1287 :                size_type _Off = _Pdif(_Where, begin());
  2700. ; 1288 :                replace(_Where, _Where, _First, _Last);
  2701. ; 1289 :                return (begin() + _Off);
  2702. ; 1290 :                }
  2703. ; 1291 :
  2704. ; 1292 :        iterator insert(const_iterator _Where,
  2705. ; 1293 :                const_pointer _First, const_pointer _Last)
  2706. ; 1294 :                {       // insert [_First, _Last) at _Where, const pointers
  2707. ; 1295 :                size_type _Off = _Pdif(_Where, begin());
  2708. ; 1296 :                replace(_Where, _Where, _First, _Last);
  2709. ; 1297 :                return (begin() + _Off);
  2710. ; 1298 :                }
  2711. ; 1299 :
  2712. ; 1300 :        iterator insert(const_iterator _Where,
  2713. ; 1301 :                const_iterator _First, const_iterator _Last)
  2714. ; 1302 :                {       // insert [_First, _Last) at _Where, const_iterators
  2715. ; 1303 :                size_type _Off = _Pdif(_Where, begin());
  2716. ; 1304 :                replace(_Where, _Where, _First, _Last);
  2717. ; 1305 :                return (begin() + _Off);
  2718. ; 1306 :                }
  2719. ; 1307 :
  2720. ; 1308 :        _Myt& erase(size_type _Off = 0)
  2721. ; 1309 :                {       // erase elements [_Off, ...)
  2722. ; 1310 :                if (this->_Mysize < _Off)
  2723.  
  2724.         cmp     DWORD PTR [esi+16], eax
  2725.         jae     SHORT $LN15@assign
  2726.  
  2727. ; 2219 :                }
  2728. ; 2220 :
  2729. ; 2221 :        bool _Grow(size_type _Newsize,
  2730. ; 2222 :                bool _Trim = false)
  2731. ; 2223 :                {       // ensure buffer is big enough, trim to size if _Trim is true
  2732. ; 2224 :                if (max_size() < _Newsize)
  2733. ; 2225 :                        _Xlen();        // result too long
  2734. ; 2226 :                if (this->_Myres < _Newsize)
  2735. ; 2227 :                        _Copy(_Newsize, this->_Mysize); // reallocate to grow
  2736. ; 2228 :                else if (_Trim && _Newsize < this->_BUF_SIZE)
  2737. ; 2229 :                        _Tidy(true,     // copy and deallocate if trimming to small string
  2738. ; 2230 :                                _Newsize < this->_Mysize ? _Newsize : this->_Mysize);
  2739. ; 2231 :                else if (_Newsize == 0)
  2740. ; 2232 :                        _Eos(0);        // new size is zero, just null terminate
  2741. ; 2233 :                return (0 < _Newsize);  // return true only if more work to do
  2742. ; 2234 :                }
  2743. ; 2235 :
  2744. ; 2236 :        bool _Inside(const _Elem *_Ptr)
  2745. ; 2237 :                {       // test if _Ptr points inside string
  2746. ; 2238 :                if (_Ptr == 0 || _Ptr < this->_Myptr()
  2747. ; 2239 :                        || this->_Myptr() + this->_Mysize <= _Ptr)
  2748. ; 2240 :                        return (false); // don't ask
  2749. ; 2241 :                else
  2750. ; 2242 :                        return (true);
  2751. ; 2243 :                }
  2752. ; 2244 :
  2753. ; 2245 :        static size_type _Pdif(const_iterator _P2,
  2754. ; 2246 :                const_iterator _P1)
  2755. ; 2247 :                {       // compute safe iterator difference
  2756. ; 2248 :                return (_STRING_ITER_BASE(_P2) == 0 ? 0 : _P2 - _P1);
  2757. ; 2249 :                }
  2758. ; 2250 :
  2759. ; 2251 :        void _Tidy(bool _Built = false,
  2760. ; 2252 :                size_type _Newsize = 0)
  2761. ; 2253 :                {       // initialize buffer, deallocating any storage
  2762. ; 2254 :                if (!_Built)
  2763. ; 2255 :                        ;
  2764. ; 2256 :                else if (this->_BUF_SIZE <= this->_Myres)
  2765. ; 2257 :                        {       // copy any leftovers to small buffer and deallocate
  2766. ; 2258 :                        pointer _Ptr = this->_Bx._Ptr;
  2767. ; 2259 :                        this->_Getal().destroy(&this->_Bx._Ptr);
  2768. ; 2260 :                        if (0 < _Newsize)
  2769. ; 2261 :                                _Traits::copy(this->_Bx._Buf,
  2770. ; 2262 :                                        _STD addressof(*_Ptr), _Newsize);
  2771. ; 2263 :                        this->_Getal().deallocate(_Ptr, this->_Myres + 1);
  2772. ; 2264 :                        }
  2773. ; 2265 :                this->_Myres = this->_BUF_SIZE - 1;
  2774. ; 2266 :                _Eos(_Newsize);
  2775. ; 2267 :                }
  2776. ; 2268 :
  2777. ; 2269 :        __declspec(noreturn) void _Xlen() const
  2778. ; 2270 :                {       // report a length_error
  2779. ; 2271 :                _Xlength_error("string too long");
  2780. ; 2272 :                }
  2781. ; 2273 :
  2782. ; 2274 :        __declspec(noreturn) void _Xran() const
  2783. ; 2275 :                {       // report an out_of_range error
  2784. ; 2276 :                _Xout_of_range("invalid string position");
  2785.  
  2786.         push    OFFSET ??_C@_0BI@CFPLBAOH@invalid?5string?5position?$AA@
  2787.         call    DWORD PTR __imp_?_Xout_of_range@std@@YAXPBD@Z
  2788. $LN60@assign:
  2789. $LN15@assign:
  2790.  
  2791. ; 517  :                        : this->_Bx._Buf);
  2792.  
  2793.         cmp     DWORD PTR [esi+20], 16                  ; 00000010H
  2794.  
  2795. ; 1311 :                        _Xran();        // _Off off end
  2796. ; 1312 :                _Eos(_Off);
  2797. ; 1313 :                return (*this);
  2798. ; 1314 :                }
  2799. ; 1315 :
  2800. ; 1316 :        _Myt& erase(size_type _Off, size_type _Count)
  2801. ; 1317 :                {       // erase elements [_Off, _Off + _Count)
  2802. ; 1318 :                if (this->_Mysize < _Off)
  2803. ; 1319 :                        _Xran();        // _Off off end
  2804. ; 1320 :                if (this->_Mysize - _Off <= _Count)
  2805. ; 1321 :                        _Eos(_Off);     // erase elements [_Off, ...)
  2806. ; 1322 :                else if (0 < _Count)
  2807. ; 1323 :                        {       // move elements down
  2808. ; 1324 :                        value_type *_Ptr = this->_Myptr() + _Off;
  2809. ; 1325 :                        size_type _Newsize = this->_Mysize - _Count;
  2810. ; 1326 :                        _Traits::move(_Ptr, _Ptr + _Count, _Newsize - _Off);
  2811. ; 1327 :                        _Eos(_Newsize);
  2812. ; 1328 :                        }
  2813. ; 1329 :                return (*this);
  2814. ; 1330 :                }
  2815. ; 1331 :
  2816. ; 1332 :        iterator erase(const_iterator _Where)
  2817. ; 1333 :                {       // erase element at _Where
  2818. ; 1334 :                size_type _Count = _Pdif(_Where, begin());
  2819. ; 1335 :                erase(_Count, 1);
  2820. ; 1336 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  2821. ; 1337 :                }
  2822. ; 1338 :
  2823. ; 1339 :        iterator erase(const_iterator _First, const_iterator _Last)
  2824. ; 1340 :                {       // erase substring [_First, _Last)
  2825. ; 1341 :                _DEBUG_RANGE(_First, _Last);
  2826. ; 1342 :                size_type _Count = _Pdif(_First, begin());
  2827. ; 1343 :                erase(_Count, _Pdif(_Last, _First));
  2828. ; 1344 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  2829. ; 1345 :                }
  2830. ; 1346 :
  2831. ; 1347 :        void clear() _NOEXCEPT
  2832. ; 1348 :                {       // erase all
  2833. ; 1349 :                _Eos(0);
  2834. ; 1350 :                }
  2835. ; 1351 :
  2836. ; 1352 :        _Myt& replace(size_type _Off, size_type _N0, const _Myt& _Right)
  2837. ; 1353 :                {       // replace [_Off, _Off + _N0) with _Right
  2838. ; 1354 :                return (replace(_Off, _N0, _Right, 0, npos));
  2839. ; 1355 :                }
  2840. ; 1356 :
  2841. ; 1357 :        _Myt& replace(size_type _Off,
  2842. ; 1358 :                size_type _N0, const _Myt& _Right, size_type _Roff, size_type _Count)
  2843. ; 1359 :                {       // replace [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
  2844. ; 1360 :                if (this->_Mysize < _Off || _Right.size() < _Roff)
  2845. ; 1361 :                        _Xran();        // _Off or _Roff off end
  2846. ; 1362 :                if (this->_Mysize - _Off < _N0)
  2847. ; 1363 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  2848. ; 1364 :                size_type _Num = _Right.size() - _Roff;
  2849. ; 1365 :                if (_Num < _Count)
  2850. ; 1366 :                        _Count = _Num;  // trim _Count to size
  2851. ; 1367 :                if (npos - _Count <= this->_Mysize - _N0)
  2852. ; 1368 :                        _Xlen();        // result too long
  2853. ; 1369 :
  2854. ; 1370 :                size_type _Nm = this->_Mysize - _N0 - _Off;     // length of kept tail
  2855. ; 1371 :                size_type _Newsize = this->_Mysize + _Count - _N0;
  2856. ; 1372 :                if (this->_Mysize < _Newsize)
  2857. ; 1373 :                        _Grow(_Newsize);
  2858. ; 1374 :
  2859. ; 1375 :                if (this != &_Right)
  2860. ; 1376 :                        {       // no overlap, just move down and copy in new stuff
  2861. ; 1377 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2862. ; 1378 :                                this->_Myptr() + _Off + _N0, _Nm);      // empty hole
  2863. ; 1379 :                        _Traits::copy(this->_Myptr() + _Off,
  2864. ; 1380 :                                _Right._Myptr() + _Roff, _Count);       // fill hole
  2865. ; 1381 :                        }
  2866. ; 1382 :                else if (_Count <= _N0)
  2867. ; 1383 :                        {       // hole doesn't get larger, just copy in substring
  2868. ; 1384 :                        _Traits::move(this->_Myptr() + _Off,
  2869. ; 1385 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  2870. ; 1386 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2871. ; 1387 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  2872. ; 1388 :                        }
  2873. ; 1389 :                else if (_Roff <= _Off)
  2874. ; 1390 :                        {       // hole gets larger, substring begins before hole
  2875. ; 1391 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2876. ; 1392 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  2877. ; 1393 :                        _Traits::move(this->_Myptr() + _Off,
  2878. ; 1394 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  2879. ; 1395 :                        }
  2880. ; 1396 :                else if (_Off + _N0 <= _Roff)
  2881. ; 1397 :                        {       // hole gets larger, substring begins after hole
  2882. ; 1398 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2883. ; 1399 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  2884. ; 1400 :                        _Traits::move(this->_Myptr() + _Off,
  2885. ; 1401 :                                this->_Myptr() + (_Roff + _Count - _N0),
  2886. ; 1402 :                                _Count);        // fill hole
  2887. ; 1403 :                        }
  2888. ; 1404 :                else
  2889. ; 1405 :                        {       // hole gets larger, substring begins in hole
  2890. ; 1406 :                        _Traits::move(this->_Myptr() + _Off,
  2891. ; 1407 :                                this->_Myptr() + _Roff, _N0);   // fill old hole
  2892. ; 1408 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2893. ; 1409 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  2894. ; 1410 :                        _Traits::move(this->_Myptr() + _Off + _N0,
  2895. ; 1411 :                                this->_Myptr() + _Roff + _Count,
  2896. ; 1412 :                                _Count - _N0);  // fill rest of new hole
  2897. ; 1413 :                        }
  2898. ; 1414 :
  2899. ; 1415 :                _Eos(_Newsize);
  2900. ; 1416 :                return (*this);
  2901. ; 1417 :                }
  2902. ; 1418 :
  2903. ; 1419 :        _Myt& replace(size_type _Off,
  2904. ; 1420 :                size_type _N0, const _Elem *_Ptr, size_type _Count)
  2905. ; 1421 :                {       // replace [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
  2906. ; 1422 :  #if _ITERATOR_DEBUG_LEVEL == 2
  2907. ; 1423 :                if (_Count != 0)
  2908. ; 1424 :                        _DEBUG_POINTER(_Ptr);
  2909. ; 1425 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  2910. ; 1426 :
  2911. ; 1427 :                if (_Inside(_Ptr))
  2912. ; 1428 :                        return (replace(_Off, _N0, *this,
  2913. ; 1429 :                                _Ptr - this->_Myptr(),
  2914. ; 1430 :                                _Count));       // substring, replace carefully
  2915. ; 1431 :                if (this->_Mysize < _Off)
  2916. ; 1432 :                        _Xran();        // _Off off end
  2917. ; 1433 :                if (this->_Mysize - _Off < _N0)
  2918. ; 1434 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  2919. ; 1435 :                if (npos - _Count <= this->_Mysize - _N0)
  2920. ; 1436 :                        _Xlen();        // result too long
  2921. ; 1437 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  2922. ; 1438 :
  2923. ; 1439 :                if (_Count < _N0)
  2924. ; 1440 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2925. ; 1441 :                                this->_Myptr() + _Off + _N0,
  2926. ; 1442 :                                _Nm);   // smaller hole, move tail up
  2927. ; 1443 :                size_type _Num;
  2928. ; 1444 :                if ((0 < _Count || 0 < _N0)
  2929. ; 1445 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  2930. ; 1446 :                        {       // make room and rearrange
  2931. ; 1447 :                        if (_N0 < _Count)
  2932. ; 1448 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  2933. ; 1449 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  2934. ; 1450 :                        _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count);     // fill hole
  2935. ; 1451 :                        _Eos(_Num);
  2936. ; 1452 :                        }
  2937. ; 1453 :                return (*this);
  2938. ; 1454 :                }
  2939. ; 1455 :
  2940. ; 1456 :        _Myt& replace(size_type _Off, size_type _N0, const _Elem *_Ptr)
  2941. ; 1457 :                {       // replace [_Off, _Off + _N0) with [_Ptr, <null>)
  2942. ; 1458 :                _DEBUG_POINTER(_Ptr);
  2943. ; 1459 :                return (replace(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
  2944. ; 1460 :                }
  2945. ; 1461 :
  2946. ; 1462 :        _Myt& replace(size_type _Off,
  2947. ; 1463 :                size_type _N0, size_type _Count, _Elem _Ch)
  2948. ; 1464 :                {       // replace [_Off, _Off + _N0) with _Count * _Ch
  2949. ; 1465 :                if (this->_Mysize < _Off)
  2950. ; 1466 :                        _Xran();        // _Off off end
  2951. ; 1467 :                if (this->_Mysize - _Off < _N0)
  2952. ; 1468 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  2953. ; 1469 :                if (npos - _Count <= this->_Mysize - _N0)
  2954. ; 1470 :                        _Xlen();        // result too long
  2955. ; 1471 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  2956. ; 1472 :
  2957. ; 1473 :                if (_Count < _N0)
  2958. ; 1474 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  2959. ; 1475 :                                this->_Myptr() + _Off + _N0,
  2960. ; 1476 :                                _Nm);   // smaller hole, move tail up
  2961. ; 1477 :                size_type _Num;
  2962. ; 1478 :                if ((0 < _Count || 0 < _N0)
  2963. ; 1479 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  2964. ; 1480 :                        {       // make room and rearrange
  2965. ; 1481 :                        if (_N0 < _Count)
  2966. ; 1482 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  2967. ; 1483 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  2968. ; 1484 :                        _Chassign(_Off, _Count, _Ch);   // fill hole
  2969. ; 1485 :                        _Eos(_Num);
  2970. ; 1486 :                        }
  2971. ; 1487 :                return (*this);
  2972. ; 1488 :                }
  2973. ; 1489 :
  2974. ; 1490 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  2975. ; 1491 :                const _Myt& _Right)
  2976. ; 1492 :                {       // replace [_First, _Last) with _Right
  2977. ; 1493 :                return (replace(
  2978. ; 1494 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Right));
  2979. ; 1495 :                }
  2980. ; 1496 :
  2981. ; 1497 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  2982. ; 1498 :                const _Elem *_Ptr, size_type _Count)
  2983. ; 1499 :                {       // replace [_First, _Last) with [_Ptr, _Ptr + _Count)
  2984. ; 1500 :                return (replace(
  2985. ; 1501 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr, _Count));
  2986. ; 1502 :                }
  2987. ; 1503 :
  2988. ; 1504 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  2989. ; 1505 :                const _Elem *_Ptr)
  2990. ; 1506 :                {       // replace [_First, _Last) with [_Ptr, <null>)
  2991. ; 1507 :                return (replace(
  2992. ; 1508 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr));
  2993. ; 1509 :                }
  2994. ; 1510 :
  2995. ; 1511 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  2996. ; 1512 :                size_type _Count, _Elem _Ch)
  2997. ; 1513 :                {       // replace [_First, _Last) with _Count * _Ch
  2998. ; 1514 :                return (replace(
  2999. ; 1515 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Count, _Ch));
  3000. ; 1516 :                }
  3001. ; 1517 :
  3002. ; 1518 :        template<class _Iter>
  3003. ; 1519 :                typename enable_if<_Is_iterator<_Iter>::value,
  3004. ; 1520 :                        _Myt&>::type
  3005. ; 1521 :                replace(const_iterator _First, const_iterator _Last,
  3006. ; 1522 :                        _Iter _First2, _Iter _Last2)
  3007. ; 1523 :                {       // replace [_First, _Last) with [_First2, _Last2), input iterators
  3008. ; 1524 :                _Myt _Right(_First2, _Last2);
  3009. ; 1525 :                replace(_First, _Last, _Right);
  3010. ; 1526 :                return (*this);
  3011. ; 1527 :                }
  3012. ; 1528 :
  3013. ; 1529 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  3014. ; 1530 :                const_pointer _First2, const_pointer _Last2)
  3015. ; 1531 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  3016. ; 1532 :                if (_First2 == _Last2)
  3017. ; 1533 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  3018. ; 1534 :                else
  3019. ; 1535 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  3020. ; 1536 :                                &*_First2, _Last2 - _First2);
  3021. ; 1537 :                return (*this);
  3022. ; 1538 :                }
  3023. ; 1539 :
  3024. ; 1540 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  3025. ; 1541 :                pointer _First2, pointer _Last2)
  3026. ; 1542 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  3027. ; 1543 :                if (_First2 == _Last2)
  3028. ; 1544 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  3029. ; 1545 :                else
  3030. ; 1546 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  3031. ; 1547 :                                &*_First2, _Last2 - _First2);
  3032. ; 1548 :                return (*this);
  3033. ; 1549 :                }
  3034. ; 1550 :
  3035. ; 1551 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  3036. ; 1552 :                const_iterator _First2, const_iterator _Last2)
  3037. ; 1553 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  3038. ; 1554 :                if (_First2 == _Last2)
  3039. ; 1555 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  3040. ; 1556 :                else
  3041. ; 1557 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  3042. ; 1558 :                                &*_First2, _Last2 - _First2);
  3043. ; 1559 :                return (*this);
  3044. ; 1560 :                }
  3045. ; 1561 :
  3046. ; 1562 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  3047. ; 1563 :                iterator _First2, iterator _Last2)
  3048. ; 1564 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  3049. ; 1565 :                if (_First2 == _Last2)
  3050. ; 1566 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  3051. ; 1567 :                else
  3052. ; 1568 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  3053. ; 1569 :                                &*_First2, _Last2 - _First2);
  3054. ; 1570 :                return (*this);
  3055. ; 1571 :                }
  3056. ; 1572 :
  3057. ; 1573 :        iterator begin() _NOEXCEPT
  3058. ; 1574 :                {       // return iterator for beginning of mutable sequence
  3059. ; 1575 :                return (_STRING_ITERATOR(this->_Myptr()));
  3060. ; 1576 :                }
  3061. ; 1577 :
  3062. ; 1578 :        const_iterator begin() const _NOEXCEPT
  3063. ; 1579 :                {       // return iterator for beginning of nonmutable sequence
  3064. ; 1580 :                return (_STRING_CONST_ITERATOR(this->_Myptr()));
  3065. ; 1581 :                }
  3066. ; 1582 :
  3067. ; 1583 :        iterator end() _NOEXCEPT
  3068. ; 1584 :                {       // return iterator for end of mutable sequence
  3069. ; 1585 :                return (_STRING_ITERATOR(this->_Myptr() + this->_Mysize));
  3070. ; 1586 :                }
  3071. ; 1587 :
  3072. ; 1588 :        const_iterator end() const _NOEXCEPT
  3073. ; 1589 :                {       // return iterator for end of nonmutable sequence
  3074. ; 1590 :                return (_STRING_CONST_ITERATOR(this->_Myptr() + this->_Mysize));
  3075. ; 1591 :                }
  3076. ; 1592 :
  3077. ; 1593 :        reverse_iterator rbegin() _NOEXCEPT
  3078. ; 1594 :                {       // return iterator for beginning of reversed mutable sequence
  3079. ; 1595 :                return (reverse_iterator(end()));
  3080. ; 1596 :                }
  3081. ; 1597 :
  3082. ; 1598 :        const_reverse_iterator rbegin() const _NOEXCEPT
  3083. ; 1599 :                {       // return iterator for beginning of reversed nonmutable sequence
  3084. ; 1600 :                return (const_reverse_iterator(end()));
  3085. ; 1601 :                }
  3086. ; 1602 :
  3087. ; 1603 :        reverse_iterator rend() _NOEXCEPT
  3088. ; 1604 :                {       // return iterator for end of reversed mutable sequence
  3089. ; 1605 :                return (reverse_iterator(begin()));
  3090. ; 1606 :                }
  3091. ; 1607 :
  3092. ; 1608 :        const_reverse_iterator rend() const _NOEXCEPT
  3093. ; 1609 :                {       // return iterator for end of reversed nonmutable sequence
  3094. ; 1610 :                return (const_reverse_iterator(begin()));
  3095. ; 1611 :                }
  3096. ; 1612 :
  3097. ; 1613 :  #if _HAS_CPP0X
  3098. ; 1614 :        const_iterator cbegin() const _NOEXCEPT
  3099. ; 1615 :                {       // return iterator for beginning of nonmutable sequence
  3100. ; 1616 :                return (((const _Myt *)this)->begin());
  3101. ; 1617 :                }
  3102. ; 1618 :
  3103. ; 1619 :        const_iterator cend() const _NOEXCEPT
  3104. ; 1620 :                {       // return iterator for end of nonmutable sequence
  3105. ; 1621 :                return (((const _Myt *)this)->end());
  3106. ; 1622 :                }
  3107. ; 1623 :
  3108. ; 1624 :        const_reverse_iterator crbegin() const _NOEXCEPT
  3109. ; 1625 :                {       // return iterator for beginning of reversed nonmutable sequence
  3110. ; 1626 :                return (((const _Myt *)this)->rbegin());
  3111. ; 1627 :                }
  3112. ; 1628 :
  3113. ; 1629 :        const_reverse_iterator crend() const _NOEXCEPT
  3114. ; 1630 :                {       // return iterator for end of reversed nonmutable sequence
  3115. ; 1631 :                return (((const _Myt *)this)->rend());
  3116. ; 1632 :                }
  3117. ; 1633 :
  3118. ; 1634 :        void shrink_to_fit()
  3119. ; 1635 :                {       // reduce capacity
  3120. ; 1636 :                if ((size() | this->_ALLOC_MASK) < capacity())
  3121. ; 1637 :                        {       // worth shrinking, do it
  3122. ; 1638 :                        _Myt _Tmp(*this);
  3123. ; 1639 :                        swap(_Tmp);
  3124. ; 1640 :                        }
  3125. ; 1641 :                }
  3126. ; 1642 :  #endif /* _HAS_CPP0X */
  3127. ; 1643 :
  3128. ; 1644 :        reference at(size_type _Off)
  3129. ; 1645 :                {       // subscript mutable sequence with checking
  3130. ; 1646 :                if (this->_Mysize <= _Off)
  3131. ; 1647 :                        _Xran();        // _Off off end
  3132. ; 1648 :                return (this->_Myptr()[_Off]);
  3133. ; 1649 :                }
  3134. ; 1650 :
  3135. ; 1651 :        const_reference at(size_type _Off) const
  3136. ; 1652 :                {       // subscript nonmutable sequence with checking
  3137. ; 1653 :                if (this->_Mysize <= _Off)
  3138. ; 1654 :                        _Xran();        // _Off off end
  3139. ; 1655 :                return (this->_Myptr()[_Off]);
  3140. ; 1656 :                }
  3141. ; 1657 :
  3142. ; 1658 :        reference operator[](size_type _Off)
  3143. ; 1659 :                {       // subscript mutable sequence
  3144. ; 1660 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3145. ; 1661 :                if (this->_Mysize < _Off)       // sic
  3146. ; 1662 :                        _DEBUG_ERROR("string subscript out of range");
  3147. ; 1663 :
  3148. ; 1664 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  3149. ; 1665 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  3150. ; 1666 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3151. ; 1667 :
  3152. ; 1668 :                return (this->_Myptr()[_Off]);
  3153. ; 1669 :                }
  3154. ; 1670 :
  3155. ; 1671 :        const_reference operator[](size_type _Off) const
  3156. ; 1672 :                {       // subscript nonmutable sequence
  3157. ; 1673 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3158. ; 1674 :                if (this->_Mysize < _Off)       // sic
  3159. ; 1675 :                        _DEBUG_ERROR("string subscript out of range");
  3160. ; 1676 :
  3161. ; 1677 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  3162. ; 1678 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  3163. ; 1679 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3164. ; 1680 :
  3165. ; 1681 :                return (this->_Myptr()[_Off]);
  3166. ; 1682 :                }
  3167. ; 1683 :
  3168. ; 1684 :        void push_back(_Elem _Ch)
  3169. ; 1685 :                {       // insert element at end
  3170. ; 1686 :                insert(end(), _Ch);
  3171. ; 1687 :                }
  3172. ; 1688 :
  3173. ; 1689 :  #if _HAS_CPP0X
  3174. ; 1690 :        void pop_back()
  3175. ; 1691 :                {       // erase element at end
  3176. ; 1692 :                erase(this->_Mysize - 1);       // throws if _Mysize == 0
  3177. ; 1693 :                }
  3178. ; 1694 :
  3179. ; 1695 :        reference front()
  3180. ; 1696 :                {       // return first element of mutable sequence
  3181. ; 1697 :                return (*begin());
  3182. ; 1698 :                }
  3183. ; 1699 :
  3184. ; 1700 :        const_reference front() const
  3185. ; 1701 :                {       // return first element of nonmutable sequence
  3186. ; 1702 :                return (*begin());
  3187. ; 1703 :                }
  3188. ; 1704 :
  3189. ; 1705 :        reference back()
  3190. ; 1706 :                {       // return last element of mutable sequence
  3191. ; 1707 :                return (*(end() - 1));
  3192. ; 1708 :                }
  3193. ; 1709 :
  3194. ; 1710 :        const_reference back() const
  3195. ; 1711 :                {       // return last element of nonmutable sequence
  3196. ; 1712 :                return (*(end() - 1));
  3197. ; 1713 :                }
  3198. ; 1714 :  #endif /* _HAS_CPP0X */
  3199. ; 1715 :
  3200. ; 1716 :        const _Elem *c_str() const _NOEXCEPT
  3201. ; 1717 :                {       // return pointer to null-terminated nonmutable array
  3202. ; 1718 :                return (this->_Myptr());
  3203. ; 1719 :                }
  3204. ; 1720 :
  3205. ; 1721 :        const _Elem *data() const _NOEXCEPT
  3206. ; 1722 :                {       // return pointer to nonmutable array
  3207. ; 1723 :                return (c_str());
  3208. ; 1724 :                }
  3209. ; 1725 :
  3210. ; 1726 :        size_type length() const _NOEXCEPT
  3211. ; 1727 :                {       // return length of sequence
  3212. ; 1728 :                return (this->_Mysize);
  3213. ; 1729 :                }
  3214. ; 1730 :
  3215. ; 1731 :        size_type size() const _NOEXCEPT
  3216. ; 1732 :                {       // return length of sequence
  3217. ; 1733 :                return (this->_Mysize);
  3218. ; 1734 :                }
  3219. ; 1735 :
  3220. ; 1736 :        size_type max_size() const _NOEXCEPT
  3221. ; 1737 :                {       // return maximum possible length of sequence
  3222. ; 1738 :                size_type _Num = this->_Getal().max_size();
  3223. ; 1739 :                return (_Num <= 1 ? 1 : _Num - 1);
  3224. ; 1740 :                }
  3225. ; 1741 :
  3226. ; 1742 :        void resize(size_type _Newsize)
  3227. ; 1743 :                {       // determine new length, padding with null elements as needed
  3228. ; 1744 :                resize(_Newsize, _Elem());
  3229. ; 1745 :                }
  3230. ; 1746 :
  3231. ; 1747 :        void resize(size_type _Newsize, _Elem _Ch)
  3232. ; 1748 :                {       // determine new length, padding with _Ch elements as needed
  3233. ; 1749 :                if (_Newsize <= this->_Mysize)
  3234. ; 1750 :                        _Eos(_Newsize);
  3235. ; 1751 :                else
  3236. ; 1752 :                        append(_Newsize - this->_Mysize, _Ch);
  3237. ; 1753 :                }
  3238. ; 1754 :
  3239. ; 1755 :        size_type capacity() const _NOEXCEPT
  3240. ; 1756 :                {       // return current length of allocated storage
  3241. ; 1757 :                return (this->_Myres);
  3242. ; 1758 :                }
  3243. ; 1759 :
  3244. ; 1760 :        void reserve(size_type _Newcap = 0)
  3245. ; 1761 :                {       // determine new minimum length of allocated storage
  3246. ; 1762 :                if (this->_Mysize <= _Newcap && this->_Myres != _Newcap)
  3247. ; 1763 :                        {       // change reservation
  3248. ; 1764 :                        size_type _Size = this->_Mysize;
  3249. ; 1765 :                        if (_Grow(_Newcap, true))
  3250. ; 1766 :                                _Eos(_Size);
  3251. ; 1767 :                        }
  3252. ; 1768 :                }
  3253. ; 1769 :
  3254. ; 1770 :        bool empty() const _NOEXCEPT
  3255. ; 1771 :                {       // test if sequence is empty
  3256. ; 1772 :                return (this->_Mysize == 0);
  3257. ; 1773 :                }
  3258. ; 1774 :
  3259. ; 1775 :        _SCL_INSECURE_DEPRECATE
  3260. ; 1776 :
  3261. ; 1777 :        size_type copy(_Elem *_Ptr,
  3262. ; 1778 :                size_type _Count, size_type _Off = 0) const
  3263. ; 1779 :                {       // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
  3264. ; 1780 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3265. ; 1781 :                if (_Count != 0)
  3266. ; 1782 :                        _DEBUG_POINTER(_Ptr);
  3267. ; 1783 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3268. ; 1784 :
  3269. ; 1785 :                if (this->_Mysize < _Off)
  3270. ; 1786 :                        _Xran();        // _Off off end
  3271. ; 1787 :                if (this->_Mysize - _Off < _Count)
  3272. ; 1788 :                        _Count = this->_Mysize - _Off;
  3273. ; 1789 :                _Traits::copy(_Ptr, this->_Myptr() + _Off, _Count);
  3274. ; 1790 :                return (_Count);
  3275. ; 1791 :                }
  3276. ; 1792 :
  3277. ; 1793 :        size_type _Copy_s(_Elem *_Dest, size_type _Dest_size,
  3278. ; 1794 :                size_type _Count, size_type _Off = 0) const
  3279. ; 1795 :                {       // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Count)
  3280. ; 1796 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3281. ; 1797 :                if (_Count != 0)
  3282. ; 1798 :                        _DEBUG_POINTER(_Dest);
  3283. ; 1799 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3284. ; 1800 :
  3285. ; 1801 :                if (this->_Mysize < _Off)
  3286. ; 1802 :                        _Xran();        // _Off off end
  3287. ; 1803 :                if (this->_Mysize - _Off < _Count)
  3288. ; 1804 :                        _Count = this->_Mysize - _Off;
  3289. ; 1805 :                _Traits::_Copy_s(_Dest, _Dest_size, this->_Myptr() + _Off, _Count);
  3290. ; 1806 :                return (_Count);
  3291. ; 1807 :                }
  3292. ; 1808 :
  3293. ; 1809 :        void _Swap_bx(_Myt& _Right)
  3294. ; 1810 :                {       // exchange _Bx with _Right._Bx
  3295. ; 1811 :                if (this->_BUF_SIZE <= this->_Myres)
  3296. ; 1812 :                        if (this->_BUF_SIZE <= _Right._Myres)
  3297. ; 1813 :                                _Swap_adl(this->_Bx._Ptr, _Right._Bx._Ptr);
  3298. ; 1814 :                        else
  3299. ; 1815 :                                {       // swap large with small
  3300. ; 1816 :                                pointer _Ptr = this->_Bx._Ptr;
  3301. ; 1817 :                                this->_Getal().destroy(&this->_Bx._Ptr);
  3302. ; 1818 :                                _Traits::copy(this->_Bx._Buf,
  3303. ; 1819 :                                        _Right._Bx._Buf, _Right._Mysize + 1);
  3304. ; 1820 :                                this->_Getal().construct(&_Right._Bx._Ptr, _Ptr);
  3305. ; 1821 :                                }
  3306. ; 1822 :                else
  3307. ; 1823 :                        if (_Right._Myres < this->_BUF_SIZE)
  3308. ; 1824 :                                _STD swap(this->_Bx._Buf, _Right._Bx._Buf);
  3309. ; 1825 :                        else
  3310. ; 1826 :                                {       // swap small with large
  3311. ; 1827 :                                pointer _Ptr = _Right._Bx._Ptr;
  3312. ; 1828 :                                this->_Getal().destroy(&_Right._Bx._Ptr);
  3313. ; 1829 :                                _Traits::copy(_Right._Bx._Buf,
  3314. ; 1830 :                                        this->_Bx._Buf, this->_Mysize + 1);
  3315. ; 1831 :                                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
  3316. ; 1832 :                                }
  3317. ; 1833 :                }
  3318. ; 1834 :
  3319. ; 1835 :        void swap(_Myt& _Right)
  3320. ; 1836 :                {       // exchange contents with _Right
  3321. ; 1837 :                if (this == &_Right)
  3322. ; 1838 :                        ;       // same object, do nothing
  3323. ; 1839 :                else if (this->_Getal() == _Right._Getal())
  3324. ; 1840 :                        {       // same allocator, swap control information
  3325. ; 1841 :                        this->_Swap_all(_Right);
  3326. ; 1842 :                        _Swap_bx(_Right);
  3327. ; 1843 :                        _STD swap(this->_Mysize, _Right._Mysize);
  3328. ; 1844 :                        _STD swap(this->_Myres, _Right._Myres);
  3329. ; 1845 :                        }
  3330. ; 1846 :
  3331. ; 1847 :  #if _HAS_CPP0X
  3332. ; 1848 :                else if (_Alty::propagate_on_container_swap::value)
  3333. ; 1849 :                        {       // swap allocators and control information
  3334. ; 1850 :                        this->_Swap_alloc(_Right);
  3335. ; 1851 :                        _Swap_bx(_Right);
  3336. ; 1852 :                        _STD swap(this->_Bx, _Right._Bx);       // pointer bitwise copyable?
  3337. ; 1853 :                        _STD swap(this->_Mysize, _Right._Mysize);
  3338. ; 1854 :                        _STD swap(this->_Myres, _Right._Myres);
  3339. ; 1855 :                        }
  3340. ; 1856 :  #endif /* _HAS_CPP0X */
  3341. ; 1857 :
  3342. ; 1858 :                else
  3343. ; 1859 :                        {       // different allocator, do multiple assigns
  3344. ; 1860 :                        _Myt _Tmp = *this;
  3345. ; 1861 :
  3346. ; 1862 :                        *this = _Right;
  3347. ; 1863 :                        _Right = _Tmp;
  3348. ; 1864 :                        }
  3349. ; 1865 :                }
  3350. ; 1866 :
  3351. ; 1867 :        size_type find(const _Myt& _Right, size_type _Off = 0) const _NOEXCEPT
  3352. ; 1868 :                {       // look for _Right beginning at or after _Off
  3353. ; 1869 :                return (find(_Right._Myptr(), _Off, _Right.size()));
  3354. ; 1870 :                }
  3355. ; 1871 :
  3356. ; 1872 :        size_type find(const _Elem *_Ptr,
  3357. ; 1873 :                size_type _Off, size_type _Count) const
  3358. ; 1874 :                {       // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
  3359. ; 1875 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3360. ; 1876 :                if (_Count != 0)
  3361. ; 1877 :                        _DEBUG_POINTER(_Ptr);
  3362. ; 1878 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3363. ; 1879 :
  3364. ; 1880 :                if (_Count == 0 && _Off <= this->_Mysize)
  3365. ; 1881 :                        return (_Off);  // null string always matches (if inside string)
  3366. ; 1882 :
  3367. ; 1883 :                size_type _Nm;
  3368. ; 1884 :                if (_Off < this->_Mysize && _Count <= (_Nm = this->_Mysize - _Off))
  3369. ; 1885 :                        {       // room for match, look for it
  3370. ; 1886 :                        const _Elem *_Uptr, *_Vptr;
  3371. ; 1887 :                        for (_Nm -= _Count - 1, _Vptr = this->_Myptr() + _Off;
  3372. ; 1888 :                                (_Uptr = _Traits::find(_Vptr, _Nm, *_Ptr)) != 0;
  3373. ; 1889 :                                _Nm -= _Uptr - _Vptr + 1, _Vptr = _Uptr + 1)
  3374. ; 1890 :                                if (_Traits::compare(_Uptr, _Ptr, _Count) == 0)
  3375. ; 1891 :                                        return (_Uptr - this->_Myptr());        // found a match
  3376. ; 1892 :                        }
  3377. ; 1893 :
  3378. ; 1894 :                return (npos);  // no match
  3379. ; 1895 :                }
  3380. ; 1896 :
  3381. ; 1897 :        size_type find(const _Elem *_Ptr, size_type _Off = 0) const
  3382. ; 1898 :                {       // look for [_Ptr, <null>) beginning at or after _Off
  3383. ; 1899 :                _DEBUG_POINTER(_Ptr);
  3384. ; 1900 :                return (find(_Ptr, _Off, _Traits::length(_Ptr)));
  3385. ; 1901 :                }
  3386. ; 1902 :
  3387. ; 1903 :        size_type find(_Elem _Ch, size_type _Off = 0) const
  3388. ; 1904 :                {       // look for _Ch at or after _Off
  3389. ; 1905 :                return (find((const _Elem *)&_Ch, _Off, 1));
  3390. ; 1906 :                }
  3391. ; 1907 :
  3392. ; 1908 :        size_type rfind(const _Myt& _Right, size_type _Off = npos) const _NOEXCEPT
  3393. ; 1909 :                {       // look for _Right beginning before _Off
  3394. ; 1910 :                return (rfind(_Right._Myptr(), _Off, _Right.size()));
  3395. ; 1911 :                }
  3396. ; 1912 :
  3397. ; 1913 :        size_type rfind(const _Elem *_Ptr,
  3398. ; 1914 :                size_type _Off, size_type _Count) const
  3399. ; 1915 :                {       // look for [_Ptr, _Ptr + _Count) beginning before _Off
  3400. ; 1916 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3401. ; 1917 :                if (_Count != 0)
  3402. ; 1918 :                        _DEBUG_POINTER(_Ptr);
  3403. ; 1919 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3404. ; 1920 :
  3405. ; 1921 :                if (_Count == 0)
  3406. ; 1922 :                        return (_Off < this->_Mysize ? _Off
  3407. ; 1923 :                                : this->_Mysize);       // null always matches
  3408. ; 1924 :                if (_Count <= this->_Mysize)
  3409. ; 1925 :                        {       // room for match, look for it
  3410. ; 1926 :                        const _Elem *_Uptr = this->_Myptr() +
  3411. ; 1927 :                                (_Off < this->_Mysize - _Count ? _Off
  3412. ; 1928 :                                        : this->_Mysize - _Count);
  3413. ; 1929 :                        for (; ; --_Uptr)
  3414. ; 1930 :                                if (_Traits::eq(*_Uptr, *_Ptr)
  3415. ; 1931 :                                        && _Traits::compare(_Uptr, _Ptr, _Count) == 0)
  3416. ; 1932 :                                        return (_Uptr - this->_Myptr());        // found a match
  3417. ; 1933 :                                else if (_Uptr == this->_Myptr())
  3418. ; 1934 :                                        break;  // at beginning, no more chance for match
  3419. ; 1935 :                        }
  3420. ; 1936 :
  3421. ; 1937 :                return (npos);  // no match
  3422. ; 1938 :                }
  3423. ; 1939 :
  3424. ; 1940 :        size_type rfind(const _Elem *_Ptr, size_type _Off = npos) const
  3425. ; 1941 :                {       // look for [_Ptr, <null>) beginning before _Off
  3426. ; 1942 :                _DEBUG_POINTER(_Ptr);
  3427. ; 1943 :                return (rfind(_Ptr, _Off, _Traits::length(_Ptr)));
  3428. ; 1944 :                }
  3429. ; 1945 :
  3430. ; 1946 :        size_type rfind(_Elem _Ch, size_type _Off = npos) const
  3431. ; 1947 :                {       // look for _Ch before _Off
  3432. ; 1948 :                return (rfind((const _Elem *)&_Ch, _Off, 1));
  3433. ; 1949 :                }
  3434. ; 1950 :
  3435. ; 1951 :        size_type find_first_of(const _Myt& _Right,
  3436. ; 1952 :                size_type _Off = 0) const _NOEXCEPT
  3437. ; 1953 :                {       // look for one of _Right at or after _Off
  3438. ; 1954 :                return (find_first_of(_Right._Myptr(), _Off, _Right.size()));
  3439. ; 1955 :                }
  3440. ; 1956 :
  3441. ; 1957 :        size_type find_first_of(const _Elem *_Ptr,
  3442. ; 1958 :                size_type _Off, size_type _Count) const
  3443. ; 1959 :                {       // look for one of [_Ptr, _Ptr + _Count) at or after _Off
  3444. ; 1960 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3445. ; 1961 :                if (_Count != 0)
  3446. ; 1962 :                        _DEBUG_POINTER(_Ptr);
  3447. ; 1963 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3448. ; 1964 :
  3449. ; 1965 :                if (0 < _Count && _Off < this->_Mysize)
  3450. ; 1966 :                        {       // room for match, look for it
  3451. ; 1967 :                        const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
  3452. ; 1968 :                        for (const _Elem *_Uptr = this->_Myptr() + _Off;
  3453. ; 1969 :                                _Uptr < _Vptr; ++_Uptr)
  3454. ; 1970 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
  3455. ; 1971 :                                        return (_Uptr - this->_Myptr());        // found a match
  3456. ; 1972 :                        }
  3457. ; 1973 :
  3458. ; 1974 :                return (npos);  // no match
  3459. ; 1975 :                }
  3460. ; 1976 :
  3461. ; 1977 :        size_type find_first_of(const _Elem *_Ptr,
  3462. ; 1978 :                size_type _Off = 0) const
  3463. ; 1979 :                {       // look for one of [_Ptr, <null>) at or after _Off
  3464. ; 1980 :                _DEBUG_POINTER(_Ptr);
  3465. ; 1981 :                return (find_first_of(_Ptr, _Off, _Traits::length(_Ptr)));
  3466. ; 1982 :                }
  3467. ; 1983 :
  3468. ; 1984 :        size_type find_first_of(_Elem _Ch,
  3469. ; 1985 :                size_type _Off = 0) const
  3470. ; 1986 :                {       // look for _Ch at or after _Off
  3471. ; 1987 :                return (find((const _Elem *)&_Ch, _Off, 1));
  3472. ; 1988 :                }
  3473. ; 1989 :
  3474. ; 1990 :        size_type find_last_of(const _Myt& _Right,
  3475. ; 1991 :                size_type _Off = npos) const _NOEXCEPT
  3476. ; 1992 :                {       // look for one of _Right before _Off
  3477. ; 1993 :                return (find_last_of(_Right._Myptr(), _Off, _Right.size()));
  3478. ; 1994 :                }
  3479. ; 1995 :
  3480. ; 1996 :        size_type find_last_of(const _Elem *_Ptr,
  3481. ; 1997 :                size_type _Off, size_type _Count) const
  3482. ; 1998 :                {       // look for one of [_Ptr, _Ptr + _Count) before _Off
  3483. ; 1999 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3484. ; 2000 :                if (_Count != 0)
  3485. ; 2001 :                        _DEBUG_POINTER(_Ptr);
  3486. ; 2002 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3487. ; 2003 :
  3488. ; 2004 :                if (0 < _Count && 0 < this->_Mysize)
  3489. ; 2005 :                        {       // worth searching, do it
  3490. ; 2006 :                        const _Elem *_Uptr = this->_Myptr()
  3491. ; 2007 :                                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
  3492. ; 2008 :                        for (; ; --_Uptr)
  3493. ; 2009 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
  3494. ; 2010 :                                        return (_Uptr - this->_Myptr());        // found a match
  3495. ; 2011 :                                else if (_Uptr == this->_Myptr())
  3496. ; 2012 :                                        break;  // at beginning, no more chance for match
  3497. ; 2013 :                        }
  3498. ; 2014 :
  3499. ; 2015 :                return (npos);  // no match
  3500. ; 2016 :                }
  3501. ; 2017 :
  3502. ; 2018 :        size_type find_last_of(const _Elem *_Ptr,
  3503. ; 2019 :                size_type _Off = npos) const
  3504. ; 2020 :                {       // look for one of [_Ptr, <null>) before _Off
  3505. ; 2021 :                _DEBUG_POINTER(_Ptr);
  3506. ; 2022 :                return (find_last_of(_Ptr, _Off, _Traits::length(_Ptr)));
  3507. ; 2023 :                }
  3508. ; 2024 :
  3509. ; 2025 :        size_type find_last_of(_Elem _Ch,
  3510. ; 2026 :                size_type _Off = npos) const
  3511. ; 2027 :                {       // look for _Ch before _Off
  3512. ; 2028 :                return (rfind((const _Elem *)&_Ch, _Off, 1));
  3513. ; 2029 :                }
  3514. ; 2030 :
  3515. ; 2031 :        size_type find_first_not_of(const _Myt& _Right,
  3516. ; 2032 :                size_type _Off = 0) const _NOEXCEPT
  3517. ; 2033 :                {       // look for none of _Right at or after _Off
  3518. ; 2034 :                return (find_first_not_of(_Right._Myptr(), _Off,
  3519. ; 2035 :                        _Right.size()));
  3520. ; 2036 :                }
  3521. ; 2037 :
  3522. ; 2038 :        size_type find_first_not_of(const _Elem *_Ptr,
  3523. ; 2039 :                size_type _Off, size_type _Count) const
  3524. ; 2040 :                {       // look for none of [_Ptr, _Ptr + _Count) at or after _Off
  3525. ; 2041 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3526. ; 2042 :                if (_Count != 0)
  3527. ; 2043 :                        _DEBUG_POINTER(_Ptr);
  3528. ; 2044 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3529. ; 2045 :
  3530. ; 2046 :                if (_Off < this->_Mysize)
  3531. ; 2047 :                        {       // room for match, look for it
  3532. ; 2048 :                        const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
  3533. ; 2049 :                        for (const _Elem *_Uptr = this->_Myptr() + _Off;
  3534. ; 2050 :                                _Uptr < _Vptr; ++_Uptr)
  3535. ; 2051 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
  3536. ; 2052 :                                        return (_Uptr - this->_Myptr());
  3537. ; 2053 :                        }
  3538. ; 2054 :                return (npos);
  3539. ; 2055 :                }
  3540. ; 2056 :
  3541. ; 2057 :        size_type find_first_not_of(const _Elem *_Ptr,
  3542. ; 2058 :                size_type _Off = 0) const
  3543. ; 2059 :                {       // look for one of [_Ptr, <null>) at or after _Off
  3544. ; 2060 :                _DEBUG_POINTER(_Ptr);
  3545. ; 2061 :                return (find_first_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
  3546. ; 2062 :                }
  3547. ; 2063 :
  3548. ; 2064 :        size_type find_first_not_of(_Elem _Ch,
  3549. ; 2065 :                size_type _Off = 0) const
  3550. ; 2066 :                {       // look for non _Ch at or after _Off
  3551. ; 2067 :                return (find_first_not_of((const _Elem *)&_Ch, _Off, 1));
  3552. ; 2068 :                }
  3553. ; 2069 :
  3554. ; 2070 :        size_type find_last_not_of(const _Myt& _Right,
  3555. ; 2071 :                size_type _Off = npos) const _NOEXCEPT
  3556. ; 2072 :                {       // look for none of _Right before _Off
  3557. ; 2073 :                return (find_last_not_of(_Right._Myptr(), _Off, _Right.size()));
  3558. ; 2074 :                }
  3559. ; 2075 :
  3560. ; 2076 :        size_type find_last_not_of(const _Elem *_Ptr,
  3561. ; 2077 :                size_type _Off, size_type _Count) const
  3562. ; 2078 :                {       // look for none of [_Ptr, _Ptr + _Count) before _Off
  3563. ; 2079 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3564. ; 2080 :                if (_Count != 0)
  3565. ; 2081 :                        _DEBUG_POINTER(_Ptr);
  3566. ; 2082 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3567. ; 2083 :
  3568. ; 2084 :                if (0 < this->_Mysize)
  3569. ; 2085 :                        {       // worth searching, do it
  3570. ; 2086 :                        const _Elem *_Uptr = this->_Myptr()
  3571. ; 2087 :                                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
  3572. ; 2088 :                        for (; ; --_Uptr)
  3573. ; 2089 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
  3574. ; 2090 :                                        return (_Uptr - this->_Myptr());
  3575. ; 2091 :                                else if (_Uptr == this->_Myptr())
  3576. ; 2092 :                                        break;
  3577. ; 2093 :                        }
  3578. ; 2094 :                return (npos);
  3579. ; 2095 :                }
  3580. ; 2096 :
  3581. ; 2097 :        size_type find_last_not_of(const _Elem *_Ptr,
  3582. ; 2098 :                size_type _Off = npos) const
  3583. ; 2099 :                {       // look for none of [_Ptr, <null>) before _Off
  3584. ; 2100 :                _DEBUG_POINTER(_Ptr);
  3585. ; 2101 :                return (find_last_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
  3586. ; 2102 :                }
  3587. ; 2103 :
  3588. ; 2104 :        size_type find_last_not_of(_Elem _Ch,
  3589. ; 2105 :                size_type _Off = npos) const
  3590. ; 2106 :                {       // look for non _Ch before _Off
  3591. ; 2107 :                return (find_last_not_of((const _Elem *)&_Ch, _Off, 1));
  3592. ; 2108 :                }
  3593. ; 2109 :
  3594. ; 2110 :        _Myt substr(size_type _Off = 0, size_type _Count = npos) const
  3595. ; 2111 :                {       // return [_Off, _Off + _Count) as new string
  3596. ; 2112 :                return (_Myt(*this, _Off, _Count, get_allocator()));
  3597. ; 2113 :                }
  3598. ; 2114 :
  3599. ; 2115 :        int compare(const _Myt& _Right) const _NOEXCEPT
  3600. ; 2116 :                {       // compare [0, _Mysize) with _Right
  3601. ; 2117 :                return (compare(0, this->_Mysize, _Right._Myptr(), _Right.size()));
  3602. ; 2118 :                }
  3603. ; 2119 :
  3604. ; 2120 :        int compare(size_type _Off, size_type _N0,
  3605. ; 2121 :                const _Myt& _Right) const
  3606. ; 2122 :                {       // compare [_Off, _Off + _N0) with _Right
  3607. ; 2123 :                return (compare(_Off, _N0, _Right, 0, npos));
  3608. ; 2124 :                }
  3609. ; 2125 :
  3610. ; 2126 :        int compare(size_type _Off,
  3611. ; 2127 :                size_type _N0, const _Myt& _Right,
  3612. ; 2128 :                size_type _Roff, size_type _Count) const
  3613. ; 2129 :                {       // compare [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
  3614. ; 2130 :                if (_Right.size() < _Roff)
  3615. ; 2131 :                        _Xran();        // _Off off end
  3616. ; 2132 :                if (_Right._Mysize - _Roff < _Count)
  3617. ; 2133 :                        _Count = _Right._Mysize - _Roff;        // trim _Count to size
  3618. ; 2134 :                return (compare(_Off, _N0, _Right._Myptr() + _Roff, _Count));
  3619. ; 2135 :                }
  3620. ; 2136 :
  3621. ; 2137 :        int compare(const _Elem *_Ptr) const
  3622. ; 2138 :                {       // compare [0, _Mysize) with [_Ptr, <null>)
  3623. ; 2139 :                _DEBUG_POINTER(_Ptr);
  3624. ; 2140 :                return (compare(0, this->_Mysize, _Ptr, _Traits::length(_Ptr)));
  3625. ; 2141 :                }
  3626. ; 2142 :
  3627. ; 2143 :        int compare(size_type _Off, size_type _N0, const _Elem *_Ptr) const
  3628. ; 2144 :                {       // compare [_Off, _Off + _N0) with [_Ptr, <null>)
  3629. ; 2145 :                _DEBUG_POINTER(_Ptr);
  3630. ; 2146 :                return (compare(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
  3631. ; 2147 :                }
  3632. ; 2148 :
  3633. ; 2149 :        int compare(size_type _Off,
  3634. ; 2150 :                size_type _N0, const _Elem *_Ptr, size_type _Count) const
  3635. ; 2151 :                {       // compare [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
  3636. ; 2152 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3637. ; 2153 :                if (_Count != 0)
  3638. ; 2154 :                        _DEBUG_POINTER(_Ptr);
  3639. ; 2155 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3640. ; 2156 :
  3641. ; 2157 :                if (this->_Mysize < _Off)
  3642. ; 2158 :                        _Xran();        // _Off off end
  3643. ; 2159 :                if (this->_Mysize - _Off < _N0)
  3644. ; 2160 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  3645. ; 2161 :
  3646. ; 2162 :                size_type _Ans = _Traits::compare(this->_Myptr() + _Off, _Ptr,
  3647. ; 2163 :                        _N0 < _Count ? _N0 : _Count);
  3648. ; 2164 :                return (_Ans != 0 ? (int)_Ans : _N0 < _Count ? -1
  3649. ; 2165 :                        : _N0 == _Count ? 0 : +1);
  3650. ; 2166 :                }
  3651. ; 2167 :
  3652. ; 2168 :        allocator_type get_allocator() const _NOEXCEPT
  3653. ; 2169 :                {       // return allocator object for values
  3654. ; 2170 :                return (this->_Getal());
  3655. ; 2171 :                }
  3656. ; 2172 :
  3657. ; 2173 :        void _Chassign(size_type _Off, size_type _Count, _Elem _Ch)
  3658. ; 2174 :                {       // assign _Count copies of _Ch beginning at _Off
  3659. ; 2175 :                if (_Count == 1)
  3660. ; 2176 :                        _Traits::assign(*(this->_Myptr() + _Off), _Ch);
  3661. ; 2177 :                else
  3662. ; 2178 :                        _Traits::assign(this->_Myptr() + _Off, _Count, _Ch);
  3663. ; 2179 :                }
  3664. ; 2180 :
  3665. ; 2181 :        void _Copy(size_type _Newsize, size_type _Oldlen)
  3666. ; 2182 :                {       // copy _Oldlen elements to newly allocated buffer
  3667. ; 2183 :                size_type _Newres = _Newsize | this->_ALLOC_MASK;
  3668. ; 2184 :                if (max_size() < _Newres)
  3669. ; 2185 :                        _Newres = _Newsize;     // undo roundup if too big
  3670. ; 2186 :                else if (this->_Myres / 2 <= _Newres / 3)
  3671. ; 2187 :                        ;
  3672. ; 2188 :                else if (this->_Myres <= max_size() - this->_Myres / 2)
  3673. ; 2189 :                        _Newres = this->_Myres
  3674. ; 2190 :                                + this->_Myres / 2;     // grow exponentially if possible
  3675. ; 2191 :                else
  3676. ; 2192 :                        _Newres = max_size();   // settle for max_size()
  3677. ; 2193 :
  3678. ; 2194 :                _Elem *_Ptr;
  3679. ; 2195 :                _TRY_BEGIN
  3680. ; 2196 :                        _Ptr = this->_Getal().allocate(_Newres + 1);
  3681. ; 2197 :                _CATCH_ALL
  3682. ; 2198 :                        _Newres = _Newsize;     // allocation failed, undo roundup and retry
  3683. ; 2199 :                        _TRY_BEGIN
  3684. ; 2200 :                                _Ptr = this->_Getal().allocate(_Newres + 1);
  3685. ; 2201 :                        _CATCH_ALL
  3686. ; 2202 :                        _Tidy(true);    // failed again, discard storage and reraise
  3687. ; 2203 :                        _RERAISE;
  3688. ; 2204 :                        _CATCH_END
  3689. ; 2205 :                _CATCH_END
  3690. ; 2206 :
  3691. ; 2207 :                if (0 < _Oldlen)
  3692. ; 2208 :                        _Traits::copy(_Ptr, this->_Myptr(),
  3693. ; 2209 :                                _Oldlen);       // copy existing elements
  3694. ; 2210 :                _Tidy(true);
  3695. ; 2211 :                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
  3696. ; 2212 :                this->_Myres = _Newres;
  3697. ; 2213 :                _Eos(_Oldlen);
  3698. ; 2214 :                }
  3699. ; 2215 :
  3700. ; 2216 :        void _Eos(size_type _Newsize)
  3701. ; 2217 :                {       // set new length and null terminator
  3702. ; 2218 :                _Traits::assign(this->_Myptr()[this->_Mysize = _Newsize], _Elem());
  3703.  
  3704.         mov     DWORD PTR [esi+16], eax
  3705.  
  3706. ; 517  :                        : this->_Bx._Buf);
  3707.  
  3708.         jb      SHORT $LN25@assign
  3709. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  3710.  
  3711. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  3712.  
  3713.         mov     edx, DWORD PTR [esi]
  3714. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3715.  
  3716. ; 1112 :                        erase((size_type)(_Roff + _Num)), erase(0, _Roff);      // substring
  3717.  
  3718.         push    ecx
  3719.         push    ecx
  3720.         mov     ecx, esi
  3721. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  3722.  
  3723. ; 564  :                _Left = _Right;
  3724.  
  3725.         mov     BYTE PTR [eax+edx], 0
  3726. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3727.  
  3728. ; 1112 :                        erase((size_type)(_Roff + _Num)), erase(0, _Roff);      // substring
  3729.  
  3730.         call    ?erase@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@II@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::erase
  3731.         pop     edi
  3732.  
  3733. ; 1119 :                return (*this);
  3734.  
  3735.         mov     eax, esi
  3736.         pop     esi
  3737.         pop     ebx
  3738.  
  3739. ; 1120 :                }
  3740.  
  3741.         pop     ebp
  3742.         ret     12                                      ; 0000000cH
  3743. $LN25@assign:
  3744.  
  3745. ; 1112 :                        erase((size_type)(_Roff + _Num)), erase(0, _Roff);      // substring
  3746.  
  3747.         push    ecx
  3748.  
  3749. ; 517  :                        : this->_Bx._Buf);
  3750.  
  3751.         mov     edx, esi
  3752.  
  3753. ; 1112 :                        erase((size_type)(_Roff + _Num)), erase(0, _Roff);      // substring
  3754.  
  3755.         push    ecx
  3756.         mov     ecx, esi
  3757. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  3758.  
  3759. ; 564  :                _Left = _Right;
  3760.  
  3761.         mov     BYTE PTR [eax+edx], 0
  3762. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3763.  
  3764. ; 1112 :                        erase((size_type)(_Roff + _Num)), erase(0, _Roff);      // substring
  3765.  
  3766.         call    ?erase@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@II@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::erase
  3767.         pop     edi
  3768.  
  3769. ; 1119 :                return (*this);
  3770.  
  3771.         mov     eax, esi
  3772.         pop     esi
  3773.         pop     ebx
  3774.  
  3775. ; 1120 :                }
  3776.  
  3777.         pop     ebp
  3778.         ret     12                                      ; 0000000cH
  3779. $LN3@assign:
  3780.  
  3781. ; 1113 :                else if (_Grow(_Num))
  3782.  
  3783.         push    ecx
  3784.         push    edi
  3785.         mov     ecx, esi
  3786.         call    ?_Grow@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE_NI_N@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Grow
  3787.         test    al, al
  3788.         je      SHORT $LN55@assign
  3789.  
  3790. ; 518  :                }
  3791. ; 519  :
  3792. ; 520  :        const value_type *_Myptr() const
  3793. ; 521  :                {       // determine current pointer to buffer for nonmutable string
  3794. ; 522  :                return (this->_BUF_SIZE <= this->_Myres
  3795. ; 523  :                        ? _STD addressof(*this->_Bx._Ptr)
  3796. ; 524  :                        : this->_Bx._Buf);
  3797.  
  3798.         cmp     DWORD PTR [ebx+20], 16                  ; 00000010H
  3799.         jb      SHORT $LN33@assign
  3800. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  3801.  
  3802. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  3803.  
  3804.         mov     ebx, DWORD PTR [ebx]
  3805. $LN33@assign:
  3806. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3807.  
  3808. ; 517  :                        : this->_Bx._Buf);
  3809.  
  3810.         cmp     DWORD PTR [esi+20], 16                  ; 00000010H
  3811.         jb      SHORT $LN39@assign
  3812. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  3813.  
  3814. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  3815.  
  3816.         mov     ecx, DWORD PTR [esi]
  3817. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3818.  
  3819. ; 517  :                        : this->_Bx._Buf);
  3820.  
  3821.         jmp     SHORT $LN40@assign
  3822. $LN39@assign:
  3823.         mov     ecx, esi
  3824. $LN40@assign:
  3825. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  3826.  
  3827. ; 530  :                        : (_Elem *)_CSTD memcpy(_First1, _First2, _Count));
  3828.  
  3829.         test    edi, edi
  3830.         je      SHORT $LN46@assign
  3831. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3832.  
  3833. ; 1116 :                                _Right._Myptr() + _Roff, _Num);
  3834.  
  3835.         mov     eax, DWORD PTR __Roff$[ebp]
  3836. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  3837.  
  3838. ; 530  :                        : (_Elem *)_CSTD memcpy(_First1, _First2, _Count));
  3839.  
  3840.         push    edi
  3841. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3842.  
  3843. ; 1116 :                                _Right._Myptr() + _Roff, _Num);
  3844.  
  3845.         add     eax, ebx
  3846. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  3847.  
  3848. ; 530  :                        : (_Elem *)_CSTD memcpy(_First1, _First2, _Count));
  3849.  
  3850.         push    eax
  3851.         push    ecx
  3852.         call    _memcpy
  3853.         add     esp, 12                                 ; 0000000cH
  3854. $LN46@assign:
  3855. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  3856.  
  3857. ; 517  :                        : this->_Bx._Buf);
  3858.  
  3859.         cmp     DWORD PTR [esi+20], 16                  ; 00000010H
  3860.  
  3861. ; 1311 :                        _Xran();        // _Off off end
  3862. ; 1312 :                _Eos(_Off);
  3863. ; 1313 :                return (*this);
  3864. ; 1314 :                }
  3865. ; 1315 :
  3866. ; 1316 :        _Myt& erase(size_type _Off, size_type _Count)
  3867. ; 1317 :                {       // erase elements [_Off, _Off + _Count)
  3868. ; 1318 :                if (this->_Mysize < _Off)
  3869. ; 1319 :                        _Xran();        // _Off off end
  3870. ; 1320 :                if (this->_Mysize - _Off <= _Count)
  3871. ; 1321 :                        _Eos(_Off);     // erase elements [_Off, ...)
  3872. ; 1322 :                else if (0 < _Count)
  3873. ; 1323 :                        {       // move elements down
  3874. ; 1324 :                        value_type *_Ptr = this->_Myptr() + _Off;
  3875. ; 1325 :                        size_type _Newsize = this->_Mysize - _Count;
  3876. ; 1326 :                        _Traits::move(_Ptr, _Ptr + _Count, _Newsize - _Off);
  3877. ; 1327 :                        _Eos(_Newsize);
  3878. ; 1328 :                        }
  3879. ; 1329 :                return (*this);
  3880. ; 1330 :                }
  3881. ; 1331 :
  3882. ; 1332 :        iterator erase(const_iterator _Where)
  3883. ; 1333 :                {       // erase element at _Where
  3884. ; 1334 :                size_type _Count = _Pdif(_Where, begin());
  3885. ; 1335 :                erase(_Count, 1);
  3886. ; 1336 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  3887. ; 1337 :                }
  3888. ; 1338 :
  3889. ; 1339 :        iterator erase(const_iterator _First, const_iterator _Last)
  3890. ; 1340 :                {       // erase substring [_First, _Last)
  3891. ; 1341 :                _DEBUG_RANGE(_First, _Last);
  3892. ; 1342 :                size_type _Count = _Pdif(_First, begin());
  3893. ; 1343 :                erase(_Count, _Pdif(_Last, _First));
  3894. ; 1344 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  3895. ; 1345 :                }
  3896. ; 1346 :
  3897. ; 1347 :        void clear() _NOEXCEPT
  3898. ; 1348 :                {       // erase all
  3899. ; 1349 :                _Eos(0);
  3900. ; 1350 :                }
  3901. ; 1351 :
  3902. ; 1352 :        _Myt& replace(size_type _Off, size_type _N0, const _Myt& _Right)
  3903. ; 1353 :                {       // replace [_Off, _Off + _N0) with _Right
  3904. ; 1354 :                return (replace(_Off, _N0, _Right, 0, npos));
  3905. ; 1355 :                }
  3906. ; 1356 :
  3907. ; 1357 :        _Myt& replace(size_type _Off,
  3908. ; 1358 :                size_type _N0, const _Myt& _Right, size_type _Roff, size_type _Count)
  3909. ; 1359 :                {       // replace [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
  3910. ; 1360 :                if (this->_Mysize < _Off || _Right.size() < _Roff)
  3911. ; 1361 :                        _Xran();        // _Off or _Roff off end
  3912. ; 1362 :                if (this->_Mysize - _Off < _N0)
  3913. ; 1363 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  3914. ; 1364 :                size_type _Num = _Right.size() - _Roff;
  3915. ; 1365 :                if (_Num < _Count)
  3916. ; 1366 :                        _Count = _Num;  // trim _Count to size
  3917. ; 1367 :                if (npos - _Count <= this->_Mysize - _N0)
  3918. ; 1368 :                        _Xlen();        // result too long
  3919. ; 1369 :
  3920. ; 1370 :                size_type _Nm = this->_Mysize - _N0 - _Off;     // length of kept tail
  3921. ; 1371 :                size_type _Newsize = this->_Mysize + _Count - _N0;
  3922. ; 1372 :                if (this->_Mysize < _Newsize)
  3923. ; 1373 :                        _Grow(_Newsize);
  3924. ; 1374 :
  3925. ; 1375 :                if (this != &_Right)
  3926. ; 1376 :                        {       // no overlap, just move down and copy in new stuff
  3927. ; 1377 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  3928. ; 1378 :                                this->_Myptr() + _Off + _N0, _Nm);      // empty hole
  3929. ; 1379 :                        _Traits::copy(this->_Myptr() + _Off,
  3930. ; 1380 :                                _Right._Myptr() + _Roff, _Count);       // fill hole
  3931. ; 1381 :                        }
  3932. ; 1382 :                else if (_Count <= _N0)
  3933. ; 1383 :                        {       // hole doesn't get larger, just copy in substring
  3934. ; 1384 :                        _Traits::move(this->_Myptr() + _Off,
  3935. ; 1385 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  3936. ; 1386 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  3937. ; 1387 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  3938. ; 1388 :                        }
  3939. ; 1389 :                else if (_Roff <= _Off)
  3940. ; 1390 :                        {       // hole gets larger, substring begins before hole
  3941. ; 1391 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  3942. ; 1392 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  3943. ; 1393 :                        _Traits::move(this->_Myptr() + _Off,
  3944. ; 1394 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  3945. ; 1395 :                        }
  3946. ; 1396 :                else if (_Off + _N0 <= _Roff)
  3947. ; 1397 :                        {       // hole gets larger, substring begins after hole
  3948. ; 1398 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  3949. ; 1399 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  3950. ; 1400 :                        _Traits::move(this->_Myptr() + _Off,
  3951. ; 1401 :                                this->_Myptr() + (_Roff + _Count - _N0),
  3952. ; 1402 :                                _Count);        // fill hole
  3953. ; 1403 :                        }
  3954. ; 1404 :                else
  3955. ; 1405 :                        {       // hole gets larger, substring begins in hole
  3956. ; 1406 :                        _Traits::move(this->_Myptr() + _Off,
  3957. ; 1407 :                                this->_Myptr() + _Roff, _N0);   // fill old hole
  3958. ; 1408 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  3959. ; 1409 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  3960. ; 1410 :                        _Traits::move(this->_Myptr() + _Off + _N0,
  3961. ; 1411 :                                this->_Myptr() + _Roff + _Count,
  3962. ; 1412 :                                _Count - _N0);  // fill rest of new hole
  3963. ; 1413 :                        }
  3964. ; 1414 :
  3965. ; 1415 :                _Eos(_Newsize);
  3966. ; 1416 :                return (*this);
  3967. ; 1417 :                }
  3968. ; 1418 :
  3969. ; 1419 :        _Myt& replace(size_type _Off,
  3970. ; 1420 :                size_type _N0, const _Elem *_Ptr, size_type _Count)
  3971. ; 1421 :                {       // replace [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
  3972. ; 1422 :  #if _ITERATOR_DEBUG_LEVEL == 2
  3973. ; 1423 :                if (_Count != 0)
  3974. ; 1424 :                        _DEBUG_POINTER(_Ptr);
  3975. ; 1425 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  3976. ; 1426 :
  3977. ; 1427 :                if (_Inside(_Ptr))
  3978. ; 1428 :                        return (replace(_Off, _N0, *this,
  3979. ; 1429 :                                _Ptr - this->_Myptr(),
  3980. ; 1430 :                                _Count));       // substring, replace carefully
  3981. ; 1431 :                if (this->_Mysize < _Off)
  3982. ; 1432 :                        _Xran();        // _Off off end
  3983. ; 1433 :                if (this->_Mysize - _Off < _N0)
  3984. ; 1434 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  3985. ; 1435 :                if (npos - _Count <= this->_Mysize - _N0)
  3986. ; 1436 :                        _Xlen();        // result too long
  3987. ; 1437 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  3988. ; 1438 :
  3989. ; 1439 :                if (_Count < _N0)
  3990. ; 1440 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  3991. ; 1441 :                                this->_Myptr() + _Off + _N0,
  3992. ; 1442 :                                _Nm);   // smaller hole, move tail up
  3993. ; 1443 :                size_type _Num;
  3994. ; 1444 :                if ((0 < _Count || 0 < _N0)
  3995. ; 1445 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  3996. ; 1446 :                        {       // make room and rearrange
  3997. ; 1447 :                        if (_N0 < _Count)
  3998. ; 1448 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  3999. ; 1449 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  4000. ; 1450 :                        _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count);     // fill hole
  4001. ; 1451 :                        _Eos(_Num);
  4002. ; 1452 :                        }
  4003. ; 1453 :                return (*this);
  4004. ; 1454 :                }
  4005. ; 1455 :
  4006. ; 1456 :        _Myt& replace(size_type _Off, size_type _N0, const _Elem *_Ptr)
  4007. ; 1457 :                {       // replace [_Off, _Off + _N0) with [_Ptr, <null>)
  4008. ; 1458 :                _DEBUG_POINTER(_Ptr);
  4009. ; 1459 :                return (replace(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
  4010. ; 1460 :                }
  4011. ; 1461 :
  4012. ; 1462 :        _Myt& replace(size_type _Off,
  4013. ; 1463 :                size_type _N0, size_type _Count, _Elem _Ch)
  4014. ; 1464 :                {       // replace [_Off, _Off + _N0) with _Count * _Ch
  4015. ; 1465 :                if (this->_Mysize < _Off)
  4016. ; 1466 :                        _Xran();        // _Off off end
  4017. ; 1467 :                if (this->_Mysize - _Off < _N0)
  4018. ; 1468 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  4019. ; 1469 :                if (npos - _Count <= this->_Mysize - _N0)
  4020. ; 1470 :                        _Xlen();        // result too long
  4021. ; 1471 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  4022. ; 1472 :
  4023. ; 1473 :                if (_Count < _N0)
  4024. ; 1474 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  4025. ; 1475 :                                this->_Myptr() + _Off + _N0,
  4026. ; 1476 :                                _Nm);   // smaller hole, move tail up
  4027. ; 1477 :                size_type _Num;
  4028. ; 1478 :                if ((0 < _Count || 0 < _N0)
  4029. ; 1479 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  4030. ; 1480 :                        {       // make room and rearrange
  4031. ; 1481 :                        if (_N0 < _Count)
  4032. ; 1482 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  4033. ; 1483 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  4034. ; 1484 :                        _Chassign(_Off, _Count, _Ch);   // fill hole
  4035. ; 1485 :                        _Eos(_Num);
  4036. ; 1486 :                        }
  4037. ; 1487 :                return (*this);
  4038. ; 1488 :                }
  4039. ; 1489 :
  4040. ; 1490 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4041. ; 1491 :                const _Myt& _Right)
  4042. ; 1492 :                {       // replace [_First, _Last) with _Right
  4043. ; 1493 :                return (replace(
  4044. ; 1494 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Right));
  4045. ; 1495 :                }
  4046. ; 1496 :
  4047. ; 1497 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4048. ; 1498 :                const _Elem *_Ptr, size_type _Count)
  4049. ; 1499 :                {       // replace [_First, _Last) with [_Ptr, _Ptr + _Count)
  4050. ; 1500 :                return (replace(
  4051. ; 1501 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr, _Count));
  4052. ; 1502 :                }
  4053. ; 1503 :
  4054. ; 1504 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4055. ; 1505 :                const _Elem *_Ptr)
  4056. ; 1506 :                {       // replace [_First, _Last) with [_Ptr, <null>)
  4057. ; 1507 :                return (replace(
  4058. ; 1508 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr));
  4059. ; 1509 :                }
  4060. ; 1510 :
  4061. ; 1511 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4062. ; 1512 :                size_type _Count, _Elem _Ch)
  4063. ; 1513 :                {       // replace [_First, _Last) with _Count * _Ch
  4064. ; 1514 :                return (replace(
  4065. ; 1515 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Count, _Ch));
  4066. ; 1516 :                }
  4067. ; 1517 :
  4068. ; 1518 :        template<class _Iter>
  4069. ; 1519 :                typename enable_if<_Is_iterator<_Iter>::value,
  4070. ; 1520 :                        _Myt&>::type
  4071. ; 1521 :                replace(const_iterator _First, const_iterator _Last,
  4072. ; 1522 :                        _Iter _First2, _Iter _Last2)
  4073. ; 1523 :                {       // replace [_First, _Last) with [_First2, _Last2), input iterators
  4074. ; 1524 :                _Myt _Right(_First2, _Last2);
  4075. ; 1525 :                replace(_First, _Last, _Right);
  4076. ; 1526 :                return (*this);
  4077. ; 1527 :                }
  4078. ; 1528 :
  4079. ; 1529 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4080. ; 1530 :                const_pointer _First2, const_pointer _Last2)
  4081. ; 1531 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  4082. ; 1532 :                if (_First2 == _Last2)
  4083. ; 1533 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  4084. ; 1534 :                else
  4085. ; 1535 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  4086. ; 1536 :                                &*_First2, _Last2 - _First2);
  4087. ; 1537 :                return (*this);
  4088. ; 1538 :                }
  4089. ; 1539 :
  4090. ; 1540 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4091. ; 1541 :                pointer _First2, pointer _Last2)
  4092. ; 1542 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  4093. ; 1543 :                if (_First2 == _Last2)
  4094. ; 1544 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  4095. ; 1545 :                else
  4096. ; 1546 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  4097. ; 1547 :                                &*_First2, _Last2 - _First2);
  4098. ; 1548 :                return (*this);
  4099. ; 1549 :                }
  4100. ; 1550 :
  4101. ; 1551 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4102. ; 1552 :                const_iterator _First2, const_iterator _Last2)
  4103. ; 1553 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  4104. ; 1554 :                if (_First2 == _Last2)
  4105. ; 1555 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  4106. ; 1556 :                else
  4107. ; 1557 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  4108. ; 1558 :                                &*_First2, _Last2 - _First2);
  4109. ; 1559 :                return (*this);
  4110. ; 1560 :                }
  4111. ; 1561 :
  4112. ; 1562 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  4113. ; 1563 :                iterator _First2, iterator _Last2)
  4114. ; 1564 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  4115. ; 1565 :                if (_First2 == _Last2)
  4116. ; 1566 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  4117. ; 1567 :                else
  4118. ; 1568 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  4119. ; 1569 :                                &*_First2, _Last2 - _First2);
  4120. ; 1570 :                return (*this);
  4121. ; 1571 :                }
  4122. ; 1572 :
  4123. ; 1573 :        iterator begin() _NOEXCEPT
  4124. ; 1574 :                {       // return iterator for beginning of mutable sequence
  4125. ; 1575 :                return (_STRING_ITERATOR(this->_Myptr()));
  4126. ; 1576 :                }
  4127. ; 1577 :
  4128. ; 1578 :        const_iterator begin() const _NOEXCEPT
  4129. ; 1579 :                {       // return iterator for beginning of nonmutable sequence
  4130. ; 1580 :                return (_STRING_CONST_ITERATOR(this->_Myptr()));
  4131. ; 1581 :                }
  4132. ; 1582 :
  4133. ; 1583 :        iterator end() _NOEXCEPT
  4134. ; 1584 :                {       // return iterator for end of mutable sequence
  4135. ; 1585 :                return (_STRING_ITERATOR(this->_Myptr() + this->_Mysize));
  4136. ; 1586 :                }
  4137. ; 1587 :
  4138. ; 1588 :        const_iterator end() const _NOEXCEPT
  4139. ; 1589 :                {       // return iterator for end of nonmutable sequence
  4140. ; 1590 :                return (_STRING_CONST_ITERATOR(this->_Myptr() + this->_Mysize));
  4141. ; 1591 :                }
  4142. ; 1592 :
  4143. ; 1593 :        reverse_iterator rbegin() _NOEXCEPT
  4144. ; 1594 :                {       // return iterator for beginning of reversed mutable sequence
  4145. ; 1595 :                return (reverse_iterator(end()));
  4146. ; 1596 :                }
  4147. ; 1597 :
  4148. ; 1598 :        const_reverse_iterator rbegin() const _NOEXCEPT
  4149. ; 1599 :                {       // return iterator for beginning of reversed nonmutable sequence
  4150. ; 1600 :                return (const_reverse_iterator(end()));
  4151. ; 1601 :                }
  4152. ; 1602 :
  4153. ; 1603 :        reverse_iterator rend() _NOEXCEPT
  4154. ; 1604 :                {       // return iterator for end of reversed mutable sequence
  4155. ; 1605 :                return (reverse_iterator(begin()));
  4156. ; 1606 :                }
  4157. ; 1607 :
  4158. ; 1608 :        const_reverse_iterator rend() const _NOEXCEPT
  4159. ; 1609 :                {       // return iterator for end of reversed nonmutable sequence
  4160. ; 1610 :                return (const_reverse_iterator(begin()));
  4161. ; 1611 :                }
  4162. ; 1612 :
  4163. ; 1613 :  #if _HAS_CPP0X
  4164. ; 1614 :        const_iterator cbegin() const _NOEXCEPT
  4165. ; 1615 :                {       // return iterator for beginning of nonmutable sequence
  4166. ; 1616 :                return (((const _Myt *)this)->begin());
  4167. ; 1617 :                }
  4168. ; 1618 :
  4169. ; 1619 :        const_iterator cend() const _NOEXCEPT
  4170. ; 1620 :                {       // return iterator for end of nonmutable sequence
  4171. ; 1621 :                return (((const _Myt *)this)->end());
  4172. ; 1622 :                }
  4173. ; 1623 :
  4174. ; 1624 :        const_reverse_iterator crbegin() const _NOEXCEPT
  4175. ; 1625 :                {       // return iterator for beginning of reversed nonmutable sequence
  4176. ; 1626 :                return (((const _Myt *)this)->rbegin());
  4177. ; 1627 :                }
  4178. ; 1628 :
  4179. ; 1629 :        const_reverse_iterator crend() const _NOEXCEPT
  4180. ; 1630 :                {       // return iterator for end of reversed nonmutable sequence
  4181. ; 1631 :                return (((const _Myt *)this)->rend());
  4182. ; 1632 :                }
  4183. ; 1633 :
  4184. ; 1634 :        void shrink_to_fit()
  4185. ; 1635 :                {       // reduce capacity
  4186. ; 1636 :                if ((size() | this->_ALLOC_MASK) < capacity())
  4187. ; 1637 :                        {       // worth shrinking, do it
  4188. ; 1638 :                        _Myt _Tmp(*this);
  4189. ; 1639 :                        swap(_Tmp);
  4190. ; 1640 :                        }
  4191. ; 1641 :                }
  4192. ; 1642 :  #endif /* _HAS_CPP0X */
  4193. ; 1643 :
  4194. ; 1644 :        reference at(size_type _Off)
  4195. ; 1645 :                {       // subscript mutable sequence with checking
  4196. ; 1646 :                if (this->_Mysize <= _Off)
  4197. ; 1647 :                        _Xran();        // _Off off end
  4198. ; 1648 :                return (this->_Myptr()[_Off]);
  4199. ; 1649 :                }
  4200. ; 1650 :
  4201. ; 1651 :        const_reference at(size_type _Off) const
  4202. ; 1652 :                {       // subscript nonmutable sequence with checking
  4203. ; 1653 :                if (this->_Mysize <= _Off)
  4204. ; 1654 :                        _Xran();        // _Off off end
  4205. ; 1655 :                return (this->_Myptr()[_Off]);
  4206. ; 1656 :                }
  4207. ; 1657 :
  4208. ; 1658 :        reference operator[](size_type _Off)
  4209. ; 1659 :                {       // subscript mutable sequence
  4210. ; 1660 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4211. ; 1661 :                if (this->_Mysize < _Off)       // sic
  4212. ; 1662 :                        _DEBUG_ERROR("string subscript out of range");
  4213. ; 1663 :
  4214. ; 1664 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  4215. ; 1665 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  4216. ; 1666 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4217. ; 1667 :
  4218. ; 1668 :                return (this->_Myptr()[_Off]);
  4219. ; 1669 :                }
  4220. ; 1670 :
  4221. ; 1671 :        const_reference operator[](size_type _Off) const
  4222. ; 1672 :                {       // subscript nonmutable sequence
  4223. ; 1673 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4224. ; 1674 :                if (this->_Mysize < _Off)       // sic
  4225. ; 1675 :                        _DEBUG_ERROR("string subscript out of range");
  4226. ; 1676 :
  4227. ; 1677 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  4228. ; 1678 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  4229. ; 1679 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4230. ; 1680 :
  4231. ; 1681 :                return (this->_Myptr()[_Off]);
  4232. ; 1682 :                }
  4233. ; 1683 :
  4234. ; 1684 :        void push_back(_Elem _Ch)
  4235. ; 1685 :                {       // insert element at end
  4236. ; 1686 :                insert(end(), _Ch);
  4237. ; 1687 :                }
  4238. ; 1688 :
  4239. ; 1689 :  #if _HAS_CPP0X
  4240. ; 1690 :        void pop_back()
  4241. ; 1691 :                {       // erase element at end
  4242. ; 1692 :                erase(this->_Mysize - 1);       // throws if _Mysize == 0
  4243. ; 1693 :                }
  4244. ; 1694 :
  4245. ; 1695 :        reference front()
  4246. ; 1696 :                {       // return first element of mutable sequence
  4247. ; 1697 :                return (*begin());
  4248. ; 1698 :                }
  4249. ; 1699 :
  4250. ; 1700 :        const_reference front() const
  4251. ; 1701 :                {       // return first element of nonmutable sequence
  4252. ; 1702 :                return (*begin());
  4253. ; 1703 :                }
  4254. ; 1704 :
  4255. ; 1705 :        reference back()
  4256. ; 1706 :                {       // return last element of mutable sequence
  4257. ; 1707 :                return (*(end() - 1));
  4258. ; 1708 :                }
  4259. ; 1709 :
  4260. ; 1710 :        const_reference back() const
  4261. ; 1711 :                {       // return last element of nonmutable sequence
  4262. ; 1712 :                return (*(end() - 1));
  4263. ; 1713 :                }
  4264. ; 1714 :  #endif /* _HAS_CPP0X */
  4265. ; 1715 :
  4266. ; 1716 :        const _Elem *c_str() const _NOEXCEPT
  4267. ; 1717 :                {       // return pointer to null-terminated nonmutable array
  4268. ; 1718 :                return (this->_Myptr());
  4269. ; 1719 :                }
  4270. ; 1720 :
  4271. ; 1721 :        const _Elem *data() const _NOEXCEPT
  4272. ; 1722 :                {       // return pointer to nonmutable array
  4273. ; 1723 :                return (c_str());
  4274. ; 1724 :                }
  4275. ; 1725 :
  4276. ; 1726 :        size_type length() const _NOEXCEPT
  4277. ; 1727 :                {       // return length of sequence
  4278. ; 1728 :                return (this->_Mysize);
  4279. ; 1729 :                }
  4280. ; 1730 :
  4281. ; 1731 :        size_type size() const _NOEXCEPT
  4282. ; 1732 :                {       // return length of sequence
  4283. ; 1733 :                return (this->_Mysize);
  4284. ; 1734 :                }
  4285. ; 1735 :
  4286. ; 1736 :        size_type max_size() const _NOEXCEPT
  4287. ; 1737 :                {       // return maximum possible length of sequence
  4288. ; 1738 :                size_type _Num = this->_Getal().max_size();
  4289. ; 1739 :                return (_Num <= 1 ? 1 : _Num - 1);
  4290. ; 1740 :                }
  4291. ; 1741 :
  4292. ; 1742 :        void resize(size_type _Newsize)
  4293. ; 1743 :                {       // determine new length, padding with null elements as needed
  4294. ; 1744 :                resize(_Newsize, _Elem());
  4295. ; 1745 :                }
  4296. ; 1746 :
  4297. ; 1747 :        void resize(size_type _Newsize, _Elem _Ch)
  4298. ; 1748 :                {       // determine new length, padding with _Ch elements as needed
  4299. ; 1749 :                if (_Newsize <= this->_Mysize)
  4300. ; 1750 :                        _Eos(_Newsize);
  4301. ; 1751 :                else
  4302. ; 1752 :                        append(_Newsize - this->_Mysize, _Ch);
  4303. ; 1753 :                }
  4304. ; 1754 :
  4305. ; 1755 :        size_type capacity() const _NOEXCEPT
  4306. ; 1756 :                {       // return current length of allocated storage
  4307. ; 1757 :                return (this->_Myres);
  4308. ; 1758 :                }
  4309. ; 1759 :
  4310. ; 1760 :        void reserve(size_type _Newcap = 0)
  4311. ; 1761 :                {       // determine new minimum length of allocated storage
  4312. ; 1762 :                if (this->_Mysize <= _Newcap && this->_Myres != _Newcap)
  4313. ; 1763 :                        {       // change reservation
  4314. ; 1764 :                        size_type _Size = this->_Mysize;
  4315. ; 1765 :                        if (_Grow(_Newcap, true))
  4316. ; 1766 :                                _Eos(_Size);
  4317. ; 1767 :                        }
  4318. ; 1768 :                }
  4319. ; 1769 :
  4320. ; 1770 :        bool empty() const _NOEXCEPT
  4321. ; 1771 :                {       // test if sequence is empty
  4322. ; 1772 :                return (this->_Mysize == 0);
  4323. ; 1773 :                }
  4324. ; 1774 :
  4325. ; 1775 :        _SCL_INSECURE_DEPRECATE
  4326. ; 1776 :
  4327. ; 1777 :        size_type copy(_Elem *_Ptr,
  4328. ; 1778 :                size_type _Count, size_type _Off = 0) const
  4329. ; 1779 :                {       // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
  4330. ; 1780 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4331. ; 1781 :                if (_Count != 0)
  4332. ; 1782 :                        _DEBUG_POINTER(_Ptr);
  4333. ; 1783 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4334. ; 1784 :
  4335. ; 1785 :                if (this->_Mysize < _Off)
  4336. ; 1786 :                        _Xran();        // _Off off end
  4337. ; 1787 :                if (this->_Mysize - _Off < _Count)
  4338. ; 1788 :                        _Count = this->_Mysize - _Off;
  4339. ; 1789 :                _Traits::copy(_Ptr, this->_Myptr() + _Off, _Count);
  4340. ; 1790 :                return (_Count);
  4341. ; 1791 :                }
  4342. ; 1792 :
  4343. ; 1793 :        size_type _Copy_s(_Elem *_Dest, size_type _Dest_size,
  4344. ; 1794 :                size_type _Count, size_type _Off = 0) const
  4345. ; 1795 :                {       // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Count)
  4346. ; 1796 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4347. ; 1797 :                if (_Count != 0)
  4348. ; 1798 :                        _DEBUG_POINTER(_Dest);
  4349. ; 1799 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4350. ; 1800 :
  4351. ; 1801 :                if (this->_Mysize < _Off)
  4352. ; 1802 :                        _Xran();        // _Off off end
  4353. ; 1803 :                if (this->_Mysize - _Off < _Count)
  4354. ; 1804 :                        _Count = this->_Mysize - _Off;
  4355. ; 1805 :                _Traits::_Copy_s(_Dest, _Dest_size, this->_Myptr() + _Off, _Count);
  4356. ; 1806 :                return (_Count);
  4357. ; 1807 :                }
  4358. ; 1808 :
  4359. ; 1809 :        void _Swap_bx(_Myt& _Right)
  4360. ; 1810 :                {       // exchange _Bx with _Right._Bx
  4361. ; 1811 :                if (this->_BUF_SIZE <= this->_Myres)
  4362. ; 1812 :                        if (this->_BUF_SIZE <= _Right._Myres)
  4363. ; 1813 :                                _Swap_adl(this->_Bx._Ptr, _Right._Bx._Ptr);
  4364. ; 1814 :                        else
  4365. ; 1815 :                                {       // swap large with small
  4366. ; 1816 :                                pointer _Ptr = this->_Bx._Ptr;
  4367. ; 1817 :                                this->_Getal().destroy(&this->_Bx._Ptr);
  4368. ; 1818 :                                _Traits::copy(this->_Bx._Buf,
  4369. ; 1819 :                                        _Right._Bx._Buf, _Right._Mysize + 1);
  4370. ; 1820 :                                this->_Getal().construct(&_Right._Bx._Ptr, _Ptr);
  4371. ; 1821 :                                }
  4372. ; 1822 :                else
  4373. ; 1823 :                        if (_Right._Myres < this->_BUF_SIZE)
  4374. ; 1824 :                                _STD swap(this->_Bx._Buf, _Right._Bx._Buf);
  4375. ; 1825 :                        else
  4376. ; 1826 :                                {       // swap small with large
  4377. ; 1827 :                                pointer _Ptr = _Right._Bx._Ptr;
  4378. ; 1828 :                                this->_Getal().destroy(&_Right._Bx._Ptr);
  4379. ; 1829 :                                _Traits::copy(_Right._Bx._Buf,
  4380. ; 1830 :                                        this->_Bx._Buf, this->_Mysize + 1);
  4381. ; 1831 :                                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
  4382. ; 1832 :                                }
  4383. ; 1833 :                }
  4384. ; 1834 :
  4385. ; 1835 :        void swap(_Myt& _Right)
  4386. ; 1836 :                {       // exchange contents with _Right
  4387. ; 1837 :                if (this == &_Right)
  4388. ; 1838 :                        ;       // same object, do nothing
  4389. ; 1839 :                else if (this->_Getal() == _Right._Getal())
  4390. ; 1840 :                        {       // same allocator, swap control information
  4391. ; 1841 :                        this->_Swap_all(_Right);
  4392. ; 1842 :                        _Swap_bx(_Right);
  4393. ; 1843 :                        _STD swap(this->_Mysize, _Right._Mysize);
  4394. ; 1844 :                        _STD swap(this->_Myres, _Right._Myres);
  4395. ; 1845 :                        }
  4396. ; 1846 :
  4397. ; 1847 :  #if _HAS_CPP0X
  4398. ; 1848 :                else if (_Alty::propagate_on_container_swap::value)
  4399. ; 1849 :                        {       // swap allocators and control information
  4400. ; 1850 :                        this->_Swap_alloc(_Right);
  4401. ; 1851 :                        _Swap_bx(_Right);
  4402. ; 1852 :                        _STD swap(this->_Bx, _Right._Bx);       // pointer bitwise copyable?
  4403. ; 1853 :                        _STD swap(this->_Mysize, _Right._Mysize);
  4404. ; 1854 :                        _STD swap(this->_Myres, _Right._Myres);
  4405. ; 1855 :                        }
  4406. ; 1856 :  #endif /* _HAS_CPP0X */
  4407. ; 1857 :
  4408. ; 1858 :                else
  4409. ; 1859 :                        {       // different allocator, do multiple assigns
  4410. ; 1860 :                        _Myt _Tmp = *this;
  4411. ; 1861 :
  4412. ; 1862 :                        *this = _Right;
  4413. ; 1863 :                        _Right = _Tmp;
  4414. ; 1864 :                        }
  4415. ; 1865 :                }
  4416. ; 1866 :
  4417. ; 1867 :        size_type find(const _Myt& _Right, size_type _Off = 0) const _NOEXCEPT
  4418. ; 1868 :                {       // look for _Right beginning at or after _Off
  4419. ; 1869 :                return (find(_Right._Myptr(), _Off, _Right.size()));
  4420. ; 1870 :                }
  4421. ; 1871 :
  4422. ; 1872 :        size_type find(const _Elem *_Ptr,
  4423. ; 1873 :                size_type _Off, size_type _Count) const
  4424. ; 1874 :                {       // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
  4425. ; 1875 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4426. ; 1876 :                if (_Count != 0)
  4427. ; 1877 :                        _DEBUG_POINTER(_Ptr);
  4428. ; 1878 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4429. ; 1879 :
  4430. ; 1880 :                if (_Count == 0 && _Off <= this->_Mysize)
  4431. ; 1881 :                        return (_Off);  // null string always matches (if inside string)
  4432. ; 1882 :
  4433. ; 1883 :                size_type _Nm;
  4434. ; 1884 :                if (_Off < this->_Mysize && _Count <= (_Nm = this->_Mysize - _Off))
  4435. ; 1885 :                        {       // room for match, look for it
  4436. ; 1886 :                        const _Elem *_Uptr, *_Vptr;
  4437. ; 1887 :                        for (_Nm -= _Count - 1, _Vptr = this->_Myptr() + _Off;
  4438. ; 1888 :                                (_Uptr = _Traits::find(_Vptr, _Nm, *_Ptr)) != 0;
  4439. ; 1889 :                                _Nm -= _Uptr - _Vptr + 1, _Vptr = _Uptr + 1)
  4440. ; 1890 :                                if (_Traits::compare(_Uptr, _Ptr, _Count) == 0)
  4441. ; 1891 :                                        return (_Uptr - this->_Myptr());        // found a match
  4442. ; 1892 :                        }
  4443. ; 1893 :
  4444. ; 1894 :                return (npos);  // no match
  4445. ; 1895 :                }
  4446. ; 1896 :
  4447. ; 1897 :        size_type find(const _Elem *_Ptr, size_type _Off = 0) const
  4448. ; 1898 :                {       // look for [_Ptr, <null>) beginning at or after _Off
  4449. ; 1899 :                _DEBUG_POINTER(_Ptr);
  4450. ; 1900 :                return (find(_Ptr, _Off, _Traits::length(_Ptr)));
  4451. ; 1901 :                }
  4452. ; 1902 :
  4453. ; 1903 :        size_type find(_Elem _Ch, size_type _Off = 0) const
  4454. ; 1904 :                {       // look for _Ch at or after _Off
  4455. ; 1905 :                return (find((const _Elem *)&_Ch, _Off, 1));
  4456. ; 1906 :                }
  4457. ; 1907 :
  4458. ; 1908 :        size_type rfind(const _Myt& _Right, size_type _Off = npos) const _NOEXCEPT
  4459. ; 1909 :                {       // look for _Right beginning before _Off
  4460. ; 1910 :                return (rfind(_Right._Myptr(), _Off, _Right.size()));
  4461. ; 1911 :                }
  4462. ; 1912 :
  4463. ; 1913 :        size_type rfind(const _Elem *_Ptr,
  4464. ; 1914 :                size_type _Off, size_type _Count) const
  4465. ; 1915 :                {       // look for [_Ptr, _Ptr + _Count) beginning before _Off
  4466. ; 1916 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4467. ; 1917 :                if (_Count != 0)
  4468. ; 1918 :                        _DEBUG_POINTER(_Ptr);
  4469. ; 1919 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4470. ; 1920 :
  4471. ; 1921 :                if (_Count == 0)
  4472. ; 1922 :                        return (_Off < this->_Mysize ? _Off
  4473. ; 1923 :                                : this->_Mysize);       // null always matches
  4474. ; 1924 :                if (_Count <= this->_Mysize)
  4475. ; 1925 :                        {       // room for match, look for it
  4476. ; 1926 :                        const _Elem *_Uptr = this->_Myptr() +
  4477. ; 1927 :                                (_Off < this->_Mysize - _Count ? _Off
  4478. ; 1928 :                                        : this->_Mysize - _Count);
  4479. ; 1929 :                        for (; ; --_Uptr)
  4480. ; 1930 :                                if (_Traits::eq(*_Uptr, *_Ptr)
  4481. ; 1931 :                                        && _Traits::compare(_Uptr, _Ptr, _Count) == 0)
  4482. ; 1932 :                                        return (_Uptr - this->_Myptr());        // found a match
  4483. ; 1933 :                                else if (_Uptr == this->_Myptr())
  4484. ; 1934 :                                        break;  // at beginning, no more chance for match
  4485. ; 1935 :                        }
  4486. ; 1936 :
  4487. ; 1937 :                return (npos);  // no match
  4488. ; 1938 :                }
  4489. ; 1939 :
  4490. ; 1940 :        size_type rfind(const _Elem *_Ptr, size_type _Off = npos) const
  4491. ; 1941 :                {       // look for [_Ptr, <null>) beginning before _Off
  4492. ; 1942 :                _DEBUG_POINTER(_Ptr);
  4493. ; 1943 :                return (rfind(_Ptr, _Off, _Traits::length(_Ptr)));
  4494. ; 1944 :                }
  4495. ; 1945 :
  4496. ; 1946 :        size_type rfind(_Elem _Ch, size_type _Off = npos) const
  4497. ; 1947 :                {       // look for _Ch before _Off
  4498. ; 1948 :                return (rfind((const _Elem *)&_Ch, _Off, 1));
  4499. ; 1949 :                }
  4500. ; 1950 :
  4501. ; 1951 :        size_type find_first_of(const _Myt& _Right,
  4502. ; 1952 :                size_type _Off = 0) const _NOEXCEPT
  4503. ; 1953 :                {       // look for one of _Right at or after _Off
  4504. ; 1954 :                return (find_first_of(_Right._Myptr(), _Off, _Right.size()));
  4505. ; 1955 :                }
  4506. ; 1956 :
  4507. ; 1957 :        size_type find_first_of(const _Elem *_Ptr,
  4508. ; 1958 :                size_type _Off, size_type _Count) const
  4509. ; 1959 :                {       // look for one of [_Ptr, _Ptr + _Count) at or after _Off
  4510. ; 1960 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4511. ; 1961 :                if (_Count != 0)
  4512. ; 1962 :                        _DEBUG_POINTER(_Ptr);
  4513. ; 1963 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4514. ; 1964 :
  4515. ; 1965 :                if (0 < _Count && _Off < this->_Mysize)
  4516. ; 1966 :                        {       // room for match, look for it
  4517. ; 1967 :                        const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
  4518. ; 1968 :                        for (const _Elem *_Uptr = this->_Myptr() + _Off;
  4519. ; 1969 :                                _Uptr < _Vptr; ++_Uptr)
  4520. ; 1970 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
  4521. ; 1971 :                                        return (_Uptr - this->_Myptr());        // found a match
  4522. ; 1972 :                        }
  4523. ; 1973 :
  4524. ; 1974 :                return (npos);  // no match
  4525. ; 1975 :                }
  4526. ; 1976 :
  4527. ; 1977 :        size_type find_first_of(const _Elem *_Ptr,
  4528. ; 1978 :                size_type _Off = 0) const
  4529. ; 1979 :                {       // look for one of [_Ptr, <null>) at or after _Off
  4530. ; 1980 :                _DEBUG_POINTER(_Ptr);
  4531. ; 1981 :                return (find_first_of(_Ptr, _Off, _Traits::length(_Ptr)));
  4532. ; 1982 :                }
  4533. ; 1983 :
  4534. ; 1984 :        size_type find_first_of(_Elem _Ch,
  4535. ; 1985 :                size_type _Off = 0) const
  4536. ; 1986 :                {       // look for _Ch at or after _Off
  4537. ; 1987 :                return (find((const _Elem *)&_Ch, _Off, 1));
  4538. ; 1988 :                }
  4539. ; 1989 :
  4540. ; 1990 :        size_type find_last_of(const _Myt& _Right,
  4541. ; 1991 :                size_type _Off = npos) const _NOEXCEPT
  4542. ; 1992 :                {       // look for one of _Right before _Off
  4543. ; 1993 :                return (find_last_of(_Right._Myptr(), _Off, _Right.size()));
  4544. ; 1994 :                }
  4545. ; 1995 :
  4546. ; 1996 :        size_type find_last_of(const _Elem *_Ptr,
  4547. ; 1997 :                size_type _Off, size_type _Count) const
  4548. ; 1998 :                {       // look for one of [_Ptr, _Ptr + _Count) before _Off
  4549. ; 1999 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4550. ; 2000 :                if (_Count != 0)
  4551. ; 2001 :                        _DEBUG_POINTER(_Ptr);
  4552. ; 2002 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4553. ; 2003 :
  4554. ; 2004 :                if (0 < _Count && 0 < this->_Mysize)
  4555. ; 2005 :                        {       // worth searching, do it
  4556. ; 2006 :                        const _Elem *_Uptr = this->_Myptr()
  4557. ; 2007 :                                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
  4558. ; 2008 :                        for (; ; --_Uptr)
  4559. ; 2009 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
  4560. ; 2010 :                                        return (_Uptr - this->_Myptr());        // found a match
  4561. ; 2011 :                                else if (_Uptr == this->_Myptr())
  4562. ; 2012 :                                        break;  // at beginning, no more chance for match
  4563. ; 2013 :                        }
  4564. ; 2014 :
  4565. ; 2015 :                return (npos);  // no match
  4566. ; 2016 :                }
  4567. ; 2017 :
  4568. ; 2018 :        size_type find_last_of(const _Elem *_Ptr,
  4569. ; 2019 :                size_type _Off = npos) const
  4570. ; 2020 :                {       // look for one of [_Ptr, <null>) before _Off
  4571. ; 2021 :                _DEBUG_POINTER(_Ptr);
  4572. ; 2022 :                return (find_last_of(_Ptr, _Off, _Traits::length(_Ptr)));
  4573. ; 2023 :                }
  4574. ; 2024 :
  4575. ; 2025 :        size_type find_last_of(_Elem _Ch,
  4576. ; 2026 :                size_type _Off = npos) const
  4577. ; 2027 :                {       // look for _Ch before _Off
  4578. ; 2028 :                return (rfind((const _Elem *)&_Ch, _Off, 1));
  4579. ; 2029 :                }
  4580. ; 2030 :
  4581. ; 2031 :        size_type find_first_not_of(const _Myt& _Right,
  4582. ; 2032 :                size_type _Off = 0) const _NOEXCEPT
  4583. ; 2033 :                {       // look for none of _Right at or after _Off
  4584. ; 2034 :                return (find_first_not_of(_Right._Myptr(), _Off,
  4585. ; 2035 :                        _Right.size()));
  4586. ; 2036 :                }
  4587. ; 2037 :
  4588. ; 2038 :        size_type find_first_not_of(const _Elem *_Ptr,
  4589. ; 2039 :                size_type _Off, size_type _Count) const
  4590. ; 2040 :                {       // look for none of [_Ptr, _Ptr + _Count) at or after _Off
  4591. ; 2041 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4592. ; 2042 :                if (_Count != 0)
  4593. ; 2043 :                        _DEBUG_POINTER(_Ptr);
  4594. ; 2044 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4595. ; 2045 :
  4596. ; 2046 :                if (_Off < this->_Mysize)
  4597. ; 2047 :                        {       // room for match, look for it
  4598. ; 2048 :                        const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
  4599. ; 2049 :                        for (const _Elem *_Uptr = this->_Myptr() + _Off;
  4600. ; 2050 :                                _Uptr < _Vptr; ++_Uptr)
  4601. ; 2051 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
  4602. ; 2052 :                                        return (_Uptr - this->_Myptr());
  4603. ; 2053 :                        }
  4604. ; 2054 :                return (npos);
  4605. ; 2055 :                }
  4606. ; 2056 :
  4607. ; 2057 :        size_type find_first_not_of(const _Elem *_Ptr,
  4608. ; 2058 :                size_type _Off = 0) const
  4609. ; 2059 :                {       // look for one of [_Ptr, <null>) at or after _Off
  4610. ; 2060 :                _DEBUG_POINTER(_Ptr);
  4611. ; 2061 :                return (find_first_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
  4612. ; 2062 :                }
  4613. ; 2063 :
  4614. ; 2064 :        size_type find_first_not_of(_Elem _Ch,
  4615. ; 2065 :                size_type _Off = 0) const
  4616. ; 2066 :                {       // look for non _Ch at or after _Off
  4617. ; 2067 :                return (find_first_not_of((const _Elem *)&_Ch, _Off, 1));
  4618. ; 2068 :                }
  4619. ; 2069 :
  4620. ; 2070 :        size_type find_last_not_of(const _Myt& _Right,
  4621. ; 2071 :                size_type _Off = npos) const _NOEXCEPT
  4622. ; 2072 :                {       // look for none of _Right before _Off
  4623. ; 2073 :                return (find_last_not_of(_Right._Myptr(), _Off, _Right.size()));
  4624. ; 2074 :                }
  4625. ; 2075 :
  4626. ; 2076 :        size_type find_last_not_of(const _Elem *_Ptr,
  4627. ; 2077 :                size_type _Off, size_type _Count) const
  4628. ; 2078 :                {       // look for none of [_Ptr, _Ptr + _Count) before _Off
  4629. ; 2079 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4630. ; 2080 :                if (_Count != 0)
  4631. ; 2081 :                        _DEBUG_POINTER(_Ptr);
  4632. ; 2082 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4633. ; 2083 :
  4634. ; 2084 :                if (0 < this->_Mysize)
  4635. ; 2085 :                        {       // worth searching, do it
  4636. ; 2086 :                        const _Elem *_Uptr = this->_Myptr()
  4637. ; 2087 :                                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
  4638. ; 2088 :                        for (; ; --_Uptr)
  4639. ; 2089 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
  4640. ; 2090 :                                        return (_Uptr - this->_Myptr());
  4641. ; 2091 :                                else if (_Uptr == this->_Myptr())
  4642. ; 2092 :                                        break;
  4643. ; 2093 :                        }
  4644. ; 2094 :                return (npos);
  4645. ; 2095 :                }
  4646. ; 2096 :
  4647. ; 2097 :        size_type find_last_not_of(const _Elem *_Ptr,
  4648. ; 2098 :                size_type _Off = npos) const
  4649. ; 2099 :                {       // look for none of [_Ptr, <null>) before _Off
  4650. ; 2100 :                _DEBUG_POINTER(_Ptr);
  4651. ; 2101 :                return (find_last_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
  4652. ; 2102 :                }
  4653. ; 2103 :
  4654. ; 2104 :        size_type find_last_not_of(_Elem _Ch,
  4655. ; 2105 :                size_type _Off = npos) const
  4656. ; 2106 :                {       // look for non _Ch before _Off
  4657. ; 2107 :                return (find_last_not_of((const _Elem *)&_Ch, _Off, 1));
  4658. ; 2108 :                }
  4659. ; 2109 :
  4660. ; 2110 :        _Myt substr(size_type _Off = 0, size_type _Count = npos) const
  4661. ; 2111 :                {       // return [_Off, _Off + _Count) as new string
  4662. ; 2112 :                return (_Myt(*this, _Off, _Count, get_allocator()));
  4663. ; 2113 :                }
  4664. ; 2114 :
  4665. ; 2115 :        int compare(const _Myt& _Right) const _NOEXCEPT
  4666. ; 2116 :                {       // compare [0, _Mysize) with _Right
  4667. ; 2117 :                return (compare(0, this->_Mysize, _Right._Myptr(), _Right.size()));
  4668. ; 2118 :                }
  4669. ; 2119 :
  4670. ; 2120 :        int compare(size_type _Off, size_type _N0,
  4671. ; 2121 :                const _Myt& _Right) const
  4672. ; 2122 :                {       // compare [_Off, _Off + _N0) with _Right
  4673. ; 2123 :                return (compare(_Off, _N0, _Right, 0, npos));
  4674. ; 2124 :                }
  4675. ; 2125 :
  4676. ; 2126 :        int compare(size_type _Off,
  4677. ; 2127 :                size_type _N0, const _Myt& _Right,
  4678. ; 2128 :                size_type _Roff, size_type _Count) const
  4679. ; 2129 :                {       // compare [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
  4680. ; 2130 :                if (_Right.size() < _Roff)
  4681. ; 2131 :                        _Xran();        // _Off off end
  4682. ; 2132 :                if (_Right._Mysize - _Roff < _Count)
  4683. ; 2133 :                        _Count = _Right._Mysize - _Roff;        // trim _Count to size
  4684. ; 2134 :                return (compare(_Off, _N0, _Right._Myptr() + _Roff, _Count));
  4685. ; 2135 :                }
  4686. ; 2136 :
  4687. ; 2137 :        int compare(const _Elem *_Ptr) const
  4688. ; 2138 :                {       // compare [0, _Mysize) with [_Ptr, <null>)
  4689. ; 2139 :                _DEBUG_POINTER(_Ptr);
  4690. ; 2140 :                return (compare(0, this->_Mysize, _Ptr, _Traits::length(_Ptr)));
  4691. ; 2141 :                }
  4692. ; 2142 :
  4693. ; 2143 :        int compare(size_type _Off, size_type _N0, const _Elem *_Ptr) const
  4694. ; 2144 :                {       // compare [_Off, _Off + _N0) with [_Ptr, <null>)
  4695. ; 2145 :                _DEBUG_POINTER(_Ptr);
  4696. ; 2146 :                return (compare(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
  4697. ; 2147 :                }
  4698. ; 2148 :
  4699. ; 2149 :        int compare(size_type _Off,
  4700. ; 2150 :                size_type _N0, const _Elem *_Ptr, size_type _Count) const
  4701. ; 2151 :                {       // compare [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
  4702. ; 2152 :  #if _ITERATOR_DEBUG_LEVEL == 2
  4703. ; 2153 :                if (_Count != 0)
  4704. ; 2154 :                        _DEBUG_POINTER(_Ptr);
  4705. ; 2155 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  4706. ; 2156 :
  4707. ; 2157 :                if (this->_Mysize < _Off)
  4708. ; 2158 :                        _Xran();        // _Off off end
  4709. ; 2159 :                if (this->_Mysize - _Off < _N0)
  4710. ; 2160 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  4711. ; 2161 :
  4712. ; 2162 :                size_type _Ans = _Traits::compare(this->_Myptr() + _Off, _Ptr,
  4713. ; 2163 :                        _N0 < _Count ? _N0 : _Count);
  4714. ; 2164 :                return (_Ans != 0 ? (int)_Ans : _N0 < _Count ? -1
  4715. ; 2165 :                        : _N0 == _Count ? 0 : +1);
  4716. ; 2166 :                }
  4717. ; 2167 :
  4718. ; 2168 :        allocator_type get_allocator() const _NOEXCEPT
  4719. ; 2169 :                {       // return allocator object for values
  4720. ; 2170 :                return (this->_Getal());
  4721. ; 2171 :                }
  4722. ; 2172 :
  4723. ; 2173 :        void _Chassign(size_type _Off, size_type _Count, _Elem _Ch)
  4724. ; 2174 :                {       // assign _Count copies of _Ch beginning at _Off
  4725. ; 2175 :                if (_Count == 1)
  4726. ; 2176 :                        _Traits::assign(*(this->_Myptr() + _Off), _Ch);
  4727. ; 2177 :                else
  4728. ; 2178 :                        _Traits::assign(this->_Myptr() + _Off, _Count, _Ch);
  4729. ; 2179 :                }
  4730. ; 2180 :
  4731. ; 2181 :        void _Copy(size_type _Newsize, size_type _Oldlen)
  4732. ; 2182 :                {       // copy _Oldlen elements to newly allocated buffer
  4733. ; 2183 :                size_type _Newres = _Newsize | this->_ALLOC_MASK;
  4734. ; 2184 :                if (max_size() < _Newres)
  4735. ; 2185 :                        _Newres = _Newsize;     // undo roundup if too big
  4736. ; 2186 :                else if (this->_Myres / 2 <= _Newres / 3)
  4737. ; 2187 :                        ;
  4738. ; 2188 :                else if (this->_Myres <= max_size() - this->_Myres / 2)
  4739. ; 2189 :                        _Newres = this->_Myres
  4740. ; 2190 :                                + this->_Myres / 2;     // grow exponentially if possible
  4741. ; 2191 :                else
  4742. ; 2192 :                        _Newres = max_size();   // settle for max_size()
  4743. ; 2193 :
  4744. ; 2194 :                _Elem *_Ptr;
  4745. ; 2195 :                _TRY_BEGIN
  4746. ; 2196 :                        _Ptr = this->_Getal().allocate(_Newres + 1);
  4747. ; 2197 :                _CATCH_ALL
  4748. ; 2198 :                        _Newres = _Newsize;     // allocation failed, undo roundup and retry
  4749. ; 2199 :                        _TRY_BEGIN
  4750. ; 2200 :                                _Ptr = this->_Getal().allocate(_Newres + 1);
  4751. ; 2201 :                        _CATCH_ALL
  4752. ; 2202 :                        _Tidy(true);    // failed again, discard storage and reraise
  4753. ; 2203 :                        _RERAISE;
  4754. ; 2204 :                        _CATCH_END
  4755. ; 2205 :                _CATCH_END
  4756. ; 2206 :
  4757. ; 2207 :                if (0 < _Oldlen)
  4758. ; 2208 :                        _Traits::copy(_Ptr, this->_Myptr(),
  4759. ; 2209 :                                _Oldlen);       // copy existing elements
  4760. ; 2210 :                _Tidy(true);
  4761. ; 2211 :                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
  4762. ; 2212 :                this->_Myres = _Newres;
  4763. ; 2213 :                _Eos(_Oldlen);
  4764. ; 2214 :                }
  4765. ; 2215 :
  4766. ; 2216 :        void _Eos(size_type _Newsize)
  4767. ; 2217 :                {       // set new length and null terminator
  4768. ; 2218 :                _Traits::assign(this->_Myptr()[this->_Mysize = _Newsize], _Elem());
  4769.  
  4770.         mov     DWORD PTR [esi+16], edi
  4771.  
  4772. ; 517  :                        : this->_Bx._Buf);
  4773.  
  4774.         jb      SHORT $LN51@assign
  4775. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  4776.  
  4777. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  4778.  
  4779.         mov     eax, DWORD PTR [esi]
  4780. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  4781.  
  4782. ; 564  :                _Left = _Right;
  4783.  
  4784.         mov     BYTE PTR [eax+edi], 0
  4785.         pop     edi
  4786. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  4787.  
  4788. ; 1119 :                return (*this);
  4789.  
  4790.         mov     eax, esi
  4791.         pop     esi
  4792.         pop     ebx
  4793.  
  4794. ; 1120 :                }
  4795.  
  4796.         pop     ebp
  4797.         ret     12                                      ; 0000000cH
  4798. $LN51@assign:
  4799.  
  4800. ; 517  :                        : this->_Bx._Buf);
  4801.  
  4802.         mov     eax, esi
  4803. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  4804.  
  4805. ; 564  :                _Left = _Right;
  4806.  
  4807.         mov     BYTE PTR [eax+edi], 0
  4808. $LN55@assign:
  4809.         pop     edi
  4810. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  4811.  
  4812. ; 1119 :                return (*this);
  4813.  
  4814.         mov     eax, esi
  4815.         pop     esi
  4816.         pop     ebx
  4817.  
  4818. ; 1120 :                }
  4819.  
  4820.         pop     ebp
  4821.         ret     12                                      ; 0000000cH
  4822. $LN58@assign:
  4823. ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@ABV12@II@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign
  4824. _TEXT   ENDS
  4825. ; Function compile flags: /Ogtp
  4826. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  4827. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  4828. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  4829. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  4830. ;       COMDAT ?_Grow@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE_NI_N@Z
  4831. _TEXT   SEGMENT
  4832. __Newsize$ = 8                                          ; size = 4
  4833. __Trim$dead$ = 12                                       ; size = 1
  4834. ?_Grow@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE_NI_N@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Grow, COMDAT
  4835. ; _this$ = ecx
  4836.  
  4837. ; 2223 :                {       // ensure buffer is big enough, trim to size if _Trim is true
  4838.  
  4839.         push    ebp
  4840.         mov     ebp, esp
  4841.         push    esi
  4842.  
  4843. ; 2224 :                if (max_size() < _Newsize)
  4844.  
  4845.         mov     esi, DWORD PTR __Newsize$[ebp]
  4846.         cmp     esi, -2                                 ; fffffffeH
  4847.         jbe     SHORT $LN6@Grow
  4848.  
  4849. ; 2235 :
  4850. ; 2236 :        bool _Inside(const _Elem *_Ptr)
  4851. ; 2237 :                {       // test if _Ptr points inside string
  4852. ; 2238 :                if (_Ptr == 0 || _Ptr < this->_Myptr()
  4853. ; 2239 :                        || this->_Myptr() + this->_Mysize <= _Ptr)
  4854. ; 2240 :                        return (false); // don't ask
  4855. ; 2241 :                else
  4856. ; 2242 :                        return (true);
  4857. ; 2243 :                }
  4858. ; 2244 :
  4859. ; 2245 :        static size_type _Pdif(const_iterator _P2,
  4860. ; 2246 :                const_iterator _P1)
  4861. ; 2247 :                {       // compute safe iterator difference
  4862. ; 2248 :                return (_STRING_ITER_BASE(_P2) == 0 ? 0 : _P2 - _P1);
  4863. ; 2249 :                }
  4864. ; 2250 :
  4865. ; 2251 :        void _Tidy(bool _Built = false,
  4866. ; 2252 :                size_type _Newsize = 0)
  4867. ; 2253 :                {       // initialize buffer, deallocating any storage
  4868. ; 2254 :                if (!_Built)
  4869. ; 2255 :                        ;
  4870. ; 2256 :                else if (this->_BUF_SIZE <= this->_Myres)
  4871. ; 2257 :                        {       // copy any leftovers to small buffer and deallocate
  4872. ; 2258 :                        pointer _Ptr = this->_Bx._Ptr;
  4873. ; 2259 :                        this->_Getal().destroy(&this->_Bx._Ptr);
  4874. ; 2260 :                        if (0 < _Newsize)
  4875. ; 2261 :                                _Traits::copy(this->_Bx._Buf,
  4876. ; 2262 :                                        _STD addressof(*_Ptr), _Newsize);
  4877. ; 2263 :                        this->_Getal().deallocate(_Ptr, this->_Myres + 1);
  4878. ; 2264 :                        }
  4879. ; 2265 :                this->_Myres = this->_BUF_SIZE - 1;
  4880. ; 2266 :                _Eos(_Newsize);
  4881. ; 2267 :                }
  4882. ; 2268 :
  4883. ; 2269 :        __declspec(noreturn) void _Xlen() const
  4884. ; 2270 :                {       // report a length_error
  4885. ; 2271 :                _Xlength_error("string too long");
  4886.  
  4887.         push    OFFSET ??_C@_0BA@JFNIOLAK@string?5too?5long?$AA@
  4888.         call    DWORD PTR __imp_?_Xlength_error@std@@YAXPBD@Z
  4889. $LN68@Grow:
  4890. $LN6@Grow:
  4891.  
  4892. ; 2225 :                        _Xlen();        // result too long
  4893. ; 2226 :                if (this->_Myres < _Newsize)
  4894.  
  4895.         mov     eax, DWORD PTR [ecx+20]
  4896.         cmp     eax, esi
  4897.         jae     SHORT $LN3@Grow
  4898.  
  4899. ; 2227 :                        _Copy(_Newsize, this->_Mysize); // reallocate to grow
  4900.  
  4901.         push    DWORD PTR [ecx+16]
  4902.         push    esi
  4903.         call    ?_Copy@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEXII@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Copy
  4904.  
  4905. ; 2233 :                return (0 < _Newsize);  // return true only if more work to do
  4906.  
  4907.         xor     eax, eax
  4908.         cmp     eax, esi
  4909.         sbb     eax, eax
  4910.         neg     eax
  4911.         pop     esi
  4912.  
  4913. ; 2234 :                }
  4914.  
  4915.         pop     ebp
  4916.         ret     8
  4917. $LN3@Grow:
  4918.  
  4919. ; 2228 :                else if (_Trim && _Newsize < this->_BUF_SIZE)
  4920. ; 2229 :                        _Tidy(true,     // copy and deallocate if trimming to small string
  4921. ; 2230 :                                _Newsize < this->_Mysize ? _Newsize : this->_Mysize);
  4922. ; 2231 :                else if (_Newsize == 0)
  4923.  
  4924.         test    esi, esi
  4925.         jne     SHORT $LN64@Grow
  4926.  
  4927. ; 518  :                }
  4928. ; 519  :
  4929. ; 520  :        const value_type *_Myptr() const
  4930. ; 521  :                {       // determine current pointer to buffer for nonmutable string
  4931. ; 522  :                return (this->_BUF_SIZE <= this->_Myres
  4932. ; 523  :                        ? _STD addressof(*this->_Bx._Ptr)
  4933. ; 524  :                        : this->_Bx._Buf);
  4934. ; 525  :                }
  4935. ; 526  :
  4936. ; 527  :        union _Bxty
  4937. ; 528  :                {       // storage for small buffer or pointer to larger one
  4938. ; 529  :                value_type _Buf[_BUF_SIZE];
  4939. ; 530  :                pointer _Ptr;
  4940. ; 531  :                char _Alias[_BUF_SIZE]; // to permit aliasing
  4941. ; 532  :                } _Bx;
  4942. ; 533  :
  4943. ; 534  :        size_type _Mysize;      // current length of string
  4944. ; 535  :        size_type _Myres;       // current storage reserved for string
  4945. ; 536  :        };
  4946. ; 537  :
  4947. ; 538  :                // TEMPLATE CLASS _String_alloc
  4948. ; 539  : template<bool _Al_has_storage,
  4949. ; 540  :        class _Alloc_types>
  4950. ; 541  :        class _String_alloc
  4951. ; 542  :                : public _String_val<typename _Alloc_types::_Val_types>
  4952. ; 543  :        {       // base class for basic_string to hold allocator with storage
  4953. ; 544  : public:
  4954. ; 545  :        typedef _String_alloc<_Al_has_storage, _Alloc_types> _Myt;
  4955. ; 546  :        typedef typename _Alloc_types::_Alloc _Alloc;
  4956. ; 547  :
  4957. ; 548  :        typedef typename _Alloc_types::_Alty _Alty;
  4958. ; 549  :
  4959. ; 550  :  #if _ITERATOR_DEBUG_LEVEL == 0
  4960. ; 551  :        _String_alloc(const _Alloc& _Al = _Alloc())
  4961. ; 552  :                : _Alval(_Al)
  4962. ; 553  :                {       // construct allocator from _Al
  4963. ; 554  :                }
  4964. ; 555  :
  4965. ; 556  :        void _Change_alloc(const _Alty& _Al)
  4966. ; 557  :                {       // replace old allocator
  4967. ; 558  :                _Alval = _Al;
  4968. ; 559  :                }
  4969. ; 560  :
  4970. ; 561  :        void _Swap_alloc(_Myt& _Right)
  4971. ; 562  :                {       // swap allocators
  4972. ; 563  :                _Swap_adl(this->_Alval, _Right._Alval);
  4973. ; 564  :                }
  4974. ; 565  :
  4975. ; 566  :  #else /* _ITERATOR_DEBUG_LEVEL == 0 */
  4976. ; 567  :        _String_alloc(const _Alloc& _Al = _Alloc())
  4977. ; 568  :                : _Alval(_Al)
  4978. ; 569  :                {       // construct allocator from _Al
  4979. ; 570  :                _Alloc_proxy();
  4980. ; 571  :                }
  4981. ; 572  :
  4982. ; 573  :        ~_String_alloc() _NOEXCEPT
  4983. ; 574  :                {       // destroy the object
  4984. ; 575  :                _Free_proxy();
  4985. ; 576  :                }
  4986. ; 577  :
  4987. ; 578  :        void _Change_alloc(const _Alty& _Al)
  4988. ; 579  :                {       // replace old allocator
  4989. ; 580  :                _Free_proxy();
  4990. ; 581  :                _Alval = _Al;
  4991. ; 582  :                _Alloc_proxy();
  4992. ; 583  :                }
  4993. ; 584  :
  4994. ; 585  :        void _Swap_alloc(_Myt& _Right)
  4995. ; 586  :                {       // swap allocators
  4996. ; 587  :                _Swap_adl(_Alval, _Right._Alval);
  4997. ; 588  :                _Swap_adl(this->_Myproxy, _Right._Myproxy);
  4998. ; 589  :                }
  4999. ; 590  :
  5000. ; 591  :        void _Alloc_proxy()
  5001. ; 592  :                {       // construct proxy from _Alval
  5002. ; 593  :                typename _Alloc::template rebind<_Container_proxy>::other
  5003. ; 594  :                        _Alproxy(_Alval);
  5004. ; 595  :                this->_Myproxy = _Alproxy.allocate(1);
  5005. ; 596  :                _Alproxy.construct(this->_Myproxy, _Container_proxy());
  5006. ; 597  :                this->_Myproxy->_Mycont = this;
  5007. ; 598  :                }
  5008. ; 599  :
  5009. ; 600  :        void _Free_proxy()
  5010. ; 601  :                {       // destroy proxy
  5011. ; 602  :                typename _Alloc::template rebind<_Container_proxy>::other
  5012. ; 603  :                        _Alproxy(_Alval);
  5013. ; 604  :                this->_Orphan_all();
  5014. ; 605  :                _Alproxy.destroy(this->_Myproxy);
  5015. ; 606  :                _Alproxy.deallocate(this->_Myproxy, 1);
  5016. ; 607  :                this->_Myproxy = 0;
  5017. ; 608  :                }
  5018. ; 609  :  #endif /* _ITERATOR_DEBUG_LEVEL == 0 */
  5019. ; 610  :
  5020. ; 611  :        _Alty& _Getal()
  5021. ; 612  :                {       // get reference to allocator
  5022. ; 613  :                return (_Alval);
  5023. ; 614  :                }
  5024. ; 615  :
  5025. ; 616  :        const _Alty& _Getal() const
  5026. ; 617  :                {       // get reference to allocator
  5027. ; 618  :                return (_Alval);
  5028. ; 619  :                }
  5029. ; 620  :
  5030. ; 621  :        _Alty _Alval;   // allocator object for strings
  5031. ; 622  :        };
  5032. ; 623  :
  5033. ; 624  : template<class _Alloc_types>
  5034. ; 625  :        class _String_alloc<false, _Alloc_types>
  5035. ; 626  :                : public _String_val<typename _Alloc_types::_Val_types>
  5036. ; 627  :        {       // base class for basic_string to hold allocator with no storage
  5037. ; 628  : public:
  5038. ; 629  :        typedef _String_alloc<false, _Alloc_types> _Myt;
  5039. ; 630  :        typedef typename _Alloc_types::_Alloc _Alloc;
  5040. ; 631  :
  5041. ; 632  :        typedef typename _Alloc_types::_Alty _Alty;
  5042. ; 633  :
  5043. ; 634  :  #if _ITERATOR_DEBUG_LEVEL == 0
  5044. ; 635  :        _String_alloc(const _Alloc& = _Alloc())
  5045. ; 636  :                {       // construct allocator from _Al
  5046. ; 637  :                }
  5047. ; 638  :
  5048. ; 639  :        void _Change_alloc(const _Alty&)
  5049. ; 640  :                {       // replace old allocator
  5050. ; 641  :                }
  5051. ; 642  :
  5052. ; 643  :        void _Swap_alloc(_Myt&)
  5053. ; 644  :                {       // swap allocators
  5054. ; 645  :                }
  5055. ; 646  :
  5056. ; 647  :  #else /* _ITERATOR_DEBUG_LEVEL == 0 */
  5057. ; 648  :        _String_alloc(const _Alloc& = _Alloc())
  5058. ; 649  :                {       // construct allocator from _Al
  5059. ; 650  :                _Alloc_proxy();
  5060. ; 651  :                }
  5061. ; 652  :
  5062. ; 653  :        ~_String_alloc() _NOEXCEPT
  5063. ; 654  :                {       // destroy the object
  5064. ; 655  :                _Free_proxy();
  5065. ; 656  :                }
  5066. ; 657  :
  5067. ; 658  :        void _Change_alloc(const _Alty&)
  5068. ; 659  :                {       // replace old allocator
  5069. ; 660  :                }
  5070. ; 661  :
  5071. ; 662  :        void _Swap_alloc(_Myt& _Right)
  5072. ; 663  :                {       // swap allocators
  5073. ; 664  :                _Swap_adl(this->_Myproxy, _Right._Myproxy);
  5074. ; 665  :                }
  5075. ; 666  :
  5076. ; 667  :        void _Alloc_proxy()
  5077. ; 668  :                {       // construct proxy from _Alval
  5078. ; 669  :                typename _Alloc::template rebind<_Container_proxy>::other
  5079. ; 670  :                        _Alproxy;
  5080. ; 671  :                this->_Myproxy = _Alproxy.allocate(1);
  5081. ; 672  :                _Alproxy.construct(this->_Myproxy, _Container_proxy());
  5082. ; 673  :                this->_Myproxy->_Mycont = this;
  5083. ; 674  :                }
  5084. ; 675  :
  5085. ; 676  :        void _Free_proxy()
  5086. ; 677  :                {       // destroy proxy
  5087. ; 678  :                typename _Alloc::template rebind<_Container_proxy>::other
  5088. ; 679  :                        _Alproxy;
  5089. ; 680  :                this->_Orphan_all();
  5090. ; 681  :                _Alproxy.destroy(this->_Myproxy);
  5091. ; 682  :                _Alproxy.deallocate(this->_Myproxy, 1);
  5092. ; 683  :                this->_Myproxy = 0;
  5093. ; 684  :                }
  5094. ; 685  :  #endif /* _ITERATOR_DEBUG_LEVEL == 0 */
  5095. ; 686  :
  5096. ; 687  :        _Alty _Getal() const
  5097. ; 688  :                {       // get reference to allocator
  5098. ; 689  :                return (_Alty());
  5099. ; 690  :                }
  5100. ; 691  :        };
  5101. ; 692  :
  5102. ; 693  :                // TEMPLATE CLASS basic_string
  5103. ; 694  : template<class _Elem,
  5104. ; 695  :        class _Traits,
  5105. ; 696  :        class _Alloc>
  5106. ; 697  :        class basic_string
  5107. ; 698  :                : public _String_alloc<!is_empty<_Alloc>::value,
  5108. ; 699  :                        _String_base_types<_Elem, _Alloc> >
  5109. ; 700  :        {       // null-terminated transparent array of elements
  5110. ; 701  : public:
  5111. ; 702  :        typedef basic_string<_Elem, _Traits, _Alloc> _Myt;
  5112. ; 703  :        typedef _String_alloc<!is_empty<_Alloc>::value,
  5113. ; 704  :                _String_base_types<_Elem, _Alloc> > _Mybase;
  5114. ; 705  :        typedef _Traits traits_type;
  5115. ; 706  :        typedef _Alloc allocator_type;
  5116. ; 707  :
  5117. ; 708  :        typedef typename _Mybase::_Alty _Alty;
  5118. ; 709  :
  5119. ; 710  :        typedef typename _Mybase::value_type value_type;
  5120. ; 711  :        typedef typename _Mybase::size_type size_type;
  5121. ; 712  :        typedef typename _Mybase::difference_type difference_type;
  5122. ; 713  :        typedef typename _Mybase::pointer pointer;
  5123. ; 714  :        typedef typename _Mybase::const_pointer const_pointer;
  5124. ; 715  :        typedef typename _Mybase::reference reference;
  5125. ; 716  :        typedef typename _Mybase::const_reference const_reference;
  5126. ; 717  :
  5127. ; 718  :        typedef typename _Mybase::iterator iterator;
  5128. ; 719  :        typedef typename _Mybase::const_iterator const_iterator;
  5129. ; 720  :
  5130. ; 721  :        typedef _STD reverse_iterator<iterator> reverse_iterator;
  5131. ; 722  :        typedef _STD reverse_iterator<const_iterator> const_reverse_iterator;
  5132. ; 723  :
  5133. ; 724  :        basic_string(const _Myt& _Right)
  5134. ; 725  :
  5135. ; 726  :  #if _HAS_CPP0X
  5136. ; 727  :                : _Mybase(_Right._Getal().select_on_container_copy_construction())
  5137. ; 728  :
  5138. ; 729  :  #else /* _HAS_CPP0X */
  5139. ; 730  :                : _Mybase(_Right._Getal())
  5140. ; 731  :  #endif /* _HAS_CPP0X */
  5141. ; 732  :
  5142. ; 733  :                {       // construct by copying _Right
  5143. ; 734  :                _Tidy();
  5144. ; 735  :                assign(_Right, 0, npos);
  5145. ; 736  :                }
  5146. ; 737  :
  5147. ; 738  :  #if _HAS_CPP0X
  5148. ; 739  :        basic_string(const _Myt& _Right, const _Alloc& _Al)
  5149. ; 740  :                : _Mybase(_Al)
  5150. ; 741  :                {       // construct by copying with allocator
  5151. ; 742  :                _Tidy();
  5152. ; 743  :                assign(_Right, 0, npos);
  5153. ; 744  :                }
  5154. ; 745  :  #endif /* _HAS_CPP0X */
  5155. ; 746  :
  5156. ; 747  :        basic_string()
  5157. ; 748  :                : _Mybase()
  5158. ; 749  :                {       // construct empty string
  5159. ; 750  :                _Tidy();
  5160. ; 751  :                }
  5161. ; 752  :
  5162. ; 753  :        explicit basic_string(const _Alloc& _Al)
  5163. ; 754  :                : _Mybase(_Al)
  5164. ; 755  :                {       // construct empty string with allocator
  5165. ; 756  :                _Tidy();
  5166. ; 757  :                }
  5167. ; 758  :
  5168. ; 759  :        basic_string(const _Myt& _Right, size_type _Roff,
  5169. ; 760  :                size_type _Count = npos)
  5170. ; 761  :                : _Mybase(_Right._Getal())
  5171. ; 762  :                {       // construct from _Right [_Roff, _Roff + _Count)
  5172. ; 763  :                _Tidy();
  5173. ; 764  :                assign(_Right, _Roff, _Count);
  5174. ; 765  :                }
  5175. ; 766  :
  5176. ; 767  :        basic_string(const _Myt& _Right, size_type _Roff, size_type _Count,
  5177. ; 768  :                const _Alloc& _Al)
  5178. ; 769  :                : _Mybase(_Al)
  5179. ; 770  :                {       // construct from _Right [_Roff, _Roff + _Count) with allocator
  5180. ; 771  :                _Tidy();
  5181. ; 772  :                assign(_Right, _Roff, _Count);
  5182. ; 773  :                }
  5183. ; 774  :
  5184. ; 775  :        basic_string(const _Elem *_Ptr, size_type _Count)
  5185. ; 776  :                : _Mybase()
  5186. ; 777  :                {       // construct from [_Ptr, _Ptr + _Count)
  5187. ; 778  :                _Tidy();
  5188. ; 779  :                assign(_Ptr, _Count);
  5189. ; 780  :                }
  5190. ; 781  :
  5191. ; 782  :        basic_string(const _Elem *_Ptr, size_type _Count, const _Alloc& _Al)
  5192. ; 783  :                : _Mybase(_Al)
  5193. ; 784  :                {       // construct from [_Ptr, _Ptr + _Count) with allocator
  5194. ; 785  :                _Tidy();
  5195. ; 786  :                assign(_Ptr, _Count);
  5196. ; 787  :                }
  5197. ; 788  :
  5198. ; 789  :        basic_string(const _Elem *_Ptr)
  5199. ; 790  :                : _Mybase()
  5200. ; 791  :                {       // construct from [_Ptr, <null>)
  5201. ; 792  :                _Tidy();
  5202. ; 793  :                assign(_Ptr);
  5203. ; 794  :                }
  5204. ; 795  :
  5205. ; 796  :        basic_string(const _Elem *_Ptr, const _Alloc& _Al)
  5206. ; 797  :                : _Mybase(_Al)
  5207. ; 798  :                {       // construct from [_Ptr, <null>) with allocator
  5208. ; 799  :                _Tidy();
  5209. ; 800  :                assign(_Ptr);
  5210. ; 801  :                }
  5211. ; 802  :
  5212. ; 803  :        basic_string(size_type _Count, _Elem _Ch)
  5213. ; 804  :                : _Mybase()
  5214. ; 805  :                {       // construct from _Count * _Ch
  5215. ; 806  :                _Tidy();
  5216. ; 807  :                assign(_Count, _Ch);
  5217. ; 808  :                }
  5218. ; 809  :
  5219. ; 810  :        basic_string(size_type _Count, _Elem _Ch, const _Alloc& _Al)
  5220. ; 811  :                : _Mybase(_Al)
  5221. ; 812  :                {       // construct from _Count * _Ch with allocator
  5222. ; 813  :                _Tidy();
  5223. ; 814  :                assign(_Count, _Ch);
  5224. ; 815  :                }
  5225. ; 816  :
  5226. ; 817  :        template<class _Iter>
  5227. ; 818  :                basic_string(_Iter _First, _Iter _Last,
  5228. ; 819  :                        typename enable_if<_Is_iterator<_Iter>::value,
  5229. ; 820  :                                void>::type ** = 0)
  5230. ; 821  :                : _Mybase()
  5231. ; 822  :                {       // construct from [_First, _Last)
  5232. ; 823  :                _Tidy();
  5233. ; 824  :                _Construct(_First, _Last, _Iter_cat(_First));
  5234. ; 825  :                }
  5235. ; 826  :
  5236. ; 827  :        template<class _Iter>
  5237. ; 828  :                basic_string(_Iter _First, _Iter _Last, const _Alloc& _Al,
  5238. ; 829  :                        typename enable_if<_Is_iterator<_Iter>::value,
  5239. ; 830  :                                void>::type ** = 0)
  5240. ; 831  :                : _Mybase(_Al)
  5241. ; 832  :                {       // construct from [_First, _Last) with allocator
  5242. ; 833  :                _Tidy();
  5243. ; 834  :                _Construct(_First, _Last, _Iter_cat(_First));
  5244. ; 835  :                }
  5245. ; 836  :
  5246. ; 837  :        template<class _Iter>
  5247. ; 838  :                void _Construct(_Iter _First,
  5248. ; 839  :                        _Iter _Last, input_iterator_tag)
  5249. ; 840  :                {       // initialize from [_First, _Last), input iterators
  5250. ; 841  :                _TRY_BEGIN
  5251. ; 842  :                for (; _First != _Last; ++_First)
  5252. ; 843  :                        append((size_type)1, (_Elem)*_First);
  5253. ; 844  :                _CATCH_ALL
  5254. ; 845  :                _Tidy(true);
  5255. ; 846  :                _RERAISE;
  5256. ; 847  :                _CATCH_END
  5257. ; 848  :                }
  5258. ; 849  :
  5259. ; 850  :        template<class _Iter>
  5260. ; 851  :                void _Construct(_Iter _First,
  5261. ; 852  :                        _Iter _Last, forward_iterator_tag)
  5262. ; 853  :                {       // initialize from [_First, _Last), forward iterators
  5263. ; 854  :                _DEBUG_RANGE(_First, _Last);
  5264. ; 855  :                size_type _Count = 0;
  5265. ; 856  :                _Distance(_First, _Last, _Count);
  5266. ; 857  :                reserve(_Count);
  5267. ; 858  :
  5268. ; 859  :                _TRY_BEGIN
  5269. ; 860  :                for (; _First != _Last; ++_First)
  5270. ; 861  :                        append((size_type)1, (_Elem)*_First);
  5271. ; 862  :                _CATCH_ALL
  5272. ; 863  :                _Tidy(true);
  5273. ; 864  :                _RERAISE;
  5274. ; 865  :                _CATCH_END
  5275. ; 866  :                }
  5276. ; 867  :
  5277. ; 868  :        basic_string(const_pointer _First, const_pointer _Last)
  5278. ; 869  :                : _Mybase()
  5279. ; 870  :                {       // construct from [_First, _Last), const pointers
  5280. ; 871  :                _DEBUG_RANGE(_First, _Last);
  5281. ; 872  :                _Tidy();
  5282. ; 873  :                if (_First != _Last)
  5283. ; 874  :                        assign(&*_First, _Last - _First);
  5284. ; 875  :                }
  5285. ; 876  :
  5286. ; 877  :        basic_string(const_pointer _First, const_pointer _Last,
  5287. ; 878  :                const _Alloc& _Al)
  5288. ; 879  :                : _Mybase(_Al)
  5289. ; 880  :                {       // construct from [_First, _Last), const pointers
  5290. ; 881  :                _DEBUG_RANGE(_First, _Last);
  5291. ; 882  :                _Tidy();
  5292. ; 883  :                if (_First != _Last)
  5293. ; 884  :                        assign(&*_First, _Last - _First);
  5294. ; 885  :                }
  5295. ; 886  :
  5296. ; 887  :        basic_string(const_iterator _First, const_iterator _Last)
  5297. ; 888  :                : _Mybase()
  5298. ; 889  :                {       // construct from [_First, _Last), const_iterators
  5299. ; 890  :                _DEBUG_RANGE(_First, _Last);
  5300. ; 891  :                _Tidy();
  5301. ; 892  :                if (_First != _Last)
  5302. ; 893  :                        assign(&*_First, _Last - _First);
  5303. ; 894  :                }
  5304. ; 895  :
  5305. ; 896  :        basic_string(_Myt&& _Right) _NOEXCEPT
  5306. ; 897  :                : _Mybase(_Right._Getal())
  5307. ; 898  :                {       // construct by moving _Right
  5308. ; 899  :                _Tidy();
  5309. ; 900  :                _Assign_rv(_STD forward<_Myt>(_Right));
  5310. ; 901  :                }
  5311. ; 902  :
  5312. ; 903  :        basic_string(_Myt&& _Right, const _Alloc& _Al)
  5313. ; 904  :                : _Mybase(_Al)
  5314. ; 905  :                {       // construct by moving _Right, allocator
  5315. ; 906  :                if (this->_Getal() != _Right._Getal())
  5316. ; 907  :                        assign(_Right.begin(), _Right.end());
  5317. ; 908  :                else
  5318. ; 909  :                        _Assign_rv(_STD forward<_Myt>(_Right));
  5319. ; 910  :                }
  5320. ; 911  :
  5321. ; 912  :        _Myt& operator=(_Myt&& _Right) _NOEXCEPT
  5322. ; 913  :                {       // assign by moving _Right
  5323. ; 914  :                if (this != &_Right)
  5324. ; 915  :                        {       // different, assign it
  5325. ; 916  :                        _Tidy(true);
  5326. ; 917  :
  5327. ; 918  :  #if _HAS_CPP0X
  5328. ; 919  :                        if (this->_Getal() != _Right._Getal()
  5329. ; 920  :                                && _Alty::propagate_on_container_move_assignment::value)
  5330. ; 921  :                                this->_Change_alloc(_Right._Getal());
  5331. ; 922  :  #endif /* _HAS_CPP0X */
  5332. ; 923  :
  5333. ; 924  :                        if (this->_Getal() != _Right._Getal())
  5334. ; 925  :                                assign(_Right.begin(), _Right.end());
  5335. ; 926  :                        else
  5336. ; 927  :                                _Assign_rv(_STD forward<_Myt>(_Right));
  5337. ; 928  :                        }
  5338. ; 929  :                return (*this);
  5339. ; 930  :                }
  5340. ; 931  :
  5341. ; 932  :        _Myt& assign(_Myt&& _Right) _NOEXCEPT
  5342. ; 933  :                {       // assign by moving _Right
  5343. ; 934  :                if (this == &_Right)
  5344. ; 935  :                        ;
  5345. ; 936  :                else if (get_allocator() != _Right.get_allocator()
  5346. ; 937  :                        && this->_BUF_SIZE <= _Right._Myres)
  5347. ; 938  :                        *this = _Right;
  5348. ; 939  :                else
  5349. ; 940  :                        {       // not same, clear this and steal from _Right
  5350. ; 941  :                        _Tidy(true);
  5351. ; 942  :                        _Assign_rv(_STD forward<_Myt>(_Right));
  5352. ; 943  :                        }
  5353. ; 944  :                return (*this);
  5354. ; 945  :                }
  5355. ; 946  :
  5356. ; 947  :        void _Assign_rv(_Myt&& _Right)
  5357. ; 948  :                {       // assign by moving _Right
  5358. ; 949  :                if (_Right._Myres < this->_BUF_SIZE)
  5359. ; 950  :                        _Traits::move(this->_Bx._Buf, _Right._Bx._Buf,
  5360. ; 951  :                                _Right._Mysize + 1);
  5361. ; 952  :                else
  5362. ; 953  :                        {       // copy pointer
  5363. ; 954  :                        this->_Getal().construct(&this->_Bx._Ptr, _Right._Bx._Ptr);
  5364. ; 955  :                        _Right._Bx._Ptr = pointer();
  5365. ; 956  :                        }
  5366. ; 957  :                this->_Mysize = _Right._Mysize;
  5367. ; 958  :                this->_Myres = _Right._Myres;
  5368. ; 959  :                _Right._Tidy();
  5369. ; 960  :                }
  5370. ; 961  :
  5371. ; 962  :        ~basic_string() _NOEXCEPT
  5372. ; 963  :                {       // destroy the string
  5373. ; 964  :                _Tidy(true);
  5374. ; 965  :                }
  5375. ; 966  :
  5376. ; 967  :        _PGLOBAL static const size_type npos;   // bad/missing length/position
  5377. ; 968  :
  5378. ; 969  :        _Myt& operator=(const _Myt& _Right)
  5379. ; 970  :                {       // assign _Right
  5380. ; 971  :                if (this != &_Right)
  5381. ; 972  :                        {       // different, assign it
  5382. ; 973  :  #if _HAS_CPP0X
  5383. ; 974  :                        if (this->_Getal() != _Right._Getal()
  5384. ; 975  :                                && _Alty::propagate_on_container_copy_assignment::value)
  5385. ; 976  :                                {       // change allocator before copying
  5386. ; 977  :                                _Tidy(true);
  5387. ; 978  :                                this->_Change_alloc(_Right._Getal());
  5388. ; 979  :                                }
  5389. ; 980  :  #endif /* _HAS_CPP0X */
  5390. ; 981  :
  5391. ; 982  :                        assign(_Right);
  5392. ; 983  :                        }
  5393. ; 984  :                return (*this);
  5394. ; 985  :                }
  5395. ; 986  :
  5396. ; 987  :        _Myt& operator=(const _Elem *_Ptr)
  5397. ; 988  :                {       // assign [_Ptr, <null>)
  5398. ; 989  :                return (assign(_Ptr));
  5399. ; 990  :                }
  5400. ; 991  :
  5401. ; 992  :        _Myt& operator=(_Elem _Ch)
  5402. ; 993  :                {       // assign 1 * _Ch
  5403. ; 994  :                return (assign(1, _Ch));
  5404. ; 995  :                }
  5405. ; 996  :
  5406. ; 997  :        _Myt& operator+=(const _Myt& _Right)
  5407. ; 998  :                {       // append _Right
  5408. ; 999  :                return (append(_Right));
  5409. ; 1000 :                }
  5410. ; 1001 :
  5411. ; 1002 :        _Myt& operator+=(const _Elem *_Ptr)
  5412. ; 1003 :                {       // append [_Ptr, <null>)
  5413. ; 1004 :                return (append(_Ptr));
  5414. ; 1005 :                }
  5415. ; 1006 :
  5416. ; 1007 :        _Myt& operator+=(_Elem _Ch)
  5417. ; 1008 :                {       // append 1 * _Ch
  5418. ; 1009 :                return (append((size_type)1, _Ch));
  5419. ; 1010 :                }
  5420. ; 1011 :
  5421. ; 1012 :        _Myt& append(const _Myt& _Right)
  5422. ; 1013 :                {       // append _Right
  5423. ; 1014 :                return (append(_Right, 0, npos));
  5424. ; 1015 :                }
  5425. ; 1016 :
  5426. ; 1017 :        _Myt& append(const _Myt& _Right,
  5427. ; 1018 :                size_type _Roff, size_type _Count)
  5428. ; 1019 :                {       // append _Right [_Roff, _Roff + _Count)
  5429. ; 1020 :                if (_Right.size() < _Roff)
  5430. ; 1021 :                        _Xran();        // _Roff off end
  5431. ; 1022 :                size_type _Num = _Right.size() - _Roff;
  5432. ; 1023 :                if (_Num < _Count)
  5433. ; 1024 :                        _Count = _Num;  // trim _Count to size
  5434. ; 1025 :                if (npos - this->_Mysize <= _Count)
  5435. ; 1026 :                        _Xlen();        // result too long
  5436. ; 1027 :
  5437. ; 1028 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  5438. ; 1029 :                        {       // make room and append new stuff
  5439. ; 1030 :                        _Traits::copy(this->_Myptr() + this->_Mysize,
  5440. ; 1031 :                                _Right._Myptr() + _Roff, _Count);
  5441. ; 1032 :                        _Eos(_Num);
  5442. ; 1033 :                        }
  5443. ; 1034 :                return (*this);
  5444. ; 1035 :                }
  5445. ; 1036 :
  5446. ; 1037 :        _Myt& append(const _Elem *_Ptr, size_type _Count)
  5447. ; 1038 :                {       // append [_Ptr, _Ptr + _Count)
  5448. ; 1039 :  #if _ITERATOR_DEBUG_LEVEL == 2
  5449. ; 1040 :                if (_Count != 0)
  5450. ; 1041 :                        _DEBUG_POINTER(_Ptr);
  5451. ; 1042 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  5452. ; 1043 :
  5453. ; 1044 :                if (_Inside(_Ptr))
  5454. ; 1045 :                        return (append(*this,
  5455. ; 1046 :                                _Ptr - this->_Myptr(), _Count));        // substring
  5456. ; 1047 :                if (npos - this->_Mysize <= _Count)
  5457. ; 1048 :                        _Xlen();        // result too long
  5458. ; 1049 :
  5459. ; 1050 :                size_type _Num;
  5460. ; 1051 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  5461. ; 1052 :                        {       // make room and append new stuff
  5462. ; 1053 :                        _Traits::copy(this->_Myptr() + this->_Mysize, _Ptr, _Count);
  5463. ; 1054 :                        _Eos(_Num);
  5464. ; 1055 :                        }
  5465. ; 1056 :                return (*this);
  5466. ; 1057 :                }
  5467. ; 1058 :
  5468. ; 1059 :        _Myt& append(const _Elem *_Ptr)
  5469. ; 1060 :                {       // append [_Ptr, <null>)
  5470. ; 1061 :                _DEBUG_POINTER(_Ptr);
  5471. ; 1062 :                return (append(_Ptr, _Traits::length(_Ptr)));
  5472. ; 1063 :                }
  5473. ; 1064 :
  5474. ; 1065 :        _Myt& append(size_type _Count, _Elem _Ch)
  5475. ; 1066 :                {       // append _Count * _Ch
  5476. ; 1067 :                if (npos - this->_Mysize <= _Count)
  5477. ; 1068 :                        _Xlen();        // result too long
  5478. ; 1069 :
  5479. ; 1070 :                size_type _Num;
  5480. ; 1071 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  5481. ; 1072 :                        {       // make room and append new stuff using assign
  5482. ; 1073 :                        _Chassign(this->_Mysize, _Count, _Ch);
  5483. ; 1074 :                        _Eos(_Num);
  5484. ; 1075 :                        }
  5485. ; 1076 :                return (*this);
  5486. ; 1077 :                }
  5487. ; 1078 :
  5488. ; 1079 :        template<class _Iter>
  5489. ; 1080 :                typename enable_if<_Is_iterator<_Iter>::value,
  5490. ; 1081 :                        _Myt&>::type
  5491. ; 1082 :                append(_Iter _First, _Iter _Last)
  5492. ; 1083 :                {       // append [_First, _Last), input iterators
  5493. ; 1084 :                return (replace(end(), end(), _First, _Last));
  5494. ; 1085 :                }
  5495. ; 1086 :
  5496. ; 1087 :        _Myt& append(const_pointer _First, const_pointer _Last)
  5497. ; 1088 :                {       // append [_First, _Last), const pointers
  5498. ; 1089 :                return (replace(end(), end(), _First, _Last));
  5499. ; 1090 :                }
  5500. ; 1091 :
  5501. ; 1092 :        _Myt& append(const_iterator _First, const_iterator _Last)
  5502. ; 1093 :                {       // append [_First, _Last), const_iterators
  5503. ; 1094 :                return (replace(end(), end(), _First, _Last));
  5504. ; 1095 :                }
  5505. ; 1096 :
  5506. ; 1097 :        _Myt& assign(const _Myt& _Right)
  5507. ; 1098 :                {       // assign _Right
  5508. ; 1099 :                return (assign(_Right, 0, npos));
  5509. ; 1100 :                }
  5510. ; 1101 :
  5511. ; 1102 :        _Myt& assign(const _Myt& _Right,
  5512. ; 1103 :                size_type _Roff, size_type _Count)
  5513. ; 1104 :                {       // assign _Right [_Roff, _Roff + _Count)
  5514. ; 1105 :                if (_Right.size() < _Roff)
  5515. ; 1106 :                        _Xran();        // _Roff off end
  5516. ; 1107 :                size_type _Num = _Right.size() - _Roff;
  5517. ; 1108 :                if (_Count < _Num)
  5518. ; 1109 :                        _Num = _Count;  // trim _Num to size
  5519. ; 1110 :
  5520. ; 1111 :                if (this == &_Right)
  5521. ; 1112 :                        erase((size_type)(_Roff + _Num)), erase(0, _Roff);      // substring
  5522. ; 1113 :                else if (_Grow(_Num))
  5523. ; 1114 :                        {       // make room and assign new stuff
  5524. ; 1115 :                        _Traits::copy(this->_Myptr(),
  5525. ; 1116 :                                _Right._Myptr() + _Roff, _Num);
  5526. ; 1117 :                        _Eos(_Num);
  5527. ; 1118 :                        }
  5528. ; 1119 :                return (*this);
  5529. ; 1120 :                }
  5530. ; 1121 :
  5531. ; 1122 :        _Myt& assign(const _Elem *_Ptr, size_type _Count)
  5532. ; 1123 :                {       // assign [_Ptr, _Ptr + _Count)
  5533. ; 1124 :  #if _ITERATOR_DEBUG_LEVEL == 2
  5534. ; 1125 :                if (_Count != 0)
  5535. ; 1126 :                        _DEBUG_POINTER(_Ptr);
  5536. ; 1127 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  5537. ; 1128 :
  5538. ; 1129 :                if (_Inside(_Ptr))
  5539. ; 1130 :                        return (assign(*this,
  5540. ; 1131 :                                _Ptr - this->_Myptr(), _Count));        // substring
  5541. ; 1132 :
  5542. ; 1133 :                if (_Grow(_Count))
  5543. ; 1134 :                        {       // make room and assign new stuff
  5544. ; 1135 :                        _Traits::copy(this->_Myptr(), _Ptr, _Count);
  5545. ; 1136 :                        _Eos(_Count);
  5546. ; 1137 :                        }
  5547. ; 1138 :                return (*this);
  5548. ; 1139 :                }
  5549. ; 1140 :
  5550. ; 1141 :        _Myt& assign(const _Elem *_Ptr)
  5551. ; 1142 :                {       // assign [_Ptr, <null>)
  5552. ; 1143 :                _DEBUG_POINTER(_Ptr);
  5553. ; 1144 :                return (assign(_Ptr, _Traits::length(_Ptr)));
  5554. ; 1145 :                }
  5555. ; 1146 :
  5556. ; 1147 :        _Myt& assign(size_type _Count, _Elem _Ch)
  5557. ; 1148 :                {       // assign _Count * _Ch
  5558. ; 1149 :                if (_Count == npos)
  5559. ; 1150 :                        _Xlen();        // result too long
  5560. ; 1151 :
  5561. ; 1152 :                if (_Grow(_Count))
  5562. ; 1153 :                        {       // make room and assign new stuff
  5563. ; 1154 :                        _Chassign(0, _Count, _Ch);
  5564. ; 1155 :                        _Eos(_Count);
  5565. ; 1156 :                        }
  5566. ; 1157 :                return (*this);
  5567. ; 1158 :                }
  5568. ; 1159 :
  5569. ; 1160 :        template<class _Iter>
  5570. ; 1161 :                typename enable_if<_Is_iterator<_Iter>::value,
  5571. ; 1162 :                        _Myt&>::type
  5572. ; 1163 :                assign(_Iter _First, _Iter _Last)
  5573. ; 1164 :                {       // assign [First, _Last), input iterators
  5574. ; 1165 :                return (replace(begin(), end(), _First, _Last));
  5575. ; 1166 :                }
  5576. ; 1167 :
  5577. ; 1168 :        _Myt& assign(const_pointer _First, const_pointer _Last)
  5578. ; 1169 :                {       // assign [First, _Last), const pointers
  5579. ; 1170 :                return (replace(begin(), end(), _First, _Last));
  5580. ; 1171 :                }
  5581. ; 1172 :
  5582. ; 1173 :        _Myt& assign(const_iterator _First, const_iterator _Last)
  5583. ; 1174 :                {       // assign [First, _Last), const_iterators
  5584. ; 1175 :                return (replace(begin(), end(), _First, _Last));
  5585. ; 1176 :                }
  5586. ; 1177 :
  5587. ; 1178 :        _Myt& insert(size_type _Off, const _Myt& _Right)
  5588. ; 1179 :                {       // insert _Right at _Off
  5589. ; 1180 :                return (insert(_Off, _Right, 0, npos));
  5590. ; 1181 :                }
  5591. ; 1182 :
  5592. ; 1183 :        _Myt& insert(size_type _Off,
  5593. ; 1184 :                const _Myt& _Right, size_type _Roff, size_type _Count)
  5594. ; 1185 :                {       // insert _Right [_Roff, _Roff + _Count) at _Off
  5595. ; 1186 :                if (this->_Mysize < _Off || _Right.size() < _Roff)
  5596. ; 1187 :                        _Xran();        // _Off or _Roff off end
  5597. ; 1188 :                size_type _Num = _Right.size() - _Roff;
  5598. ; 1189 :                if (_Num < _Count)
  5599. ; 1190 :                        _Count = _Num;  // trim _Count to size
  5600. ; 1191 :                if (npos - this->_Mysize <= _Count)
  5601. ; 1192 :                        _Xlen();        // result too long
  5602. ; 1193 :
  5603. ; 1194 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  5604. ; 1195 :                        {       // make room and insert new stuff
  5605. ; 1196 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5606. ; 1197 :                                this->_Myptr() + _Off,
  5607. ; 1198 :                                this->_Mysize - _Off);  // empty out hole
  5608. ; 1199 :                        if (this == &_Right)
  5609. ; 1200 :                                _Traits::move(this->_Myptr() + _Off,
  5610. ; 1201 :                                        this->_Myptr() + (_Off < _Roff ? _Roff + _Count : _Roff),
  5611. ; 1202 :                                                _Count);        // substring
  5612. ; 1203 :                        else
  5613. ; 1204 :                                _Traits::copy(this->_Myptr() + _Off,
  5614. ; 1205 :                                        _Right._Myptr() + _Roff, _Count);       // fill hole
  5615. ; 1206 :                        _Eos(_Num);
  5616. ; 1207 :                        }
  5617. ; 1208 :                return (*this);
  5618. ; 1209 :                }
  5619. ; 1210 :
  5620. ; 1211 :        _Myt& insert(size_type _Off,
  5621. ; 1212 :                const _Elem *_Ptr, size_type _Count)
  5622. ; 1213 :                {       // insert [_Ptr, _Ptr + _Count) at _Off
  5623. ; 1214 :  #if _ITERATOR_DEBUG_LEVEL == 2
  5624. ; 1215 :                if (_Count != 0)
  5625. ; 1216 :                        _DEBUG_POINTER(_Ptr);
  5626. ; 1217 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  5627. ; 1218 :
  5628. ; 1219 :                if (_Inside(_Ptr))
  5629. ; 1220 :                        return (insert(_Off, *this,
  5630. ; 1221 :                                _Ptr - this->_Myptr(), _Count));        // substring
  5631. ; 1222 :                if (this->_Mysize < _Off)
  5632. ; 1223 :                        _Xran();        // _Off off end
  5633. ; 1224 :                if (npos - this->_Mysize <= _Count)
  5634. ; 1225 :                        _Xlen();        // result too long
  5635. ; 1226 :                size_type _Num;
  5636. ; 1227 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  5637. ; 1228 :                        {       // make room and insert new stuff
  5638. ; 1229 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5639. ; 1230 :                                this->_Myptr() + _Off,
  5640. ; 1231 :                                this->_Mysize - _Off);  // empty out hole
  5641. ; 1232 :                        _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count);     // fill hole
  5642. ; 1233 :                        _Eos(_Num);
  5643. ; 1234 :                        }
  5644. ; 1235 :                return (*this);
  5645. ; 1236 :                }
  5646. ; 1237 :
  5647. ; 1238 :        _Myt& insert(size_type _Off, const _Elem *_Ptr)
  5648. ; 1239 :                {       // insert [_Ptr, <null>) at _Off
  5649. ; 1240 :                _DEBUG_POINTER(_Ptr);
  5650. ; 1241 :                return (insert(_Off, _Ptr, _Traits::length(_Ptr)));
  5651. ; 1242 :                }
  5652. ; 1243 :
  5653. ; 1244 :        _Myt& insert(size_type _Off,
  5654. ; 1245 :                size_type _Count, _Elem _Ch)
  5655. ; 1246 :                {       // insert _Count * _Ch at _Off
  5656. ; 1247 :                if (this->_Mysize < _Off)
  5657. ; 1248 :                        _Xran();        // _Off off end
  5658. ; 1249 :                if (npos - this->_Mysize <= _Count)
  5659. ; 1250 :                        _Xlen();        // result too long
  5660. ; 1251 :                size_type _Num;
  5661. ; 1252 :                if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
  5662. ; 1253 :                        {       // make room and insert new stuff
  5663. ; 1254 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5664. ; 1255 :                                this->_Myptr() + _Off,
  5665. ; 1256 :                                this->_Mysize - _Off);  // empty out hole
  5666. ; 1257 :                        _Chassign(_Off, _Count, _Ch);   // fill hole
  5667. ; 1258 :                        _Eos(_Num);
  5668. ; 1259 :                        }
  5669. ; 1260 :                return (*this);
  5670. ; 1261 :                }
  5671. ; 1262 :
  5672. ; 1263 :        iterator insert(const_iterator _Where)
  5673. ; 1264 :                {       // insert <null> at _Where
  5674. ; 1265 :                return (insert(_Where, _Elem()));
  5675. ; 1266 :                }
  5676. ; 1267 :
  5677. ; 1268 :        iterator insert(const_iterator _Where, _Elem _Ch)
  5678. ; 1269 :                {       // insert _Ch at _Where
  5679. ; 1270 :                size_type _Off = _Pdif(_Where, begin());
  5680. ; 1271 :                insert(_Off, 1, _Ch);
  5681. ; 1272 :                return (begin() + _Off);
  5682. ; 1273 :                }
  5683. ; 1274 :
  5684. ; 1275 :        iterator insert(const_iterator _Where, size_type _Count, _Elem _Ch)
  5685. ; 1276 :                {       // insert _Count * _Elem at _Where
  5686. ; 1277 :                size_type _Off = _Pdif(_Where, begin());
  5687. ; 1278 :                insert(_Off, _Count, _Ch);
  5688. ; 1279 :                return (begin() + _Off);
  5689. ; 1280 :                }
  5690. ; 1281 :
  5691. ; 1282 :        template<class _Iter>
  5692. ; 1283 :                typename enable_if<_Is_iterator<_Iter>::value,
  5693. ; 1284 :                        iterator>::type
  5694. ; 1285 :                insert(const_iterator _Where, _Iter _First, _Iter _Last)
  5695. ; 1286 :                {       // insert [_First, _Last) at _Where, input iterators
  5696. ; 1287 :                size_type _Off = _Pdif(_Where, begin());
  5697. ; 1288 :                replace(_Where, _Where, _First, _Last);
  5698. ; 1289 :                return (begin() + _Off);
  5699. ; 1290 :                }
  5700. ; 1291 :
  5701. ; 1292 :        iterator insert(const_iterator _Where,
  5702. ; 1293 :                const_pointer _First, const_pointer _Last)
  5703. ; 1294 :                {       // insert [_First, _Last) at _Where, const pointers
  5704. ; 1295 :                size_type _Off = _Pdif(_Where, begin());
  5705. ; 1296 :                replace(_Where, _Where, _First, _Last);
  5706. ; 1297 :                return (begin() + _Off);
  5707. ; 1298 :                }
  5708. ; 1299 :
  5709. ; 1300 :        iterator insert(const_iterator _Where,
  5710. ; 1301 :                const_iterator _First, const_iterator _Last)
  5711. ; 1302 :                {       // insert [_First, _Last) at _Where, const_iterators
  5712. ; 1303 :                size_type _Off = _Pdif(_Where, begin());
  5713. ; 1304 :                replace(_Where, _Where, _First, _Last);
  5714. ; 1305 :                return (begin() + _Off);
  5715. ; 1306 :                }
  5716. ; 1307 :
  5717. ; 1308 :        _Myt& erase(size_type _Off = 0)
  5718. ; 1309 :                {       // erase elements [_Off, ...)
  5719. ; 1310 :                if (this->_Mysize < _Off)
  5720. ; 1311 :                        _Xran();        // _Off off end
  5721. ; 1312 :                _Eos(_Off);
  5722. ; 1313 :                return (*this);
  5723. ; 1314 :                }
  5724. ; 1315 :
  5725. ; 1316 :        _Myt& erase(size_type _Off, size_type _Count)
  5726. ; 1317 :                {       // erase elements [_Off, _Off + _Count)
  5727. ; 1318 :                if (this->_Mysize < _Off)
  5728. ; 1319 :                        _Xran();        // _Off off end
  5729. ; 1320 :                if (this->_Mysize - _Off <= _Count)
  5730. ; 1321 :                        _Eos(_Off);     // erase elements [_Off, ...)
  5731. ; 1322 :                else if (0 < _Count)
  5732. ; 1323 :                        {       // move elements down
  5733. ; 1324 :                        value_type *_Ptr = this->_Myptr() + _Off;
  5734. ; 1325 :                        size_type _Newsize = this->_Mysize - _Count;
  5735. ; 1326 :                        _Traits::move(_Ptr, _Ptr + _Count, _Newsize - _Off);
  5736. ; 1327 :                        _Eos(_Newsize);
  5737. ; 1328 :                        }
  5738. ; 1329 :                return (*this);
  5739. ; 1330 :                }
  5740. ; 1331 :
  5741. ; 1332 :        iterator erase(const_iterator _Where)
  5742. ; 1333 :                {       // erase element at _Where
  5743. ; 1334 :                size_type _Count = _Pdif(_Where, begin());
  5744. ; 1335 :                erase(_Count, 1);
  5745. ; 1336 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  5746. ; 1337 :                }
  5747. ; 1338 :
  5748. ; 1339 :        iterator erase(const_iterator _First, const_iterator _Last)
  5749. ; 1340 :                {       // erase substring [_First, _Last)
  5750. ; 1341 :                _DEBUG_RANGE(_First, _Last);
  5751. ; 1342 :                size_type _Count = _Pdif(_First, begin());
  5752. ; 1343 :                erase(_Count, _Pdif(_Last, _First));
  5753. ; 1344 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  5754. ; 1345 :                }
  5755. ; 1346 :
  5756. ; 1347 :        void clear() _NOEXCEPT
  5757. ; 1348 :                {       // erase all
  5758. ; 1349 :                _Eos(0);
  5759. ; 1350 :                }
  5760. ; 1351 :
  5761. ; 1352 :        _Myt& replace(size_type _Off, size_type _N0, const _Myt& _Right)
  5762. ; 1353 :                {       // replace [_Off, _Off + _N0) with _Right
  5763. ; 1354 :                return (replace(_Off, _N0, _Right, 0, npos));
  5764. ; 1355 :                }
  5765. ; 1356 :
  5766. ; 1357 :        _Myt& replace(size_type _Off,
  5767. ; 1358 :                size_type _N0, const _Myt& _Right, size_type _Roff, size_type _Count)
  5768. ; 1359 :                {       // replace [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
  5769. ; 1360 :                if (this->_Mysize < _Off || _Right.size() < _Roff)
  5770. ; 1361 :                        _Xran();        // _Off or _Roff off end
  5771. ; 1362 :                if (this->_Mysize - _Off < _N0)
  5772. ; 1363 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  5773. ; 1364 :                size_type _Num = _Right.size() - _Roff;
  5774. ; 1365 :                if (_Num < _Count)
  5775. ; 1366 :                        _Count = _Num;  // trim _Count to size
  5776. ; 1367 :                if (npos - _Count <= this->_Mysize - _N0)
  5777. ; 1368 :                        _Xlen();        // result too long
  5778. ; 1369 :
  5779. ; 1370 :                size_type _Nm = this->_Mysize - _N0 - _Off;     // length of kept tail
  5780. ; 1371 :                size_type _Newsize = this->_Mysize + _Count - _N0;
  5781. ; 1372 :                if (this->_Mysize < _Newsize)
  5782. ; 1373 :                        _Grow(_Newsize);
  5783. ; 1374 :
  5784. ; 1375 :                if (this != &_Right)
  5785. ; 1376 :                        {       // no overlap, just move down and copy in new stuff
  5786. ; 1377 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5787. ; 1378 :                                this->_Myptr() + _Off + _N0, _Nm);      // empty hole
  5788. ; 1379 :                        _Traits::copy(this->_Myptr() + _Off,
  5789. ; 1380 :                                _Right._Myptr() + _Roff, _Count);       // fill hole
  5790. ; 1381 :                        }
  5791. ; 1382 :                else if (_Count <= _N0)
  5792. ; 1383 :                        {       // hole doesn't get larger, just copy in substring
  5793. ; 1384 :                        _Traits::move(this->_Myptr() + _Off,
  5794. ; 1385 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  5795. ; 1386 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5796. ; 1387 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  5797. ; 1388 :                        }
  5798. ; 1389 :                else if (_Roff <= _Off)
  5799. ; 1390 :                        {       // hole gets larger, substring begins before hole
  5800. ; 1391 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5801. ; 1392 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  5802. ; 1393 :                        _Traits::move(this->_Myptr() + _Off,
  5803. ; 1394 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  5804. ; 1395 :                        }
  5805. ; 1396 :                else if (_Off + _N0 <= _Roff)
  5806. ; 1397 :                        {       // hole gets larger, substring begins after hole
  5807. ; 1398 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5808. ; 1399 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  5809. ; 1400 :                        _Traits::move(this->_Myptr() + _Off,
  5810. ; 1401 :                                this->_Myptr() + (_Roff + _Count - _N0),
  5811. ; 1402 :                                _Count);        // fill hole
  5812. ; 1403 :                        }
  5813. ; 1404 :                else
  5814. ; 1405 :                        {       // hole gets larger, substring begins in hole
  5815. ; 1406 :                        _Traits::move(this->_Myptr() + _Off,
  5816. ; 1407 :                                this->_Myptr() + _Roff, _N0);   // fill old hole
  5817. ; 1408 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5818. ; 1409 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  5819. ; 1410 :                        _Traits::move(this->_Myptr() + _Off + _N0,
  5820. ; 1411 :                                this->_Myptr() + _Roff + _Count,
  5821. ; 1412 :                                _Count - _N0);  // fill rest of new hole
  5822. ; 1413 :                        }
  5823. ; 1414 :
  5824. ; 1415 :                _Eos(_Newsize);
  5825. ; 1416 :                return (*this);
  5826. ; 1417 :                }
  5827. ; 1418 :
  5828. ; 1419 :        _Myt& replace(size_type _Off,
  5829. ; 1420 :                size_type _N0, const _Elem *_Ptr, size_type _Count)
  5830. ; 1421 :                {       // replace [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
  5831. ; 1422 :  #if _ITERATOR_DEBUG_LEVEL == 2
  5832. ; 1423 :                if (_Count != 0)
  5833. ; 1424 :                        _DEBUG_POINTER(_Ptr);
  5834. ; 1425 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  5835. ; 1426 :
  5836. ; 1427 :                if (_Inside(_Ptr))
  5837. ; 1428 :                        return (replace(_Off, _N0, *this,
  5838. ; 1429 :                                _Ptr - this->_Myptr(),
  5839. ; 1430 :                                _Count));       // substring, replace carefully
  5840. ; 1431 :                if (this->_Mysize < _Off)
  5841. ; 1432 :                        _Xran();        // _Off off end
  5842. ; 1433 :                if (this->_Mysize - _Off < _N0)
  5843. ; 1434 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  5844. ; 1435 :                if (npos - _Count <= this->_Mysize - _N0)
  5845. ; 1436 :                        _Xlen();        // result too long
  5846. ; 1437 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  5847. ; 1438 :
  5848. ; 1439 :                if (_Count < _N0)
  5849. ; 1440 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5850. ; 1441 :                                this->_Myptr() + _Off + _N0,
  5851. ; 1442 :                                _Nm);   // smaller hole, move tail up
  5852. ; 1443 :                size_type _Num;
  5853. ; 1444 :                if ((0 < _Count || 0 < _N0)
  5854. ; 1445 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  5855. ; 1446 :                        {       // make room and rearrange
  5856. ; 1447 :                        if (_N0 < _Count)
  5857. ; 1448 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  5858. ; 1449 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  5859. ; 1450 :                        _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count);     // fill hole
  5860. ; 1451 :                        _Eos(_Num);
  5861. ; 1452 :                        }
  5862. ; 1453 :                return (*this);
  5863. ; 1454 :                }
  5864. ; 1455 :
  5865. ; 1456 :        _Myt& replace(size_type _Off, size_type _N0, const _Elem *_Ptr)
  5866. ; 1457 :                {       // replace [_Off, _Off + _N0) with [_Ptr, <null>)
  5867. ; 1458 :                _DEBUG_POINTER(_Ptr);
  5868. ; 1459 :                return (replace(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
  5869. ; 1460 :                }
  5870. ; 1461 :
  5871. ; 1462 :        _Myt& replace(size_type _Off,
  5872. ; 1463 :                size_type _N0, size_type _Count, _Elem _Ch)
  5873. ; 1464 :                {       // replace [_Off, _Off + _N0) with _Count * _Ch
  5874. ; 1465 :                if (this->_Mysize < _Off)
  5875. ; 1466 :                        _Xran();        // _Off off end
  5876. ; 1467 :                if (this->_Mysize - _Off < _N0)
  5877. ; 1468 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  5878. ; 1469 :                if (npos - _Count <= this->_Mysize - _N0)
  5879. ; 1470 :                        _Xlen();        // result too long
  5880. ; 1471 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  5881. ; 1472 :
  5882. ; 1473 :                if (_Count < _N0)
  5883. ; 1474 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  5884. ; 1475 :                                this->_Myptr() + _Off + _N0,
  5885. ; 1476 :                                _Nm);   // smaller hole, move tail up
  5886. ; 1477 :                size_type _Num;
  5887. ; 1478 :                if ((0 < _Count || 0 < _N0)
  5888. ; 1479 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  5889. ; 1480 :                        {       // make room and rearrange
  5890. ; 1481 :                        if (_N0 < _Count)
  5891. ; 1482 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  5892. ; 1483 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  5893. ; 1484 :                        _Chassign(_Off, _Count, _Ch);   // fill hole
  5894. ; 1485 :                        _Eos(_Num);
  5895. ; 1486 :                        }
  5896. ; 1487 :                return (*this);
  5897. ; 1488 :                }
  5898. ; 1489 :
  5899. ; 1490 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5900. ; 1491 :                const _Myt& _Right)
  5901. ; 1492 :                {       // replace [_First, _Last) with _Right
  5902. ; 1493 :                return (replace(
  5903. ; 1494 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Right));
  5904. ; 1495 :                }
  5905. ; 1496 :
  5906. ; 1497 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5907. ; 1498 :                const _Elem *_Ptr, size_type _Count)
  5908. ; 1499 :                {       // replace [_First, _Last) with [_Ptr, _Ptr + _Count)
  5909. ; 1500 :                return (replace(
  5910. ; 1501 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr, _Count));
  5911. ; 1502 :                }
  5912. ; 1503 :
  5913. ; 1504 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5914. ; 1505 :                const _Elem *_Ptr)
  5915. ; 1506 :                {       // replace [_First, _Last) with [_Ptr, <null>)
  5916. ; 1507 :                return (replace(
  5917. ; 1508 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr));
  5918. ; 1509 :                }
  5919. ; 1510 :
  5920. ; 1511 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5921. ; 1512 :                size_type _Count, _Elem _Ch)
  5922. ; 1513 :                {       // replace [_First, _Last) with _Count * _Ch
  5923. ; 1514 :                return (replace(
  5924. ; 1515 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Count, _Ch));
  5925. ; 1516 :                }
  5926. ; 1517 :
  5927. ; 1518 :        template<class _Iter>
  5928. ; 1519 :                typename enable_if<_Is_iterator<_Iter>::value,
  5929. ; 1520 :                        _Myt&>::type
  5930. ; 1521 :                replace(const_iterator _First, const_iterator _Last,
  5931. ; 1522 :                        _Iter _First2, _Iter _Last2)
  5932. ; 1523 :                {       // replace [_First, _Last) with [_First2, _Last2), input iterators
  5933. ; 1524 :                _Myt _Right(_First2, _Last2);
  5934. ; 1525 :                replace(_First, _Last, _Right);
  5935. ; 1526 :                return (*this);
  5936. ; 1527 :                }
  5937. ; 1528 :
  5938. ; 1529 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5939. ; 1530 :                const_pointer _First2, const_pointer _Last2)
  5940. ; 1531 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  5941. ; 1532 :                if (_First2 == _Last2)
  5942. ; 1533 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  5943. ; 1534 :                else
  5944. ; 1535 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  5945. ; 1536 :                                &*_First2, _Last2 - _First2);
  5946. ; 1537 :                return (*this);
  5947. ; 1538 :                }
  5948. ; 1539 :
  5949. ; 1540 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5950. ; 1541 :                pointer _First2, pointer _Last2)
  5951. ; 1542 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  5952. ; 1543 :                if (_First2 == _Last2)
  5953. ; 1544 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  5954. ; 1545 :                else
  5955. ; 1546 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  5956. ; 1547 :                                &*_First2, _Last2 - _First2);
  5957. ; 1548 :                return (*this);
  5958. ; 1549 :                }
  5959. ; 1550 :
  5960. ; 1551 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5961. ; 1552 :                const_iterator _First2, const_iterator _Last2)
  5962. ; 1553 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  5963. ; 1554 :                if (_First2 == _Last2)
  5964. ; 1555 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  5965. ; 1556 :                else
  5966. ; 1557 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  5967. ; 1558 :                                &*_First2, _Last2 - _First2);
  5968. ; 1559 :                return (*this);
  5969. ; 1560 :                }
  5970. ; 1561 :
  5971. ; 1562 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  5972. ; 1563 :                iterator _First2, iterator _Last2)
  5973. ; 1564 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  5974. ; 1565 :                if (_First2 == _Last2)
  5975. ; 1566 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  5976. ; 1567 :                else
  5977. ; 1568 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  5978. ; 1569 :                                &*_First2, _Last2 - _First2);
  5979. ; 1570 :                return (*this);
  5980. ; 1571 :                }
  5981. ; 1572 :
  5982. ; 1573 :        iterator begin() _NOEXCEPT
  5983. ; 1574 :                {       // return iterator for beginning of mutable sequence
  5984. ; 1575 :                return (_STRING_ITERATOR(this->_Myptr()));
  5985. ; 1576 :                }
  5986. ; 1577 :
  5987. ; 1578 :        const_iterator begin() const _NOEXCEPT
  5988. ; 1579 :                {       // return iterator for beginning of nonmutable sequence
  5989. ; 1580 :                return (_STRING_CONST_ITERATOR(this->_Myptr()));
  5990. ; 1581 :                }
  5991. ; 1582 :
  5992. ; 1583 :        iterator end() _NOEXCEPT
  5993. ; 1584 :                {       // return iterator for end of mutable sequence
  5994. ; 1585 :                return (_STRING_ITERATOR(this->_Myptr() + this->_Mysize));
  5995. ; 1586 :                }
  5996. ; 1587 :
  5997. ; 1588 :        const_iterator end() const _NOEXCEPT
  5998. ; 1589 :                {       // return iterator for end of nonmutable sequence
  5999. ; 1590 :                return (_STRING_CONST_ITERATOR(this->_Myptr() + this->_Mysize));
  6000. ; 1591 :                }
  6001. ; 1592 :
  6002. ; 1593 :        reverse_iterator rbegin() _NOEXCEPT
  6003. ; 1594 :                {       // return iterator for beginning of reversed mutable sequence
  6004. ; 1595 :                return (reverse_iterator(end()));
  6005. ; 1596 :                }
  6006. ; 1597 :
  6007. ; 1598 :        const_reverse_iterator rbegin() const _NOEXCEPT
  6008. ; 1599 :                {       // return iterator for beginning of reversed nonmutable sequence
  6009. ; 1600 :                return (const_reverse_iterator(end()));
  6010. ; 1601 :                }
  6011. ; 1602 :
  6012. ; 1603 :        reverse_iterator rend() _NOEXCEPT
  6013. ; 1604 :                {       // return iterator for end of reversed mutable sequence
  6014. ; 1605 :                return (reverse_iterator(begin()));
  6015. ; 1606 :                }
  6016. ; 1607 :
  6017. ; 1608 :        const_reverse_iterator rend() const _NOEXCEPT
  6018. ; 1609 :                {       // return iterator for end of reversed nonmutable sequence
  6019. ; 1610 :                return (const_reverse_iterator(begin()));
  6020. ; 1611 :                }
  6021. ; 1612 :
  6022. ; 1613 :  #if _HAS_CPP0X
  6023. ; 1614 :        const_iterator cbegin() const _NOEXCEPT
  6024. ; 1615 :                {       // return iterator for beginning of nonmutable sequence
  6025. ; 1616 :                return (((const _Myt *)this)->begin());
  6026. ; 1617 :                }
  6027. ; 1618 :
  6028. ; 1619 :        const_iterator cend() const _NOEXCEPT
  6029. ; 1620 :                {       // return iterator for end of nonmutable sequence
  6030. ; 1621 :                return (((const _Myt *)this)->end());
  6031. ; 1622 :                }
  6032. ; 1623 :
  6033. ; 1624 :        const_reverse_iterator crbegin() const _NOEXCEPT
  6034. ; 1625 :                {       // return iterator for beginning of reversed nonmutable sequence
  6035. ; 1626 :                return (((const _Myt *)this)->rbegin());
  6036. ; 1627 :                }
  6037. ; 1628 :
  6038. ; 1629 :        const_reverse_iterator crend() const _NOEXCEPT
  6039. ; 1630 :                {       // return iterator for end of reversed nonmutable sequence
  6040. ; 1631 :                return (((const _Myt *)this)->rend());
  6041. ; 1632 :                }
  6042. ; 1633 :
  6043. ; 1634 :        void shrink_to_fit()
  6044. ; 1635 :                {       // reduce capacity
  6045. ; 1636 :                if ((size() | this->_ALLOC_MASK) < capacity())
  6046. ; 1637 :                        {       // worth shrinking, do it
  6047. ; 1638 :                        _Myt _Tmp(*this);
  6048. ; 1639 :                        swap(_Tmp);
  6049. ; 1640 :                        }
  6050. ; 1641 :                }
  6051. ; 1642 :  #endif /* _HAS_CPP0X */
  6052. ; 1643 :
  6053. ; 1644 :        reference at(size_type _Off)
  6054. ; 1645 :                {       // subscript mutable sequence with checking
  6055. ; 1646 :                if (this->_Mysize <= _Off)
  6056. ; 1647 :                        _Xran();        // _Off off end
  6057. ; 1648 :                return (this->_Myptr()[_Off]);
  6058. ; 1649 :                }
  6059. ; 1650 :
  6060. ; 1651 :        const_reference at(size_type _Off) const
  6061. ; 1652 :                {       // subscript nonmutable sequence with checking
  6062. ; 1653 :                if (this->_Mysize <= _Off)
  6063. ; 1654 :                        _Xran();        // _Off off end
  6064. ; 1655 :                return (this->_Myptr()[_Off]);
  6065. ; 1656 :                }
  6066. ; 1657 :
  6067. ; 1658 :        reference operator[](size_type _Off)
  6068. ; 1659 :                {       // subscript mutable sequence
  6069. ; 1660 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6070. ; 1661 :                if (this->_Mysize < _Off)       // sic
  6071. ; 1662 :                        _DEBUG_ERROR("string subscript out of range");
  6072. ; 1663 :
  6073. ; 1664 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  6074. ; 1665 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  6075. ; 1666 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6076. ; 1667 :
  6077. ; 1668 :                return (this->_Myptr()[_Off]);
  6078. ; 1669 :                }
  6079. ; 1670 :
  6080. ; 1671 :        const_reference operator[](size_type _Off) const
  6081. ; 1672 :                {       // subscript nonmutable sequence
  6082. ; 1673 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6083. ; 1674 :                if (this->_Mysize < _Off)       // sic
  6084. ; 1675 :                        _DEBUG_ERROR("string subscript out of range");
  6085. ; 1676 :
  6086. ; 1677 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  6087. ; 1678 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  6088. ; 1679 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6089. ; 1680 :
  6090. ; 1681 :                return (this->_Myptr()[_Off]);
  6091. ; 1682 :                }
  6092. ; 1683 :
  6093. ; 1684 :        void push_back(_Elem _Ch)
  6094. ; 1685 :                {       // insert element at end
  6095. ; 1686 :                insert(end(), _Ch);
  6096. ; 1687 :                }
  6097. ; 1688 :
  6098. ; 1689 :  #if _HAS_CPP0X
  6099. ; 1690 :        void pop_back()
  6100. ; 1691 :                {       // erase element at end
  6101. ; 1692 :                erase(this->_Mysize - 1);       // throws if _Mysize == 0
  6102. ; 1693 :                }
  6103. ; 1694 :
  6104. ; 1695 :        reference front()
  6105. ; 1696 :                {       // return first element of mutable sequence
  6106. ; 1697 :                return (*begin());
  6107. ; 1698 :                }
  6108. ; 1699 :
  6109. ; 1700 :        const_reference front() const
  6110. ; 1701 :                {       // return first element of nonmutable sequence
  6111. ; 1702 :                return (*begin());
  6112. ; 1703 :                }
  6113. ; 1704 :
  6114. ; 1705 :        reference back()
  6115. ; 1706 :                {       // return last element of mutable sequence
  6116. ; 1707 :                return (*(end() - 1));
  6117. ; 1708 :                }
  6118. ; 1709 :
  6119. ; 1710 :        const_reference back() const
  6120. ; 1711 :                {       // return last element of nonmutable sequence
  6121. ; 1712 :                return (*(end() - 1));
  6122. ; 1713 :                }
  6123. ; 1714 :  #endif /* _HAS_CPP0X */
  6124. ; 1715 :
  6125. ; 1716 :        const _Elem *c_str() const _NOEXCEPT
  6126. ; 1717 :                {       // return pointer to null-terminated nonmutable array
  6127. ; 1718 :                return (this->_Myptr());
  6128. ; 1719 :                }
  6129. ; 1720 :
  6130. ; 1721 :        const _Elem *data() const _NOEXCEPT
  6131. ; 1722 :                {       // return pointer to nonmutable array
  6132. ; 1723 :                return (c_str());
  6133. ; 1724 :                }
  6134. ; 1725 :
  6135. ; 1726 :        size_type length() const _NOEXCEPT
  6136. ; 1727 :                {       // return length of sequence
  6137. ; 1728 :                return (this->_Mysize);
  6138. ; 1729 :                }
  6139. ; 1730 :
  6140. ; 1731 :        size_type size() const _NOEXCEPT
  6141. ; 1732 :                {       // return length of sequence
  6142. ; 1733 :                return (this->_Mysize);
  6143. ; 1734 :                }
  6144. ; 1735 :
  6145. ; 1736 :        size_type max_size() const _NOEXCEPT
  6146. ; 1737 :                {       // return maximum possible length of sequence
  6147. ; 1738 :                size_type _Num = this->_Getal().max_size();
  6148. ; 1739 :                return (_Num <= 1 ? 1 : _Num - 1);
  6149. ; 1740 :                }
  6150. ; 1741 :
  6151. ; 1742 :        void resize(size_type _Newsize)
  6152. ; 1743 :                {       // determine new length, padding with null elements as needed
  6153. ; 1744 :                resize(_Newsize, _Elem());
  6154. ; 1745 :                }
  6155. ; 1746 :
  6156. ; 1747 :        void resize(size_type _Newsize, _Elem _Ch)
  6157. ; 1748 :                {       // determine new length, padding with _Ch elements as needed
  6158. ; 1749 :                if (_Newsize <= this->_Mysize)
  6159. ; 1750 :                        _Eos(_Newsize);
  6160. ; 1751 :                else
  6161. ; 1752 :                        append(_Newsize - this->_Mysize, _Ch);
  6162. ; 1753 :                }
  6163. ; 1754 :
  6164. ; 1755 :        size_type capacity() const _NOEXCEPT
  6165. ; 1756 :                {       // return current length of allocated storage
  6166. ; 1757 :                return (this->_Myres);
  6167. ; 1758 :                }
  6168. ; 1759 :
  6169. ; 1760 :        void reserve(size_type _Newcap = 0)
  6170. ; 1761 :                {       // determine new minimum length of allocated storage
  6171. ; 1762 :                if (this->_Mysize <= _Newcap && this->_Myres != _Newcap)
  6172. ; 1763 :                        {       // change reservation
  6173. ; 1764 :                        size_type _Size = this->_Mysize;
  6174. ; 1765 :                        if (_Grow(_Newcap, true))
  6175. ; 1766 :                                _Eos(_Size);
  6176. ; 1767 :                        }
  6177. ; 1768 :                }
  6178. ; 1769 :
  6179. ; 1770 :        bool empty() const _NOEXCEPT
  6180. ; 1771 :                {       // test if sequence is empty
  6181. ; 1772 :                return (this->_Mysize == 0);
  6182. ; 1773 :                }
  6183. ; 1774 :
  6184. ; 1775 :        _SCL_INSECURE_DEPRECATE
  6185. ; 1776 :
  6186. ; 1777 :        size_type copy(_Elem *_Ptr,
  6187. ; 1778 :                size_type _Count, size_type _Off = 0) const
  6188. ; 1779 :                {       // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
  6189. ; 1780 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6190. ; 1781 :                if (_Count != 0)
  6191. ; 1782 :                        _DEBUG_POINTER(_Ptr);
  6192. ; 1783 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6193. ; 1784 :
  6194. ; 1785 :                if (this->_Mysize < _Off)
  6195. ; 1786 :                        _Xran();        // _Off off end
  6196. ; 1787 :                if (this->_Mysize - _Off < _Count)
  6197. ; 1788 :                        _Count = this->_Mysize - _Off;
  6198. ; 1789 :                _Traits::copy(_Ptr, this->_Myptr() + _Off, _Count);
  6199. ; 1790 :                return (_Count);
  6200. ; 1791 :                }
  6201. ; 1792 :
  6202. ; 1793 :        size_type _Copy_s(_Elem *_Dest, size_type _Dest_size,
  6203. ; 1794 :                size_type _Count, size_type _Off = 0) const
  6204. ; 1795 :                {       // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Count)
  6205. ; 1796 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6206. ; 1797 :                if (_Count != 0)
  6207. ; 1798 :                        _DEBUG_POINTER(_Dest);
  6208. ; 1799 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6209. ; 1800 :
  6210. ; 1801 :                if (this->_Mysize < _Off)
  6211. ; 1802 :                        _Xran();        // _Off off end
  6212. ; 1803 :                if (this->_Mysize - _Off < _Count)
  6213. ; 1804 :                        _Count = this->_Mysize - _Off;
  6214. ; 1805 :                _Traits::_Copy_s(_Dest, _Dest_size, this->_Myptr() + _Off, _Count);
  6215. ; 1806 :                return (_Count);
  6216. ; 1807 :                }
  6217. ; 1808 :
  6218. ; 1809 :        void _Swap_bx(_Myt& _Right)
  6219. ; 1810 :                {       // exchange _Bx with _Right._Bx
  6220. ; 1811 :                if (this->_BUF_SIZE <= this->_Myres)
  6221. ; 1812 :                        if (this->_BUF_SIZE <= _Right._Myres)
  6222. ; 1813 :                                _Swap_adl(this->_Bx._Ptr, _Right._Bx._Ptr);
  6223. ; 1814 :                        else
  6224. ; 1815 :                                {       // swap large with small
  6225. ; 1816 :                                pointer _Ptr = this->_Bx._Ptr;
  6226. ; 1817 :                                this->_Getal().destroy(&this->_Bx._Ptr);
  6227. ; 1818 :                                _Traits::copy(this->_Bx._Buf,
  6228. ; 1819 :                                        _Right._Bx._Buf, _Right._Mysize + 1);
  6229. ; 1820 :                                this->_Getal().construct(&_Right._Bx._Ptr, _Ptr);
  6230. ; 1821 :                                }
  6231. ; 1822 :                else
  6232. ; 1823 :                        if (_Right._Myres < this->_BUF_SIZE)
  6233. ; 1824 :                                _STD swap(this->_Bx._Buf, _Right._Bx._Buf);
  6234. ; 1825 :                        else
  6235. ; 1826 :                                {       // swap small with large
  6236. ; 1827 :                                pointer _Ptr = _Right._Bx._Ptr;
  6237. ; 1828 :                                this->_Getal().destroy(&_Right._Bx._Ptr);
  6238. ; 1829 :                                _Traits::copy(_Right._Bx._Buf,
  6239. ; 1830 :                                        this->_Bx._Buf, this->_Mysize + 1);
  6240. ; 1831 :                                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
  6241. ; 1832 :                                }
  6242. ; 1833 :                }
  6243. ; 1834 :
  6244. ; 1835 :        void swap(_Myt& _Right)
  6245. ; 1836 :                {       // exchange contents with _Right
  6246. ; 1837 :                if (this == &_Right)
  6247. ; 1838 :                        ;       // same object, do nothing
  6248. ; 1839 :                else if (this->_Getal() == _Right._Getal())
  6249. ; 1840 :                        {       // same allocator, swap control information
  6250. ; 1841 :                        this->_Swap_all(_Right);
  6251. ; 1842 :                        _Swap_bx(_Right);
  6252. ; 1843 :                        _STD swap(this->_Mysize, _Right._Mysize);
  6253. ; 1844 :                        _STD swap(this->_Myres, _Right._Myres);
  6254. ; 1845 :                        }
  6255. ; 1846 :
  6256. ; 1847 :  #if _HAS_CPP0X
  6257. ; 1848 :                else if (_Alty::propagate_on_container_swap::value)
  6258. ; 1849 :                        {       // swap allocators and control information
  6259. ; 1850 :                        this->_Swap_alloc(_Right);
  6260. ; 1851 :                        _Swap_bx(_Right);
  6261. ; 1852 :                        _STD swap(this->_Bx, _Right._Bx);       // pointer bitwise copyable?
  6262. ; 1853 :                        _STD swap(this->_Mysize, _Right._Mysize);
  6263. ; 1854 :                        _STD swap(this->_Myres, _Right._Myres);
  6264. ; 1855 :                        }
  6265. ; 1856 :  #endif /* _HAS_CPP0X */
  6266. ; 1857 :
  6267. ; 1858 :                else
  6268. ; 1859 :                        {       // different allocator, do multiple assigns
  6269. ; 1860 :                        _Myt _Tmp = *this;
  6270. ; 1861 :
  6271. ; 1862 :                        *this = _Right;
  6272. ; 1863 :                        _Right = _Tmp;
  6273. ; 1864 :                        }
  6274. ; 1865 :                }
  6275. ; 1866 :
  6276. ; 1867 :        size_type find(const _Myt& _Right, size_type _Off = 0) const _NOEXCEPT
  6277. ; 1868 :                {       // look for _Right beginning at or after _Off
  6278. ; 1869 :                return (find(_Right._Myptr(), _Off, _Right.size()));
  6279. ; 1870 :                }
  6280. ; 1871 :
  6281. ; 1872 :        size_type find(const _Elem *_Ptr,
  6282. ; 1873 :                size_type _Off, size_type _Count) const
  6283. ; 1874 :                {       // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
  6284. ; 1875 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6285. ; 1876 :                if (_Count != 0)
  6286. ; 1877 :                        _DEBUG_POINTER(_Ptr);
  6287. ; 1878 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6288. ; 1879 :
  6289. ; 1880 :                if (_Count == 0 && _Off <= this->_Mysize)
  6290. ; 1881 :                        return (_Off);  // null string always matches (if inside string)
  6291. ; 1882 :
  6292. ; 1883 :                size_type _Nm;
  6293. ; 1884 :                if (_Off < this->_Mysize && _Count <= (_Nm = this->_Mysize - _Off))
  6294. ; 1885 :                        {       // room for match, look for it
  6295. ; 1886 :                        const _Elem *_Uptr, *_Vptr;
  6296. ; 1887 :                        for (_Nm -= _Count - 1, _Vptr = this->_Myptr() + _Off;
  6297. ; 1888 :                                (_Uptr = _Traits::find(_Vptr, _Nm, *_Ptr)) != 0;
  6298. ; 1889 :                                _Nm -= _Uptr - _Vptr + 1, _Vptr = _Uptr + 1)
  6299. ; 1890 :                                if (_Traits::compare(_Uptr, _Ptr, _Count) == 0)
  6300. ; 1891 :                                        return (_Uptr - this->_Myptr());        // found a match
  6301. ; 1892 :                        }
  6302. ; 1893 :
  6303. ; 1894 :                return (npos);  // no match
  6304. ; 1895 :                }
  6305. ; 1896 :
  6306. ; 1897 :        size_type find(const _Elem *_Ptr, size_type _Off = 0) const
  6307. ; 1898 :                {       // look for [_Ptr, <null>) beginning at or after _Off
  6308. ; 1899 :                _DEBUG_POINTER(_Ptr);
  6309. ; 1900 :                return (find(_Ptr, _Off, _Traits::length(_Ptr)));
  6310. ; 1901 :                }
  6311. ; 1902 :
  6312. ; 1903 :        size_type find(_Elem _Ch, size_type _Off = 0) const
  6313. ; 1904 :                {       // look for _Ch at or after _Off
  6314. ; 1905 :                return (find((const _Elem *)&_Ch, _Off, 1));
  6315. ; 1906 :                }
  6316. ; 1907 :
  6317. ; 1908 :        size_type rfind(const _Myt& _Right, size_type _Off = npos) const _NOEXCEPT
  6318. ; 1909 :                {       // look for _Right beginning before _Off
  6319. ; 1910 :                return (rfind(_Right._Myptr(), _Off, _Right.size()));
  6320. ; 1911 :                }
  6321. ; 1912 :
  6322. ; 1913 :        size_type rfind(const _Elem *_Ptr,
  6323. ; 1914 :                size_type _Off, size_type _Count) const
  6324. ; 1915 :                {       // look for [_Ptr, _Ptr + _Count) beginning before _Off
  6325. ; 1916 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6326. ; 1917 :                if (_Count != 0)
  6327. ; 1918 :                        _DEBUG_POINTER(_Ptr);
  6328. ; 1919 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6329. ; 1920 :
  6330. ; 1921 :                if (_Count == 0)
  6331. ; 1922 :                        return (_Off < this->_Mysize ? _Off
  6332. ; 1923 :                                : this->_Mysize);       // null always matches
  6333. ; 1924 :                if (_Count <= this->_Mysize)
  6334. ; 1925 :                        {       // room for match, look for it
  6335. ; 1926 :                        const _Elem *_Uptr = this->_Myptr() +
  6336. ; 1927 :                                (_Off < this->_Mysize - _Count ? _Off
  6337. ; 1928 :                                        : this->_Mysize - _Count);
  6338. ; 1929 :                        for (; ; --_Uptr)
  6339. ; 1930 :                                if (_Traits::eq(*_Uptr, *_Ptr)
  6340. ; 1931 :                                        && _Traits::compare(_Uptr, _Ptr, _Count) == 0)
  6341. ; 1932 :                                        return (_Uptr - this->_Myptr());        // found a match
  6342. ; 1933 :                                else if (_Uptr == this->_Myptr())
  6343. ; 1934 :                                        break;  // at beginning, no more chance for match
  6344. ; 1935 :                        }
  6345. ; 1936 :
  6346. ; 1937 :                return (npos);  // no match
  6347. ; 1938 :                }
  6348. ; 1939 :
  6349. ; 1940 :        size_type rfind(const _Elem *_Ptr, size_type _Off = npos) const
  6350. ; 1941 :                {       // look for [_Ptr, <null>) beginning before _Off
  6351. ; 1942 :                _DEBUG_POINTER(_Ptr);
  6352. ; 1943 :                return (rfind(_Ptr, _Off, _Traits::length(_Ptr)));
  6353. ; 1944 :                }
  6354. ; 1945 :
  6355. ; 1946 :        size_type rfind(_Elem _Ch, size_type _Off = npos) const
  6356. ; 1947 :                {       // look for _Ch before _Off
  6357. ; 1948 :                return (rfind((const _Elem *)&_Ch, _Off, 1));
  6358. ; 1949 :                }
  6359. ; 1950 :
  6360. ; 1951 :        size_type find_first_of(const _Myt& _Right,
  6361. ; 1952 :                size_type _Off = 0) const _NOEXCEPT
  6362. ; 1953 :                {       // look for one of _Right at or after _Off
  6363. ; 1954 :                return (find_first_of(_Right._Myptr(), _Off, _Right.size()));
  6364. ; 1955 :                }
  6365. ; 1956 :
  6366. ; 1957 :        size_type find_first_of(const _Elem *_Ptr,
  6367. ; 1958 :                size_type _Off, size_type _Count) const
  6368. ; 1959 :                {       // look for one of [_Ptr, _Ptr + _Count) at or after _Off
  6369. ; 1960 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6370. ; 1961 :                if (_Count != 0)
  6371. ; 1962 :                        _DEBUG_POINTER(_Ptr);
  6372. ; 1963 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6373. ; 1964 :
  6374. ; 1965 :                if (0 < _Count && _Off < this->_Mysize)
  6375. ; 1966 :                        {       // room for match, look for it
  6376. ; 1967 :                        const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
  6377. ; 1968 :                        for (const _Elem *_Uptr = this->_Myptr() + _Off;
  6378. ; 1969 :                                _Uptr < _Vptr; ++_Uptr)
  6379. ; 1970 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
  6380. ; 1971 :                                        return (_Uptr - this->_Myptr());        // found a match
  6381. ; 1972 :                        }
  6382. ; 1973 :
  6383. ; 1974 :                return (npos);  // no match
  6384. ; 1975 :                }
  6385. ; 1976 :
  6386. ; 1977 :        size_type find_first_of(const _Elem *_Ptr,
  6387. ; 1978 :                size_type _Off = 0) const
  6388. ; 1979 :                {       // look for one of [_Ptr, <null>) at or after _Off
  6389. ; 1980 :                _DEBUG_POINTER(_Ptr);
  6390. ; 1981 :                return (find_first_of(_Ptr, _Off, _Traits::length(_Ptr)));
  6391. ; 1982 :                }
  6392. ; 1983 :
  6393. ; 1984 :        size_type find_first_of(_Elem _Ch,
  6394. ; 1985 :                size_type _Off = 0) const
  6395. ; 1986 :                {       // look for _Ch at or after _Off
  6396. ; 1987 :                return (find((const _Elem *)&_Ch, _Off, 1));
  6397. ; 1988 :                }
  6398. ; 1989 :
  6399. ; 1990 :        size_type find_last_of(const _Myt& _Right,
  6400. ; 1991 :                size_type _Off = npos) const _NOEXCEPT
  6401. ; 1992 :                {       // look for one of _Right before _Off
  6402. ; 1993 :                return (find_last_of(_Right._Myptr(), _Off, _Right.size()));
  6403. ; 1994 :                }
  6404. ; 1995 :
  6405. ; 1996 :        size_type find_last_of(const _Elem *_Ptr,
  6406. ; 1997 :                size_type _Off, size_type _Count) const
  6407. ; 1998 :                {       // look for one of [_Ptr, _Ptr + _Count) before _Off
  6408. ; 1999 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6409. ; 2000 :                if (_Count != 0)
  6410. ; 2001 :                        _DEBUG_POINTER(_Ptr);
  6411. ; 2002 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6412. ; 2003 :
  6413. ; 2004 :                if (0 < _Count && 0 < this->_Mysize)
  6414. ; 2005 :                        {       // worth searching, do it
  6415. ; 2006 :                        const _Elem *_Uptr = this->_Myptr()
  6416. ; 2007 :                                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
  6417. ; 2008 :                        for (; ; --_Uptr)
  6418. ; 2009 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
  6419. ; 2010 :                                        return (_Uptr - this->_Myptr());        // found a match
  6420. ; 2011 :                                else if (_Uptr == this->_Myptr())
  6421. ; 2012 :                                        break;  // at beginning, no more chance for match
  6422. ; 2013 :                        }
  6423. ; 2014 :
  6424. ; 2015 :                return (npos);  // no match
  6425. ; 2016 :                }
  6426. ; 2017 :
  6427. ; 2018 :        size_type find_last_of(const _Elem *_Ptr,
  6428. ; 2019 :                size_type _Off = npos) const
  6429. ; 2020 :                {       // look for one of [_Ptr, <null>) before _Off
  6430. ; 2021 :                _DEBUG_POINTER(_Ptr);
  6431. ; 2022 :                return (find_last_of(_Ptr, _Off, _Traits::length(_Ptr)));
  6432. ; 2023 :                }
  6433. ; 2024 :
  6434. ; 2025 :        size_type find_last_of(_Elem _Ch,
  6435. ; 2026 :                size_type _Off = npos) const
  6436. ; 2027 :                {       // look for _Ch before _Off
  6437. ; 2028 :                return (rfind((const _Elem *)&_Ch, _Off, 1));
  6438. ; 2029 :                }
  6439. ; 2030 :
  6440. ; 2031 :        size_type find_first_not_of(const _Myt& _Right,
  6441. ; 2032 :                size_type _Off = 0) const _NOEXCEPT
  6442. ; 2033 :                {       // look for none of _Right at or after _Off
  6443. ; 2034 :                return (find_first_not_of(_Right._Myptr(), _Off,
  6444. ; 2035 :                        _Right.size()));
  6445. ; 2036 :                }
  6446. ; 2037 :
  6447. ; 2038 :        size_type find_first_not_of(const _Elem *_Ptr,
  6448. ; 2039 :                size_type _Off, size_type _Count) const
  6449. ; 2040 :                {       // look for none of [_Ptr, _Ptr + _Count) at or after _Off
  6450. ; 2041 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6451. ; 2042 :                if (_Count != 0)
  6452. ; 2043 :                        _DEBUG_POINTER(_Ptr);
  6453. ; 2044 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6454. ; 2045 :
  6455. ; 2046 :                if (_Off < this->_Mysize)
  6456. ; 2047 :                        {       // room for match, look for it
  6457. ; 2048 :                        const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
  6458. ; 2049 :                        for (const _Elem *_Uptr = this->_Myptr() + _Off;
  6459. ; 2050 :                                _Uptr < _Vptr; ++_Uptr)
  6460. ; 2051 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
  6461. ; 2052 :                                        return (_Uptr - this->_Myptr());
  6462. ; 2053 :                        }
  6463. ; 2054 :                return (npos);
  6464. ; 2055 :                }
  6465. ; 2056 :
  6466. ; 2057 :        size_type find_first_not_of(const _Elem *_Ptr,
  6467. ; 2058 :                size_type _Off = 0) const
  6468. ; 2059 :                {       // look for one of [_Ptr, <null>) at or after _Off
  6469. ; 2060 :                _DEBUG_POINTER(_Ptr);
  6470. ; 2061 :                return (find_first_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
  6471. ; 2062 :                }
  6472. ; 2063 :
  6473. ; 2064 :        size_type find_first_not_of(_Elem _Ch,
  6474. ; 2065 :                size_type _Off = 0) const
  6475. ; 2066 :                {       // look for non _Ch at or after _Off
  6476. ; 2067 :                return (find_first_not_of((const _Elem *)&_Ch, _Off, 1));
  6477. ; 2068 :                }
  6478. ; 2069 :
  6479. ; 2070 :        size_type find_last_not_of(const _Myt& _Right,
  6480. ; 2071 :                size_type _Off = npos) const _NOEXCEPT
  6481. ; 2072 :                {       // look for none of _Right before _Off
  6482. ; 2073 :                return (find_last_not_of(_Right._Myptr(), _Off, _Right.size()));
  6483. ; 2074 :                }
  6484. ; 2075 :
  6485. ; 2076 :        size_type find_last_not_of(const _Elem *_Ptr,
  6486. ; 2077 :                size_type _Off, size_type _Count) const
  6487. ; 2078 :                {       // look for none of [_Ptr, _Ptr + _Count) before _Off
  6488. ; 2079 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6489. ; 2080 :                if (_Count != 0)
  6490. ; 2081 :                        _DEBUG_POINTER(_Ptr);
  6491. ; 2082 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6492. ; 2083 :
  6493. ; 2084 :                if (0 < this->_Mysize)
  6494. ; 2085 :                        {       // worth searching, do it
  6495. ; 2086 :                        const _Elem *_Uptr = this->_Myptr()
  6496. ; 2087 :                                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
  6497. ; 2088 :                        for (; ; --_Uptr)
  6498. ; 2089 :                                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
  6499. ; 2090 :                                        return (_Uptr - this->_Myptr());
  6500. ; 2091 :                                else if (_Uptr == this->_Myptr())
  6501. ; 2092 :                                        break;
  6502. ; 2093 :                        }
  6503. ; 2094 :                return (npos);
  6504. ; 2095 :                }
  6505. ; 2096 :
  6506. ; 2097 :        size_type find_last_not_of(const _Elem *_Ptr,
  6507. ; 2098 :                size_type _Off = npos) const
  6508. ; 2099 :                {       // look for none of [_Ptr, <null>) before _Off
  6509. ; 2100 :                _DEBUG_POINTER(_Ptr);
  6510. ; 2101 :                return (find_last_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
  6511. ; 2102 :                }
  6512. ; 2103 :
  6513. ; 2104 :        size_type find_last_not_of(_Elem _Ch,
  6514. ; 2105 :                size_type _Off = npos) const
  6515. ; 2106 :                {       // look for non _Ch before _Off
  6516. ; 2107 :                return (find_last_not_of((const _Elem *)&_Ch, _Off, 1));
  6517. ; 2108 :                }
  6518. ; 2109 :
  6519. ; 2110 :        _Myt substr(size_type _Off = 0, size_type _Count = npos) const
  6520. ; 2111 :                {       // return [_Off, _Off + _Count) as new string
  6521. ; 2112 :                return (_Myt(*this, _Off, _Count, get_allocator()));
  6522. ; 2113 :                }
  6523. ; 2114 :
  6524. ; 2115 :        int compare(const _Myt& _Right) const _NOEXCEPT
  6525. ; 2116 :                {       // compare [0, _Mysize) with _Right
  6526. ; 2117 :                return (compare(0, this->_Mysize, _Right._Myptr(), _Right.size()));
  6527. ; 2118 :                }
  6528. ; 2119 :
  6529. ; 2120 :        int compare(size_type _Off, size_type _N0,
  6530. ; 2121 :                const _Myt& _Right) const
  6531. ; 2122 :                {       // compare [_Off, _Off + _N0) with _Right
  6532. ; 2123 :                return (compare(_Off, _N0, _Right, 0, npos));
  6533. ; 2124 :                }
  6534. ; 2125 :
  6535. ; 2126 :        int compare(size_type _Off,
  6536. ; 2127 :                size_type _N0, const _Myt& _Right,
  6537. ; 2128 :                size_type _Roff, size_type _Count) const
  6538. ; 2129 :                {       // compare [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
  6539. ; 2130 :                if (_Right.size() < _Roff)
  6540. ; 2131 :                        _Xran();        // _Off off end
  6541. ; 2132 :                if (_Right._Mysize - _Roff < _Count)
  6542. ; 2133 :                        _Count = _Right._Mysize - _Roff;        // trim _Count to size
  6543. ; 2134 :                return (compare(_Off, _N0, _Right._Myptr() + _Roff, _Count));
  6544. ; 2135 :                }
  6545. ; 2136 :
  6546. ; 2137 :        int compare(const _Elem *_Ptr) const
  6547. ; 2138 :                {       // compare [0, _Mysize) with [_Ptr, <null>)
  6548. ; 2139 :                _DEBUG_POINTER(_Ptr);
  6549. ; 2140 :                return (compare(0, this->_Mysize, _Ptr, _Traits::length(_Ptr)));
  6550. ; 2141 :                }
  6551. ; 2142 :
  6552. ; 2143 :        int compare(size_type _Off, size_type _N0, const _Elem *_Ptr) const
  6553. ; 2144 :                {       // compare [_Off, _Off + _N0) with [_Ptr, <null>)
  6554. ; 2145 :                _DEBUG_POINTER(_Ptr);
  6555. ; 2146 :                return (compare(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
  6556. ; 2147 :                }
  6557. ; 2148 :
  6558. ; 2149 :        int compare(size_type _Off,
  6559. ; 2150 :                size_type _N0, const _Elem *_Ptr, size_type _Count) const
  6560. ; 2151 :                {       // compare [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
  6561. ; 2152 :  #if _ITERATOR_DEBUG_LEVEL == 2
  6562. ; 2153 :                if (_Count != 0)
  6563. ; 2154 :                        _DEBUG_POINTER(_Ptr);
  6564. ; 2155 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  6565. ; 2156 :
  6566. ; 2157 :                if (this->_Mysize < _Off)
  6567. ; 2158 :                        _Xran();        // _Off off end
  6568. ; 2159 :                if (this->_Mysize - _Off < _N0)
  6569. ; 2160 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  6570. ; 2161 :
  6571. ; 2162 :                size_type _Ans = _Traits::compare(this->_Myptr() + _Off, _Ptr,
  6572. ; 2163 :                        _N0 < _Count ? _N0 : _Count);
  6573. ; 2164 :                return (_Ans != 0 ? (int)_Ans : _N0 < _Count ? -1
  6574. ; 2165 :                        : _N0 == _Count ? 0 : +1);
  6575. ; 2166 :                }
  6576. ; 2167 :
  6577. ; 2168 :        allocator_type get_allocator() const _NOEXCEPT
  6578. ; 2169 :                {       // return allocator object for values
  6579. ; 2170 :                return (this->_Getal());
  6580. ; 2171 :                }
  6581. ; 2172 :
  6582. ; 2173 :        void _Chassign(size_type _Off, size_type _Count, _Elem _Ch)
  6583. ; 2174 :                {       // assign _Count copies of _Ch beginning at _Off
  6584. ; 2175 :                if (_Count == 1)
  6585. ; 2176 :                        _Traits::assign(*(this->_Myptr() + _Off), _Ch);
  6586. ; 2177 :                else
  6587. ; 2178 :                        _Traits::assign(this->_Myptr() + _Off, _Count, _Ch);
  6588. ; 2179 :                }
  6589. ; 2180 :
  6590. ; 2181 :        void _Copy(size_type _Newsize, size_type _Oldlen)
  6591. ; 2182 :                {       // copy _Oldlen elements to newly allocated buffer
  6592. ; 2183 :                size_type _Newres = _Newsize | this->_ALLOC_MASK;
  6593. ; 2184 :                if (max_size() < _Newres)
  6594. ; 2185 :                        _Newres = _Newsize;     // undo roundup if too big
  6595. ; 2186 :                else if (this->_Myres / 2 <= _Newres / 3)
  6596. ; 2187 :                        ;
  6597. ; 2188 :                else if (this->_Myres <= max_size() - this->_Myres / 2)
  6598. ; 2189 :                        _Newres = this->_Myres
  6599. ; 2190 :                                + this->_Myres / 2;     // grow exponentially if possible
  6600. ; 2191 :                else
  6601. ; 2192 :                        _Newres = max_size();   // settle for max_size()
  6602. ; 2193 :
  6603. ; 2194 :                _Elem *_Ptr;
  6604. ; 2195 :                _TRY_BEGIN
  6605. ; 2196 :                        _Ptr = this->_Getal().allocate(_Newres + 1);
  6606. ; 2197 :                _CATCH_ALL
  6607. ; 2198 :                        _Newres = _Newsize;     // allocation failed, undo roundup and retry
  6608. ; 2199 :                        _TRY_BEGIN
  6609. ; 2200 :                                _Ptr = this->_Getal().allocate(_Newres + 1);
  6610. ; 2201 :                        _CATCH_ALL
  6611. ; 2202 :                        _Tidy(true);    // failed again, discard storage and reraise
  6612. ; 2203 :                        _RERAISE;
  6613. ; 2204 :                        _CATCH_END
  6614. ; 2205 :                _CATCH_END
  6615. ; 2206 :
  6616. ; 2207 :                if (0 < _Oldlen)
  6617. ; 2208 :                        _Traits::copy(_Ptr, this->_Myptr(),
  6618. ; 2209 :                                _Oldlen);       // copy existing elements
  6619. ; 2210 :                _Tidy(true);
  6620. ; 2211 :                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
  6621. ; 2212 :                this->_Myres = _Newres;
  6622. ; 2213 :                _Eos(_Oldlen);
  6623. ; 2214 :                }
  6624. ; 2215 :
  6625. ; 2216 :        void _Eos(size_type _Newsize)
  6626. ; 2217 :                {       // set new length and null terminator
  6627. ; 2218 :                _Traits::assign(this->_Myptr()[this->_Mysize = _Newsize], _Elem());
  6628.  
  6629.         mov     DWORD PTR [ecx+16], esi
  6630.  
  6631. ; 517  :                        : this->_Bx._Buf);
  6632.  
  6633.         cmp     eax, 16                                 ; 00000010H
  6634.         jb      SHORT $LN60@Grow
  6635. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  6636.  
  6637. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  6638.  
  6639.         mov     ecx, DWORD PTR [ecx]
  6640. $LN60@Grow:
  6641. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  6642.  
  6643. ; 564  :                _Left = _Right;
  6644.  
  6645.         mov     BYTE PTR [ecx], 0
  6646. $LN64@Grow:
  6647. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6648.  
  6649. ; 2233 :                return (0 < _Newsize);  // return true only if more work to do
  6650.  
  6651.         xor     eax, eax
  6652.         cmp     eax, esi
  6653.         sbb     eax, eax
  6654.         neg     eax
  6655.         pop     esi
  6656.  
  6657. ; 2234 :                }
  6658.  
  6659.         pop     ebp
  6660.         ret     8
  6661. $LN67@Grow:
  6662. ?_Grow@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE_NI_N@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Grow
  6663. _TEXT   ENDS
  6664. ; Function compile flags: /Ogtp
  6665. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6666. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  6667. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6668. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  6669. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6670. ;       COMDAT ?_Inside@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE_NPBD@Z
  6671. _TEXT   SEGMENT
  6672. __Ptr$ = 8                                              ; size = 4
  6673. ?_Inside@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE_NPBD@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Inside, COMDAT
  6674. ; _this$ = ecx
  6675.  
  6676. ; 2237 :                {       // test if _Ptr points inside string
  6677.  
  6678.         push    ebp
  6679.         mov     ebp, esp
  6680.  
  6681. ; 2238 :                if (_Ptr == 0 || _Ptr < this->_Myptr()
  6682. ; 2239 :                        || this->_Myptr() + this->_Mysize <= _Ptr)
  6683.  
  6684.         mov     edx, DWORD PTR __Ptr$[ebp]
  6685.         push    esi
  6686.         test    edx, edx
  6687.         je      SHORT $LN2@Inside
  6688.  
  6689. ; 517  :                        : this->_Bx._Buf);
  6690.  
  6691.         mov     eax, DWORD PTR [ecx+20]
  6692.         cmp     eax, 16                                 ; 00000010H
  6693.         jb      SHORT $LN8@Inside
  6694. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  6695.  
  6696. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  6697.  
  6698.         mov     esi, DWORD PTR [ecx]
  6699. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6700.  
  6701. ; 517  :                        : this->_Bx._Buf);
  6702.  
  6703.         jmp     SHORT $LN9@Inside
  6704. $LN8@Inside:
  6705.         mov     esi, ecx
  6706. $LN9@Inside:
  6707.  
  6708. ; 2238 :                if (_Ptr == 0 || _Ptr < this->_Myptr()
  6709. ; 2239 :                        || this->_Myptr() + this->_Mysize <= _Ptr)
  6710.  
  6711.         cmp     edx, esi
  6712.         jb      SHORT $LN2@Inside
  6713.  
  6714. ; 517  :                        : this->_Bx._Buf);
  6715.  
  6716.         cmp     eax, 16                                 ; 00000010H
  6717.         jb      SHORT $LN14@Inside
  6718. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  6719.  
  6720. ; 88   :                reinterpret_cast<const volatile char&>(_Val)))));
  6721.  
  6722.         mov     esi, DWORD PTR [ecx]
  6723. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6724.  
  6725. ; 517  :                        : this->_Bx._Buf);
  6726.  
  6727.         jmp     SHORT $LN15@Inside
  6728. $LN14@Inside:
  6729.         mov     esi, ecx
  6730. $LN15@Inside:
  6731.  
  6732. ; 2238 :                if (_Ptr == 0 || _Ptr < this->_Myptr()
  6733. ; 2239 :                        || this->_Myptr() + this->_Mysize <= _Ptr)
  6734.  
  6735.         mov     eax, DWORD PTR [ecx+16]
  6736.         add     eax, esi
  6737.         cmp     eax, edx
  6738.         jbe     SHORT $LN2@Inside
  6739.  
  6740. ; 2241 :                else
  6741. ; 2242 :                        return (true);
  6742.  
  6743.         mov     al, 1
  6744.         pop     esi
  6745.  
  6746. ; 2243 :                }
  6747.  
  6748.         pop     ebp
  6749.         ret     4
  6750. $LN2@Inside:
  6751.  
  6752. ; 2240 :                        return (false); // don't ask
  6753.  
  6754.         xor     al, al
  6755.         pop     esi
  6756.  
  6757. ; 2243 :                }
  6758.  
  6759.         pop     ebp
  6760.         ret     4
  6761. ?_Inside@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE_NPBD@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Inside
  6762. _TEXT   ENDS
  6763. ; Function compile flags: /Ogtp
  6764. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6765. ;       COMDAT ?_Xlen@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEXXZ
  6766. _TEXT   SEGMENT
  6767. ?_Xlen@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEXXZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Xlen, COMDAT
  6768. ; _this$dead$ = ecx
  6769.  
  6770. ; 2271 :                _Xlength_error("string too long");
  6771.  
  6772.         push    OFFSET ??_C@_0BA@JFNIOLAK@string?5too?5long?$AA@
  6773.         call    DWORD PTR __imp_?_Xlength_error@std@@YAXPBD@Z
  6774. $LN4@Xlen:
  6775. $LN3@Xlen:
  6776.         int     3
  6777. ?_Xlen@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEXXZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Xlen
  6778. _TEXT   ENDS
  6779. ; Function compile flags: /Ogtp
  6780. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  6781. ;       COMDAT ?deallocate@?$allocator@D@std@@QAEXPADI@Z
  6782. _TEXT   SEGMENT
  6783. __Ptr$ = 8                                              ; size = 4
  6784. ___formal$dead$ = 12                                    ; size = 4
  6785. ?deallocate@?$allocator@D@std@@QAEXPADI@Z PROC          ; std::allocator<char>::deallocate, COMDAT
  6786. ; _this$dead$ = ecx
  6787.  
  6788. ; 585  :                {       // deallocate object at _Ptr, ignore size
  6789.  
  6790.         push    ebp
  6791.         mov     ebp, esp
  6792.  
  6793. ; 586  :                ::operator delete(_Ptr);
  6794.  
  6795.         push    DWORD PTR __Ptr$[ebp]
  6796.         call    DWORD PTR __imp_??3@YAXPAX@Z
  6797.         add     esp, 4
  6798.  
  6799. ; 587  :                }
  6800.  
  6801.         pop     ebp
  6802.         ret     8
  6803. ?deallocate@?$allocator@D@std@@QAEXPADI@Z ENDP          ; std::allocator<char>::deallocate
  6804. _TEXT   ENDS
  6805. ; Function compile flags: /Ogtp
  6806. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  6807. ;       COMDAT ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QAEPADXZ
  6808. _TEXT   SEGMENT
  6809. ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QAEPADXZ PROC ; std::_String_val<std::_Simple_types<char> >::_Myptr, COMDAT
  6810. ; _this$ = ecx
  6811.  
  6812. ; 515  :                return (this->_BUF_SIZE <= this->_Myres
  6813. ; 516  :                        ? _STD addressof(*this->_Bx._Ptr)
  6814. ; 517  :                        : this->_Bx._Buf);
  6815.  
  6816.         cmp     DWORD PTR [ecx+20], 16                  ; 00000010H
  6817.         jb      SHORT $LN3@Myptr
  6818.         mov     eax, DWORD PTR [ecx]
  6819.  
  6820. ; 518  :                }
  6821.  
  6822.         ret     0
  6823. $LN3@Myptr:
  6824.  
  6825. ; 515  :                return (this->_BUF_SIZE <= this->_Myres
  6826. ; 516  :                        ? _STD addressof(*this->_Bx._Ptr)
  6827. ; 517  :                        : this->_Bx._Buf);
  6828.  
  6829.         mov     eax, ecx
  6830.  
  6831. ; 518  :                }
  6832.  
  6833.         ret     0
  6834. ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QAEPADXZ ENDP ; std::_String_val<std::_Simple_types<char> >::_Myptr
  6835. _TEXT   ENDS
  6836. ; Function compile flags: /Ogtp
  6837. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  6838. ;       COMDAT ?deallocate@?$allocator@H@std@@QAEXPAHI@Z
  6839. _TEXT   SEGMENT
  6840. __Ptr$ = 8                                              ; size = 4
  6841. ___formal$dead$ = 12                                    ; size = 4
  6842. ?deallocate@?$allocator@H@std@@QAEXPAHI@Z PROC          ; std::allocator<int>::deallocate, COMDAT
  6843. ; _this$dead$ = ecx
  6844.  
  6845. ; 585  :                {       // deallocate object at _Ptr, ignore size
  6846.  
  6847.         push    ebp
  6848.         mov     ebp, esp
  6849.  
  6850. ; 586  :                ::operator delete(_Ptr);
  6851.  
  6852.         push    DWORD PTR __Ptr$[ebp]
  6853.         call    DWORD PTR __imp_??3@YAXPAX@Z
  6854.         add     esp, 4
  6855.  
  6856. ; 587  :                }
  6857.  
  6858.         pop     ebp
  6859.         ret     8
  6860. ?deallocate@?$allocator@H@std@@QAEXPAHI@Z ENDP          ; std::allocator<int>::deallocate
  6861. _TEXT   ENDS
  6862. ; Function compile flags: /Ogtp
  6863. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  6864. ;       COMDAT ??0?$_Wrap_alloc@V?$allocator@H@std@@@std@@QAE@XZ
  6865. _TEXT   SEGMENT
  6866. ??0?$_Wrap_alloc@V?$allocator@H@std@@@std@@QAE@XZ PROC  ; std::_Wrap_alloc<std::allocator<int> >::_Wrap_alloc<std::allocator<int> >, COMDAT
  6867. ; _this$ = ecx
  6868.  
  6869. ; 831  :                }
  6870.  
  6871.         mov     eax, ecx
  6872.         ret     0
  6873. ??0?$_Wrap_alloc@V?$allocator@H@std@@@std@@QAE@XZ ENDP  ; std::_Wrap_alloc<std::allocator<int> >::_Wrap_alloc<std::allocator<int> >
  6874. _TEXT   ENDS
  6875. ; Function compile flags: /Ogtp
  6876. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  6877. ;       COMDAT ?_Unused_capacity@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ
  6878. _TEXT   SEGMENT
  6879. ?_Unused_capacity@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ PROC ; std::vector<double,std::allocator<double> >::_Unused_capacity, COMDAT
  6880. ; _this$ = ecx
  6881.  
  6882. ; 972  :                return (this->_Myend - this->_Mylast);
  6883.  
  6884.         mov     eax, DWORD PTR [ecx+8]
  6885.         sub     eax, DWORD PTR [ecx+4]
  6886.         sar     eax, 3
  6887.  
  6888. ; 973  :                }
  6889.  
  6890.         ret     0
  6891. ?_Unused_capacity@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ ENDP ; std::vector<double,std::allocator<double> >::_Unused_capacity
  6892. _TEXT   ENDS
  6893. ; Function compile flags: /Ogtp
  6894. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  6895. ;       COMDAT ?_Make_iter@?$vector@NV?$allocator@N@std@@@std@@QBE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@V?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@@Z
  6896. _TEXT   SEGMENT
  6897. ___$ReturnUdt$ = 8                                      ; size = 4
  6898. __Where$ = 12                                           ; size = 4
  6899. ?_Make_iter@?$vector@NV?$allocator@N@std@@@std@@QBE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@V?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@@Z PROC ; std::vector<double,std::allocator<double> >::_Make_iter, COMDAT
  6900. ; _this$dead$ = ecx
  6901.  
  6902. ; 1001 :                {       // make iterator from const_iterator
  6903.  
  6904.         push    ebp
  6905.         mov     ebp, esp
  6906.  
  6907. ; 47   :                {       // construct with pointer _Parg
  6908.  
  6909.         mov     eax, DWORD PTR ___$ReturnUdt$[ebp]
  6910.         mov     ecx, DWORD PTR __Where$[ebp]
  6911.         mov     DWORD PTR [eax], ecx
  6912.  
  6913. ; 1002 :                return (iterator(_Where._Ptr, this));
  6914. ; 1003 :                }
  6915.  
  6916.         pop     ebp
  6917.         ret     8
  6918. ?_Make_iter@?$vector@NV?$allocator@N@std@@@std@@QBE?AV?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@V?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@2@@Z ENDP ; std::vector<double,std::allocator<double> >::_Make_iter
  6919. _TEXT   ENDS
  6920. ; Function compile flags: /Ogtp
  6921. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  6922. ;       COMDAT ?max_size@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ
  6923. _TEXT   SEGMENT
  6924. ?max_size@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ PROC ; std::vector<double,std::allocator<double> >::max_size, COMDAT
  6925. ; _this$dead$ = ecx
  6926.  
  6927. ; 1092 :                return (this->_Getal().max_size());
  6928.  
  6929.         mov     eax, 536870911                          ; 1fffffffH
  6930.  
  6931. ; 1093 :                }
  6932.  
  6933.         ret     0
  6934. ?max_size@?$vector@NV?$allocator@N@std@@@std@@QBEIXZ ENDP ; std::vector<double,std::allocator<double> >::max_size
  6935. _TEXT   ENDS
  6936. ; Function compile flags: /Ogtp
  6937. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  6938. ;       COMDAT ?clear@?$vector@NV?$allocator@N@std@@@std@@QAEXXZ
  6939. _TEXT   SEGMENT
  6940. ?clear@?$vector@NV?$allocator@N@std@@@std@@QAEXXZ PROC  ; std::vector<double,std::allocator<double> >::clear, COMDAT
  6941. ; _this$ = ecx
  6942.  
  6943. ; 1414 :                this->_Orphan_all();
  6944. ; 1415 :                _Destroy(this->_Myfirst, this->_Mylast);
  6945. ; 1416 :                this->_Mylast = this->_Myfirst;
  6946.  
  6947.         mov     eax, DWORD PTR [ecx]
  6948.         mov     DWORD PTR [ecx+4], eax
  6949.  
  6950. ; 1417 :                }
  6951.  
  6952.         ret     0
  6953. ?clear@?$vector@NV?$allocator@N@std@@@std@@QAEXXZ ENDP  ; std::vector<double,std::allocator<double> >::clear
  6954. _TEXT   ENDS
  6955. ; Function compile flags: /Ogtp
  6956. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  6957. ;       COMDAT ?_Grow_to@?$vector@NV?$allocator@N@std@@@std@@IBEII@Z
  6958. _TEXT   SEGMENT
  6959. __Count$ = 8                                            ; size = 4
  6960. ?_Grow_to@?$vector@NV?$allocator@N@std@@@std@@IBEII@Z PROC ; std::vector<double,std::allocator<double> >::_Grow_to, COMDAT
  6961. ; _this$ = ecx
  6962.  
  6963. ; 1484 :                {       // grow by 50% or at least to _Count
  6964.  
  6965.         push    ebp
  6966.         mov     ebp, esp
  6967.  
  6968. ; 967  :                return (this->_Myend - this->_Myfirst);
  6969.  
  6970.         mov     edx, DWORD PTR [ecx+8]
  6971.         sub     edx, DWORD PTR [ecx]
  6972.  
  6973. ; 1485 :                size_type _Capacity = capacity();
  6974. ; 1486 :
  6975. ; 1487 :                _Capacity = max_size() - _Capacity / 2 < _Capacity
  6976. ; 1488 :                        ? 0 : _Capacity + _Capacity / 2;        // try to grow by 50%
  6977.  
  6978.         mov     eax, 536870911                          ; 1fffffffH
  6979.  
  6980. ; 967  :                return (this->_Myend - this->_Myfirst);
  6981.  
  6982.         sar     edx, 3
  6983.  
  6984. ; 1485 :                size_type _Capacity = capacity();
  6985. ; 1486 :
  6986. ; 1487 :                _Capacity = max_size() - _Capacity / 2 < _Capacity
  6987. ; 1488 :                        ? 0 : _Capacity + _Capacity / 2;        // try to grow by 50%
  6988.  
  6989.         mov     ecx, edx
  6990.         shr     ecx, 1
  6991.         sub     eax, ecx
  6992.         cmp     eax, edx
  6993.         jae     SHORT $LN4@Grow_to
  6994.         xor     edx, edx
  6995.  
  6996. ; 1489 :                if (_Capacity < _Count)
  6997.  
  6998.         cmp     edx, DWORD PTR __Count$[ebp]
  6999.         cmovb   edx, DWORD PTR __Count$[ebp]
  7000.  
  7001. ; 1490 :                        _Capacity = _Count;
  7002. ; 1491 :                return (_Capacity);
  7003.  
  7004.         mov     eax, edx
  7005.  
  7006. ; 1492 :                }
  7007.  
  7008.         pop     ebp
  7009.         ret     4
  7010. $LN4@Grow_to:
  7011.  
  7012. ; 1485 :                size_type _Capacity = capacity();
  7013. ; 1486 :
  7014. ; 1487 :                _Capacity = max_size() - _Capacity / 2 < _Capacity
  7015. ; 1488 :                        ? 0 : _Capacity + _Capacity / 2;        // try to grow by 50%
  7016.  
  7017.         add     edx, ecx
  7018.  
  7019. ; 1489 :                if (_Capacity < _Count)
  7020.  
  7021.         cmp     edx, DWORD PTR __Count$[ebp]
  7022.         cmovb   edx, DWORD PTR __Count$[ebp]
  7023.  
  7024. ; 1490 :                        _Capacity = _Count;
  7025. ; 1491 :                return (_Capacity);
  7026.  
  7027.         mov     eax, edx
  7028.  
  7029. ; 1492 :                }
  7030.  
  7031.         pop     ebp
  7032.         ret     4
  7033. ?_Grow_to@?$vector@NV?$allocator@N@std@@@std@@IBEII@Z ENDP ; std::vector<double,std::allocator<double> >::_Grow_to
  7034. _TEXT   ENDS
  7035. ; Function compile flags: /Ogtp
  7036. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7037. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7038. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7039. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7040. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7041. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory
  7042. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7043. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory
  7044. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7045. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7046. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7047. ;       COMDAT ?_Reallocate@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z
  7048. _TEXT   SEGMENT
  7049. __Size$1$ = 8                                           ; size = 4
  7050. __Count$ = 8                                            ; size = 4
  7051. ?_Reallocate@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z PROC ; std::vector<double,std::allocator<double> >::_Reallocate, COMDAT
  7052. ; _this$ = ecx
  7053.  
  7054. ; 1500 :                {       // move to array of exactly _Count elements
  7055.  
  7056.         push    ebp
  7057.         mov     ebp, esp
  7058.         push    ebx
  7059. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7060.  
  7061. ; 25   :        if (_Count == 0)
  7062.  
  7063.         mov     ebx, DWORD PTR __Count$[ebp]
  7064.         push    esi
  7065.  
  7066. ; 23   :        void *_Ptr = 0;
  7067.  
  7068.         xor     esi, esi
  7069.         push    edi
  7070. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7071.  
  7072. ; 1500 :                {       // move to array of exactly _Count elements
  7073.  
  7074.         mov     edi, ecx
  7075. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7076.  
  7077. ; 25   :        if (_Count == 0)
  7078.  
  7079.         test    ebx, ebx
  7080.         je      SHORT $LN16@Reallocate
  7081.  
  7082. ; 26   :                ;
  7083. ; 27   :        else if (((size_t)(-1) / sizeof (_Ty) < _Count)
  7084. ; 28   :                || (_Ptr = ::operator new(_Count * sizeof (_Ty))) == 0)
  7085.  
  7086.         cmp     ebx, 536870911                          ; 1fffffffH
  7087.         ja      SHORT $LN15@Reallocate
  7088.         lea     eax, DWORD PTR [ebx*8]
  7089.         push    eax
  7090.         call    DWORD PTR __imp_??2@YAPAXI@Z
  7091.         mov     esi, eax
  7092.         add     esp, 4
  7093.         test    esi, esi
  7094.         jne     SHORT $LN16@Reallocate
  7095. $LN15@Reallocate:
  7096.  
  7097. ; 29   :                _Xbad_alloc();  // report no memory
  7098.  
  7099.         call    DWORD PTR __imp_?_Xbad_alloc@std@@YAXXZ
  7100. $LN52@Reallocate:
  7101. $LN16@Reallocate:
  7102. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7103.  
  7104. ; 1504 :                _Umove(this->_Myfirst, this->_Mylast, _Ptr);
  7105.  
  7106.         mov     ecx, DWORD PTR [edi]
  7107. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory
  7108.  
  7109. ; 461  :        size_t _Count = (size_t)(_Last - _First);
  7110.  
  7111.         mov     eax, DWORD PTR [edi+4]
  7112.         sub     eax, ecx
  7113.  
  7114. ; 463  :                _Count * sizeof (*_First)) + _Count);   // NB: non-overlapping move
  7115.  
  7116.         and     eax, -8                                 ; fffffff8H
  7117.         push    eax
  7118.         push    ecx
  7119.         push    esi
  7120.         call    DWORD PTR __imp__memmove
  7121. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7122.  
  7123. ; 1087 :                return (this->_Mylast - this->_Myfirst);
  7124.  
  7125.         mov     ecx, DWORD PTR [edi]
  7126.         mov     eax, DWORD PTR [edi+4]
  7127.         sub     eax, ecx
  7128.         sar     eax, 3
  7129. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory
  7130.  
  7131. ; 463  :                _Count * sizeof (*_First)) + _Count);   // NB: non-overlapping move
  7132.  
  7133.         add     esp, 12                                 ; 0000000cH
  7134. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7135.  
  7136. ; 1087 :                return (this->_Mylast - this->_Myfirst);
  7137.  
  7138.         mov     DWORD PTR __Size$1$[ebp], eax
  7139.  
  7140. ; 1505 :                _CATCH_ALL
  7141. ; 1506 :                this->_Getal().deallocate(_Ptr, _Count);
  7142. ; 1507 :                _RERAISE;
  7143. ; 1508 :                _CATCH_END
  7144. ; 1509 :
  7145. ; 1510 :                size_type _Size = size();
  7146. ; 1511 :                if (this->_Myfirst != pointer())
  7147.  
  7148.         test    ecx, ecx
  7149.         je      SHORT $LN46@Reallocate
  7150. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7151.  
  7152. ; 586  :                ::operator delete(_Ptr);
  7153.  
  7154.         push    ecx
  7155.         call    DWORD PTR __imp_??3@YAXPAX@Z
  7156.         add     esp, 4
  7157. $LN46@Reallocate:
  7158. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7159.  
  7160. ; 1519 :                this->_Myend = _Ptr + _Count;
  7161.  
  7162.         lea     eax, DWORD PTR [esi+ebx*8]
  7163.         mov     DWORD PTR [edi+8], eax
  7164.  
  7165. ; 1520 :                this->_Mylast = _Ptr + _Size;
  7166.  
  7167.         mov     eax, DWORD PTR __Size$1$[ebp]
  7168.  
  7169. ; 1521 :                this->_Myfirst = _Ptr;
  7170.  
  7171.         mov     DWORD PTR [edi], esi
  7172.         lea     eax, DWORD PTR [esi+eax*8]
  7173.         mov     DWORD PTR [edi+4], eax
  7174.         pop     edi
  7175.         pop     esi
  7176.         pop     ebx
  7177.  
  7178. ; 1522 :                }
  7179.  
  7180.         pop     ebp
  7181.         ret     4
  7182. $LN51@Reallocate:
  7183. ?_Reallocate@?$vector@NV?$allocator@N@std@@@std@@IAEXI@Z ENDP ; std::vector<double,std::allocator<double> >::_Reallocate
  7184. _TEXT   ENDS
  7185. ; Function compile flags: /Ogtp
  7186. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7187. ;       COMDAT ?_Xlen@?$vector@NV?$allocator@N@std@@@std@@IBEXXZ
  7188. _TEXT   SEGMENT
  7189. ?_Xlen@?$vector@NV?$allocator@N@std@@@std@@IBEXXZ PROC  ; std::vector<double,std::allocator<double> >::_Xlen, COMDAT
  7190. ; _this$dead$ = ecx
  7191.  
  7192. ; 1667 :                _Xlength_error("vector<T> too long");
  7193.  
  7194.         push    OFFSET ??_C@_0BD@OLBABOEK@vector?$DMT?$DO?5too?5long?$AA@
  7195.         call    DWORD PTR __imp_?_Xlength_error@std@@YAXPBD@Z
  7196. $LN4@Xlen:
  7197. $LN3@Xlen:
  7198.         int     3
  7199. ?_Xlen@?$vector@NV?$allocator@N@std@@@std@@IBEXXZ ENDP  ; std::vector<double,std::allocator<double> >::_Xlen
  7200. _TEXT   ENDS
  7201. ; Function compile flags: /Ogtp
  7202. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7203. ;       COMDAT ?deallocate@?$allocator@N@std@@QAEXPANI@Z
  7204. _TEXT   SEGMENT
  7205. __Ptr$ = 8                                              ; size = 4
  7206. ___formal$dead$ = 12                                    ; size = 4
  7207. ?deallocate@?$allocator@N@std@@QAEXPANI@Z PROC          ; std::allocator<double>::deallocate, COMDAT
  7208. ; _this$dead$ = ecx
  7209.  
  7210. ; 585  :                {       // deallocate object at _Ptr, ignore size
  7211.  
  7212.         push    ebp
  7213.         mov     ebp, esp
  7214.  
  7215. ; 586  :                ::operator delete(_Ptr);
  7216.  
  7217.         push    DWORD PTR __Ptr$[ebp]
  7218.         call    DWORD PTR __imp_??3@YAXPAX@Z
  7219.         add     esp, 4
  7220.  
  7221. ; 587  :                }
  7222.  
  7223.         pop     ebp
  7224.         ret     8
  7225. ?deallocate@?$allocator@N@std@@QAEXPANI@Z ENDP          ; std::allocator<double>::deallocate
  7226. _TEXT   ENDS
  7227. ; Function compile flags: /Ogtp
  7228. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xmemory0
  7229. ;       COMDAT ??0?$_Wrap_alloc@V?$allocator@N@std@@@std@@QAE@XZ
  7230. _TEXT   SEGMENT
  7231. ??0?$_Wrap_alloc@V?$allocator@N@std@@@std@@QAE@XZ PROC  ; std::_Wrap_alloc<std::allocator<double> >::_Wrap_alloc<std::allocator<double> >, COMDAT
  7232. ; _this$ = ecx
  7233.  
  7234. ; 831  :                }
  7235.  
  7236.         mov     eax, ecx
  7237.         ret     0
  7238. ??0?$_Wrap_alloc@V?$allocator@N@std@@@std@@QAE@XZ ENDP  ; std::_Wrap_alloc<std::allocator<double> >::_Wrap_alloc<std::allocator<double> >
  7239. _TEXT   ENDS
  7240. ; Function compile flags: /Ogtp
  7241. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7242. ;       COMDAT ??0?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QAE@PANPBU_Container_base0@1@@Z
  7243. _TEXT   SEGMENT
  7244. __Parg$ = 8                                             ; size = 4
  7245. __Pvector$dead$ = 12                                    ; size = 4
  7246. ??0?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QAE@PANPBU_Container_base0@1@@Z PROC ; std::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >, COMDAT
  7247. ; _this$ = ecx
  7248.  
  7249. ; 306  :                {       // construct with pointer _Parg
  7250.  
  7251.         push    ebp
  7252.         mov     ebp, esp
  7253.  
  7254. ; 47   :                {       // construct with pointer _Parg
  7255.  
  7256.         mov     eax, DWORD PTR __Parg$[ebp]
  7257.         mov     DWORD PTR [ecx], eax
  7258.  
  7259. ; 307  :                }
  7260.  
  7261.         mov     eax, ecx
  7262.         pop     ebp
  7263.         ret     8
  7264. ??0?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QAE@PANPBU_Container_base0@1@@Z ENDP ; std::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >
  7265. _TEXT   ENDS
  7266. ; Function compile flags: /Ogtp
  7267. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7268. ;       COMDAT ??Y?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QAEAAV01@H@Z
  7269. _TEXT   SEGMENT
  7270. __Off$ = 8                                              ; size = 4
  7271. ??Y?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QAEAAV01@H@Z PROC ; std::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator+=, COMDAT
  7272. ; _this$ = ecx
  7273.  
  7274. ; 359  :                {       // increment by integer
  7275.  
  7276.         push    ebp
  7277.         mov     ebp, esp
  7278.  
  7279. ; 170  :                _Ptr += _Off;
  7280.  
  7281.         mov     eax, DWORD PTR __Off$[ebp]
  7282.         shl     eax, 3
  7283.         add     DWORD PTR [ecx], eax
  7284.  
  7285. ; 360  :                *(_Mybase *)this += _Off;
  7286. ; 361  :                return (*this);
  7287.  
  7288.         mov     eax, ecx
  7289.  
  7290. ; 362  :                }
  7291.  
  7292.         pop     ebp
  7293.         ret     4
  7294. ??Y?$_Vector_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QAEAAV01@H@Z ENDP ; std::_Vector_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator+=
  7295. _TEXT   ENDS
  7296. ; Function compile flags: /Ogtp
  7297. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7298. ;       COMDAT ??8?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE_NABV01@@Z
  7299. _TEXT   SEGMENT
  7300. __Right$ = 8                                            ; size = 4
  7301. ??8?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE_NABV01@@Z PROC ; std::_Vector_const_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator==, COMDAT
  7302. ; _this$ = ecx
  7303.  
  7304. ; 203  :                {       // test for iterator equality
  7305.  
  7306.         push    ebp
  7307.         mov     ebp, esp
  7308.  
  7309. ; 204  :                _Compat(_Right);
  7310. ; 205  :                return (this->_Ptr == _Right._Ptr);
  7311.  
  7312.         mov     edx, DWORD PTR [ecx]
  7313.         mov     ecx, DWORD PTR __Right$[ebp]
  7314.         xor     eax, eax
  7315.         cmp     edx, DWORD PTR [ecx]
  7316.         sete    al
  7317.  
  7318. ; 206  :                }
  7319.  
  7320.         pop     ebp
  7321.         ret     4
  7322. ??8?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE_NABV01@@Z ENDP ; std::_Vector_const_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator==
  7323. _TEXT   ENDS
  7324. ; Function compile flags: /Ogtp
  7325. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\vector
  7326. ;       COMDAT ??9?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE_NABV01@@Z
  7327. _TEXT   SEGMENT
  7328. __Right$ = 8                                            ; size = 4
  7329. ??9?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE_NABV01@@Z PROC ; std::_Vector_const_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator!=, COMDAT
  7330. ; _this$ = ecx
  7331.  
  7332. ; 209  :                {       // test for iterator inequality
  7333.  
  7334.         push    ebp
  7335.         mov     ebp, esp
  7336.  
  7337. ; 205  :                return (this->_Ptr == _Right._Ptr);
  7338.  
  7339.         mov     edx, DWORD PTR [ecx]
  7340.         mov     ecx, DWORD PTR __Right$[ebp]
  7341.  
  7342. ; 210  :                return (!(*this == _Right));
  7343.  
  7344.         xor     eax, eax
  7345.  
  7346. ; 205  :                return (this->_Ptr == _Right._Ptr);
  7347.  
  7348.         cmp     edx, DWORD PTR [ecx]
  7349.  
  7350. ; 210  :                return (!(*this == _Right));
  7351.  
  7352.         setne   al
  7353.  
  7354. ; 211  :                }
  7355.  
  7356.         pop     ebp
  7357.         ret     4
  7358. ??9?$_Vector_const_iterator@V?$_Vector_val@U?$_Simple_types@N@std@@@std@@@std@@QBE_NABV01@@Z ENDP ; std::_Vector_const_iterator<std::_Vector_val<std::_Simple_types<double> > >::operator!=
  7359. _TEXT   ENDS
  7360. ; Function compile flags: /Ogtp
  7361. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  7362. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstddef
  7363. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  7364. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  7365. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\iosfwd
  7366. ; File c:\program files (x86)\microsoft visual studio 11.0\vc\include\xstring
  7367. ;       COMDAT ?erase@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@I@Z
  7368. _TEXT   SEGMENT
  7369. __Off$ = 8                                              ; size = 4
  7370. ?erase@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@I@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::erase, COMDAT
  7371. ; _this$ = ecx
  7372.  
  7373. ; 1309 :                {       // erase elements [_Off, ...)
  7374.  
  7375.         push    ebp
  7376.         mov     ebp, esp
  7377.  
  7378. ; 1310 :                if (this->_Mysize < _Off)
  7379.  
  7380.         mov     eax, DWORD PTR __Off$[ebp]
  7381.         cmp     DWORD PTR [ecx+16], eax
  7382.         jae     SHORT $LN1@erase
  7383.  
  7384. ; 2219 :                }
  7385. ; 2220 :
  7386. ; 2221 :        bool _Grow(size_type _Newsize,
  7387. ; 2222 :                bool _Trim = false)
  7388. ; 2223 :                {       // ensure buffer is big enough, trim to size if _Trim is true
  7389. ; 2224 :                if (max_size() < _Newsize)
  7390. ; 2225 :                        _Xlen();        // result too long
  7391. ; 2226 :                if (this->_Myres < _Newsize)
  7392. ; 2227 :                        _Copy(_Newsize, this->_Mysize); // reallocate to grow
  7393. ; 2228 :                else if (_Trim && _Newsize < this->_BUF_SIZE)
  7394. ; 2229 :                        _Tidy(true,     // copy and deallocate if trimming to small string
  7395. ; 2230 :                                _Newsize < this->_Mysize ? _Newsize : this->_Mysize);
  7396. ; 2231 :                else if (_Newsize == 0)
  7397. ; 2232 :                        _Eos(0);        // new size is zero, just null terminate
  7398. ; 2233 :                return (0 < _Newsize);  // return true only if more work to do
  7399. ; 2234 :                }
  7400. ; 2235 :
  7401. ; 2236 :        bool _Inside(const _Elem *_Ptr)
  7402. ; 2237 :                {       // test if _Ptr points inside string
  7403. ; 2238 :                if (_Ptr == 0 || _Ptr < this->_Myptr()
  7404. ; 2239 :                        || this->_Myptr() + this->_Mysize <= _Ptr)
  7405. ; 2240 :                        return (false); // don't ask
  7406. ; 2241 :                else
  7407. ; 2242 :                        return (true);
  7408. ; 2243 :                }
  7409. ; 2244 :
  7410. ; 2245 :        static size_type _Pdif(const_iterator _P2,
  7411. ; 2246 :                const_iterator _P1)
  7412. ; 2247 :                {       // compute safe iterator difference
  7413. ; 2248 :                return (_STRING_ITER_BASE(_P2) == 0 ? 0 : _P2 - _P1);
  7414. ; 2249 :                }
  7415. ; 2250 :
  7416. ; 2251 :        void _Tidy(bool _Built = false,
  7417. ; 2252 :                size_type _Newsize = 0)
  7418. ; 2253 :                {       // initialize buffer, deallocating any storage
  7419. ; 2254 :                if (!_Built)
  7420. ; 2255 :                        ;
  7421. ; 2256 :                else if (this->_BUF_SIZE <= this->_Myres)
  7422. ; 2257 :                        {       // copy any leftovers to small buffer and deallocate
  7423. ; 2258 :                        pointer _Ptr = this->_Bx._Ptr;
  7424. ; 2259 :                        this->_Getal().destroy(&this->_Bx._Ptr);
  7425. ; 2260 :                        if (0 < _Newsize)
  7426. ; 2261 :                                _Traits::copy(this->_Bx._Buf,
  7427. ; 2262 :                                        _STD addressof(*_Ptr), _Newsize);
  7428. ; 2263 :                        this->_Getal().deallocate(_Ptr, this->_Myres + 1);
  7429. ; 2264 :                        }
  7430. ; 2265 :                this->_Myres = this->_BUF_SIZE - 1;
  7431. ; 2266 :                _Eos(_Newsize);
  7432. ; 2267 :                }
  7433. ; 2268 :
  7434. ; 2269 :        __declspec(noreturn) void _Xlen() const
  7435. ; 2270 :                {       // report a length_error
  7436. ; 2271 :                _Xlength_error("string too long");
  7437. ; 2272 :                }
  7438. ; 2273 :
  7439. ; 2274 :        __declspec(noreturn) void _Xran() const
  7440. ; 2275 :                {       // report an out_of_range error
  7441. ; 2276 :                _Xout_of_range("invalid string position");
  7442.  
  7443.         push    OFFSET ??_C@_0BI@CFPLBAOH@invalid?5string?5position?$AA@
  7444.         call    DWORD PTR __imp_?_Xout_of_range@std@@YAXPBD@Z
  7445. $LN19@erase:
  7446. $LN1@erase:
  7447.  
  7448. ; 517  :                        : this->_Bx._Buf);
  7449.  
  7450.         cmp     DWORD PTR [ecx+20], 16                  ; 00000010H
  7451.  
  7452. ; 1315 :
  7453. ; 1316 :        _Myt& erase(size_type _Off, size_type _Count)
  7454. ; 1317 :                {       // erase elements [_Off, _Off + _Count)
  7455. ; 1318 :                if (this->_Mysize < _Off)
  7456. ; 1319 :                        _Xran();        // _Off off end
  7457. ; 1320 :                if (this->_Mysize - _Off <= _Count)
  7458. ; 1321 :                        _Eos(_Off);     // erase elements [_Off, ...)
  7459. ; 1322 :                else if (0 < _Count)
  7460. ; 1323 :                        {       // move elements down
  7461. ; 1324 :                        value_type *_Ptr = this->_Myptr() + _Off;
  7462. ; 1325 :                        size_type _Newsize = this->_Mysize - _Count;
  7463. ; 1326 :                        _Traits::move(_Ptr, _Ptr + _Count, _Newsize - _Off);
  7464. ; 1327 :                        _Eos(_Newsize);
  7465. ; 1328 :                        }
  7466. ; 1329 :                return (*this);
  7467. ; 1330 :                }
  7468. ; 1331 :
  7469. ; 1332 :        iterator erase(const_iterator _Where)
  7470. ; 1333 :                {       // erase element at _Where
  7471. ; 1334 :                size_type _Count = _Pdif(_Where, begin());
  7472. ; 1335 :                erase(_Count, 1);
  7473. ; 1336 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  7474. ; 1337 :                }
  7475. ; 1338 :
  7476. ; 1339 :        iterator erase(const_iterator _First, const_iterator _Last)
  7477. ; 1340 :                {       // erase substring [_First, _Last)
  7478. ; 1341 :                _DEBUG_RANGE(_First, _Last);
  7479. ; 1342 :                size_type _Count = _Pdif(_First, begin());
  7480. ; 1343 :                erase(_Count, _Pdif(_Last, _First));
  7481. ; 1344 :                return (_STRING_ITERATOR(this->_Myptr() + _Count));
  7482. ; 1345 :                }
  7483. ; 1346 :
  7484. ; 1347 :        void clear() _NOEXCEPT
  7485. ; 1348 :                {       // erase all
  7486. ; 1349 :                _Eos(0);
  7487. ; 1350 :                }
  7488. ; 1351 :
  7489. ; 1352 :        _Myt& replace(size_type _Off, size_type _N0, const _Myt& _Right)
  7490. ; 1353 :                {       // replace [_Off, _Off + _N0) with _Right
  7491. ; 1354 :                return (replace(_Off, _N0, _Right, 0, npos));
  7492. ; 1355 :                }
  7493. ; 1356 :
  7494. ; 1357 :        _Myt& replace(size_type _Off,
  7495. ; 1358 :                size_type _N0, const _Myt& _Right, size_type _Roff, size_type _Count)
  7496. ; 1359 :                {       // replace [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
  7497. ; 1360 :                if (this->_Mysize < _Off || _Right.size() < _Roff)
  7498. ; 1361 :                        _Xran();        // _Off or _Roff off end
  7499. ; 1362 :                if (this->_Mysize - _Off < _N0)
  7500. ; 1363 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  7501. ; 1364 :                size_type _Num = _Right.size() - _Roff;
  7502. ; 1365 :                if (_Num < _Count)
  7503. ; 1366 :                        _Count = _Num;  // trim _Count to size
  7504. ; 1367 :                if (npos - _Count <= this->_Mysize - _N0)
  7505. ; 1368 :                        _Xlen();        // result too long
  7506. ; 1369 :
  7507. ; 1370 :                size_type _Nm = this->_Mysize - _N0 - _Off;     // length of kept tail
  7508. ; 1371 :                size_type _Newsize = this->_Mysize + _Count - _N0;
  7509. ; 1372 :                if (this->_Mysize < _Newsize)
  7510. ; 1373 :                        _Grow(_Newsize);
  7511. ; 1374 :
  7512. ; 1375 :                if (this != &_Right)
  7513. ; 1376 :                        {       // no overlap, just move down and copy in new stuff
  7514. ; 1377 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  7515. ; 1378 :                                this->_Myptr() + _Off + _N0, _Nm);      // empty hole
  7516. ; 1379 :                        _Traits::copy(this->_Myptr() + _Off,
  7517. ; 1380 :                                _Right._Myptr() + _Roff, _Count);       // fill hole
  7518. ; 1381 :                        }
  7519. ; 1382 :                else if (_Count <= _N0)
  7520. ; 1383 :                        {       // hole doesn't get larger, just copy in substring
  7521. ; 1384 :                        _Traits::move(this->_Myptr() + _Off,
  7522. ; 1385 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  7523. ; 1386 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  7524. ; 1387 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  7525. ; 1388 :                        }
  7526. ; 1389 :                else if (_Roff <= _Off)
  7527. ; 1390 :                        {       // hole gets larger, substring begins before hole
  7528. ; 1391 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  7529. ; 1392 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  7530. ; 1393 :                        _Traits::move(this->_Myptr() + _Off,
  7531. ; 1394 :                                this->_Myptr() + _Roff, _Count);        // fill hole
  7532. ; 1395 :                        }
  7533. ; 1396 :                else if (_Off + _N0 <= _Roff)
  7534. ; 1397 :                        {       // hole gets larger, substring begins after hole
  7535. ; 1398 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  7536. ; 1399 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  7537. ; 1400 :                        _Traits::move(this->_Myptr() + _Off,
  7538. ; 1401 :                                this->_Myptr() + (_Roff + _Count - _N0),
  7539. ; 1402 :                                _Count);        // fill hole
  7540. ; 1403 :                        }
  7541. ; 1404 :                else
  7542. ; 1405 :                        {       // hole gets larger, substring begins in hole
  7543. ; 1406 :                        _Traits::move(this->_Myptr() + _Off,
  7544. ; 1407 :                                this->_Myptr() + _Roff, _N0);   // fill old hole
  7545. ; 1408 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  7546. ; 1409 :                                this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  7547. ; 1410 :                        _Traits::move(this->_Myptr() + _Off + _N0,
  7548. ; 1411 :                                this->_Myptr() + _Roff + _Count,
  7549. ; 1412 :                                _Count - _N0);  // fill rest of new hole
  7550. ; 1413 :                        }
  7551. ; 1414 :
  7552. ; 1415 :                _Eos(_Newsize);
  7553. ; 1416 :                return (*this);
  7554. ; 1417 :                }
  7555. ; 1418 :
  7556. ; 1419 :        _Myt& replace(size_type _Off,
  7557. ; 1420 :                size_type _N0, const _Elem *_Ptr, size_type _Count)
  7558. ; 1421 :                {       // replace [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
  7559. ; 1422 :  #if _ITERATOR_DEBUG_LEVEL == 2
  7560. ; 1423 :                if (_Count != 0)
  7561. ; 1424 :                        _DEBUG_POINTER(_Ptr);
  7562. ; 1425 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  7563. ; 1426 :
  7564. ; 1427 :                if (_Inside(_Ptr))
  7565. ; 1428 :                        return (replace(_Off, _N0, *this,
  7566. ; 1429 :                                _Ptr - this->_Myptr(),
  7567. ; 1430 :                                _Count));       // substring, replace carefully
  7568. ; 1431 :                if (this->_Mysize < _Off)
  7569. ; 1432 :                        _Xran();        // _Off off end
  7570. ; 1433 :                if (this->_Mysize - _Off < _N0)
  7571. ; 1434 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  7572. ; 1435 :                if (npos - _Count <= this->_Mysize - _N0)
  7573. ; 1436 :                        _Xlen();        // result too long
  7574. ; 1437 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  7575. ; 1438 :
  7576. ; 1439 :                if (_Count < _N0)
  7577. ; 1440 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  7578. ; 1441 :                                this->_Myptr() + _Off + _N0,
  7579. ; 1442 :                                _Nm);   // smaller hole, move tail up
  7580. ; 1443 :                size_type _Num;
  7581. ; 1444 :                if ((0 < _Count || 0 < _N0)
  7582. ; 1445 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  7583. ; 1446 :                        {       // make room and rearrange
  7584. ; 1447 :                        if (_N0 < _Count)
  7585. ; 1448 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  7586. ; 1449 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  7587. ; 1450 :                        _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count);     // fill hole
  7588. ; 1451 :                        _Eos(_Num);
  7589. ; 1452 :                        }
  7590. ; 1453 :                return (*this);
  7591. ; 1454 :                }
  7592. ; 1455 :
  7593. ; 1456 :        _Myt& replace(size_type _Off, size_type _N0, const _Elem *_Ptr)
  7594. ; 1457 :                {       // replace [_Off, _Off + _N0) with [_Ptr, <null>)
  7595. ; 1458 :                _DEBUG_POINTER(_Ptr);
  7596. ; 1459 :                return (replace(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
  7597. ; 1460 :                }
  7598. ; 1461 :
  7599. ; 1462 :        _Myt& replace(size_type _Off,
  7600. ; 1463 :                size_type _N0, size_type _Count, _Elem _Ch)
  7601. ; 1464 :                {       // replace [_Off, _Off + _N0) with _Count * _Ch
  7602. ; 1465 :                if (this->_Mysize < _Off)
  7603. ; 1466 :                        _Xran();        // _Off off end
  7604. ; 1467 :                if (this->_Mysize - _Off < _N0)
  7605. ; 1468 :                        _N0 = this->_Mysize - _Off;     // trim _N0 to size
  7606. ; 1469 :                if (npos - _Count <= this->_Mysize - _N0)
  7607. ; 1470 :                        _Xlen();        // result too long
  7608. ; 1471 :                size_type _Nm = this->_Mysize - _N0 - _Off;
  7609. ; 1472 :
  7610. ; 1473 :                if (_Count < _N0)
  7611. ; 1474 :                        _Traits::move(this->_Myptr() + _Off + _Count,
  7612. ; 1475 :                                this->_Myptr() + _Off + _N0,
  7613. ; 1476 :                                _Nm);   // smaller hole, move tail up
  7614. ; 1477 :                size_type _Num;
  7615. ; 1478 :                if ((0 < _Count || 0 < _N0)
  7616. ; 1479 :                        && _Grow(_Num = this->_Mysize + _Count - _N0))
  7617. ; 1480 :                        {       // make room and rearrange
  7618. ; 1481 :                        if (_N0 < _Count)
  7619. ; 1482 :                                _Traits::move(this->_Myptr() + _Off + _Count,
  7620. ; 1483 :                                        this->_Myptr() + _Off + _N0, _Nm);      // move tail down
  7621. ; 1484 :                        _Chassign(_Off, _Count, _Ch);   // fill hole
  7622. ; 1485 :                        _Eos(_Num);
  7623. ; 1486 :                        }
  7624. ; 1487 :                return (*this);
  7625. ; 1488 :                }
  7626. ; 1489 :
  7627. ; 1490 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7628. ; 1491 :                const _Myt& _Right)
  7629. ; 1492 :                {       // replace [_First, _Last) with _Right
  7630. ; 1493 :                return (replace(
  7631. ; 1494 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Right));
  7632. ; 1495 :                }
  7633. ; 1496 :
  7634. ; 1497 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7635. ; 1498 :                const _Elem *_Ptr, size_type _Count)
  7636. ; 1499 :                {       // replace [_First, _Last) with [_Ptr, _Ptr + _Count)
  7637. ; 1500 :                return (replace(
  7638. ; 1501 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr, _Count));
  7639. ; 1502 :                }
  7640. ; 1503 :
  7641. ; 1504 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7642. ; 1505 :                const _Elem *_Ptr)
  7643. ; 1506 :                {       // replace [_First, _Last) with [_Ptr, <null>)
  7644. ; 1507 :                return (replace(
  7645. ; 1508 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Ptr));
  7646. ; 1509 :                }
  7647. ; 1510 :
  7648. ; 1511 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7649. ; 1512 :                size_type _Count, _Elem _Ch)
  7650. ; 1513 :                {       // replace [_First, _Last) with _Count * _Ch
  7651. ; 1514 :                return (replace(
  7652. ; 1515 :                        _Pdif(_First, begin()), _Pdif(_Last, _First), _Count, _Ch));
  7653. ; 1516 :                }
  7654. ; 1517 :
  7655. ; 1518 :        template<class _Iter>
  7656. ; 1519 :                typename enable_if<_Is_iterator<_Iter>::value,
  7657. ; 1520 :                        _Myt&>::type
  7658. ; 1521 :                replace(const_iterator _First, const_iterator _Last,
  7659. ; 1522 :                        _Iter _First2, _Iter _Last2)
  7660. ; 1523 :                {       // replace [_First, _Last) with [_First2, _Last2), input iterators
  7661. ; 1524 :                _Myt _Right(_First2, _Last2);
  7662. ; 1525 :                replace(_First, _Last, _Right);
  7663. ; 1526 :                return (*this);
  7664. ; 1527 :                }
  7665. ; 1528 :
  7666. ; 1529 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7667. ; 1530 :                const_pointer _First2, const_pointer _Last2)
  7668. ; 1531 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  7669. ; 1532 :                if (_First2 == _Last2)
  7670. ; 1533 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  7671. ; 1534 :                else
  7672. ; 1535 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  7673. ; 1536 :                                &*_First2, _Last2 - _First2);
  7674. ; 1537 :                return (*this);
  7675. ; 1538 :                }
  7676. ; 1539 :
  7677. ; 1540 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7678. ; 1541 :                pointer _First2, pointer _Last2)
  7679. ; 1542 :                {       // replace [_First, _Last) with [_First2, _Last2), const pointers
  7680. ; 1543 :                if (_First2 == _Last2)
  7681. ; 1544 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  7682. ; 1545 :                else
  7683. ; 1546 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  7684. ; 1547 :                                &*_First2, _Last2 - _First2);
  7685. ; 1548 :                return (*this);
  7686. ; 1549 :                }
  7687. ; 1550 :
  7688. ; 1551 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7689. ; 1552 :                const_iterator _First2, const_iterator _Last2)
  7690. ; 1553 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  7691. ; 1554 :                if (_First2 == _Last2)
  7692. ; 1555 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  7693. ; 1556 :                else
  7694. ; 1557 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  7695. ; 1558 :                                &*_First2, _Last2 - _First2);
  7696. ; 1559 :                return (*this);
  7697. ; 1560 :                }
  7698. ; 1561 :
  7699. ; 1562 :        _Myt& replace(const_iterator _First, const_iterator _Last,
  7700. ; 1563 :                iterator _First2, iterator _Last2)
  7701. ; 1564 :                {       // replace [_First, _Last) with [_First2, _Last2), const_iterators
  7702. ; 1565 :                if (_First2 == _Last2)
  7703. ; 1566 :                        erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
  7704. ; 1567 :                else
  7705. ; 1568 :                        replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
  7706. ; 1569 :                                &*_First2, _Last2 - _First2);
  7707. ; 1570 :                return (*this);
  7708. ; 1571 :                }
  7709. ; 1572 :
  7710. ; 1573 :        iterator begin() _NOEXCEPT
  7711. ; 1574 :                {       // return iterator for beginning of mutable sequence
  7712. ; 1575 :                return (_STRING_ITERATOR(this->_Myptr()));
  7713. ; 1576 :                }
  7714. ; 1577 :
  7715. ; 1578 :        const_iterator begin() const _NOEXCEPT
  7716. ; 1579 :                {       // return iterator for beginning of nonmutable sequence
  7717. ; 1580 :                return (_STRING_CONST_ITERATOR(this->_Myptr()));
  7718. ; 1581 :                }
  7719. ; 1582 :
  7720. ; 1583 :        iterator end() _NOEXCEPT
  7721. ; 1584 :                {       // return iterator for end of mutable sequence
  7722. ; 1585 :                return (_STRING_ITERATOR(this->_Myptr() + this->_Mysize));
  7723. ; 1586 :                }
  7724. ; 1587 :
  7725. ; 1588 :        const_iterator end() const _NOEXCEPT
  7726. ; 1589 :                {       // return iterator for end of nonmutable sequence
  7727. ; 1590 :                return (_STRING_CONST_ITERATOR(this->_Myptr() + this->_Mysize));
  7728. ; 1591 :                }
  7729. ; 1592 :
  7730. ; 1593 :        reverse_iterator rbegin() _NOEXCEPT
  7731. ; 1594 :                {       // return iterator for beginning of reversed mutable sequence
  7732. ; 1595 :                return (reverse_iterator(end()));
  7733. ; 1596 :                }
  7734. ; 1597 :
  7735. ; 1598 :        const_reverse_iterator rbegin() const _NOEXCEPT
  7736. ; 1599 :                {       // return iterator for beginning of reversed nonmutable sequence
  7737. ; 1600 :                return (const_reverse_iterator(end()));
  7738. ; 1601 :                }
  7739. ; 1602 :
  7740. ; 1603 :        reverse_iterator rend() _NOEXCEPT
  7741. ; 1604 :                {       // return iterator for end of reversed mutable sequence
  7742. ; 1605 :                return (reverse_iterator(begin()));
  7743. ; 1606 :                }
  7744. ; 1607 :
  7745. ; 1608 :        const_reverse_iterator rend() const _NOEXCEPT
  7746. ; 1609 :                {       // return iterator for end of reversed nonmutable sequence
  7747. ; 1610 :                return (const_reverse_iterator(begin()));
  7748. ; 1611 :                }
  7749. ; 1612 :
  7750. ; 1613 :  #if _HAS_CPP0X
  7751. ; 1614 :        const_iterator cbegin() const _NOEXCEPT
  7752. ; 1615 :                {       // return iterator for beginning of nonmutable sequence
  7753. ; 1616 :                return (((const _Myt *)this)->begin());
  7754. ; 1617 :                }
  7755. ; 1618 :
  7756. ; 1619 :        const_iterator cend() const _NOEXCEPT
  7757. ; 1620 :                {       // return iterator for end of nonmutable sequence
  7758. ; 1621 :                return (((const _Myt *)this)->end());
  7759. ; 1622 :                }
  7760. ; 1623 :
  7761. ; 1624 :        const_reverse_iterator crbegin() const _NOEXCEPT
  7762. ; 1625 :                {       // return iterator for beginning of reversed nonmutable sequence
  7763. ; 1626 :                return (((const _Myt *)this)->rbegin());
  7764. ; 1627 :                }
  7765. ; 1628 :
  7766. ; 1629 :        const_reverse_iterator crend() const _NOEXCEPT
  7767. ; 1630 :                {       // return iterator for end of reversed nonmutable sequence
  7768. ; 1631 :                return (((const _Myt *)this)->rend());
  7769. ; 1632 :                }
  7770. ; 1633 :
  7771. ; 1634 :        void shrink_to_fit()
  7772. ; 1635 :                {       // reduce capacity
  7773. ; 1636 :                if ((size() | this->_ALLOC_MASK) < capacity())
  7774. ; 1637 :                        {       // worth shrinking, do it
  7775. ; 1638 :                        _Myt _Tmp(*this);
  7776. ; 1639 :                        swap(_Tmp);
  7777. ; 1640 :                        }
  7778. ; 1641 :                }
  7779. ; 1642 :  #endif /* _HAS_CPP0X */
  7780. ; 1643 :
  7781. ; 1644 :        reference at(size_type _Off)
  7782. ; 1645 :                {       // subscript mutable sequence with checking
  7783. ; 1646 :                if (this->_Mysize <= _Off)
  7784. ; 1647 :                        _Xran();        // _Off off end
  7785. ; 1648 :                return (this->_Myptr()[_Off]);
  7786. ; 1649 :                }
  7787. ; 1650 :
  7788. ; 1651 :        const_reference at(size_type _Off) const
  7789. ; 1652 :                {       // subscript nonmutable sequence with checking
  7790. ; 1653 :                if (this->_Mysize <= _Off)
  7791. ; 1654 :                        _Xran();        // _Off off end
  7792. ; 1655 :                return (this->_Myptr()[_Off]);
  7793. ; 1656 :                }
  7794. ; 1657 :
  7795. ; 1658 :        reference operator[](size_type _Off)
  7796. ; 1659 :                {       // subscript mutable sequence
  7797. ; 1660 :  #if _ITERATOR_DEBUG_LEVEL == 2
  7798. ; 1661 :                if (this->_Mysize < _Off)       // sic
  7799. ; 1662 :                        _DEBUG_ERROR("string subscript out of range");
  7800. ; 1663 :
  7801. ; 1664 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  7802. ; 1665 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  7803. ; 1666 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  7804. ; 1667 :
  7805. ; 1668 :                return (this->_Myptr()[_Off]);
  7806. ; 1669 :                }
  7807. ; 1670 :
  7808. ; 1671 :        const_reference operator[](size_type _Off) const
  7809. ; 1672 :                {       // subscript nonmutable sequence
  7810. ; 1673 :  #if _ITERATOR_DEBUG_LEVEL == 2
  7811. ; 1674 :                if (this->_Mysize < _Off)       // sic
  7812. ; 1675 :                        _DEBUG_ERROR("string subscript out of range");
  7813. ; 1676 :
  7814. ; 1677 :  #elif _ITERATOR_DEBUG_LEVEL == 1
  7815. ; 1678 :                _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);      // sic
  7816. ; 1679 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  7817. ; 1680 :
  7818. ; 1681 :                return (this->_Myptr()[_Off]);
  7819. ; 1682 :                }
  7820. ; 1683 :
  7821. ; 1684 :        void push_back(_Elem _Ch)
  7822. ; 1685 :                {       // insert element at end
  7823. ; 1686 :                insert(end(), _Ch);
  7824. ; 1687 :                }
  7825. ; 1688 :
  7826. ; 1689 :  #if _HAS_CPP0X
  7827. ; 1690 :        void pop_back()
  7828. ; 1691 :                {       // erase element at end
  7829. ; 1692 :                erase(this->_Mysize - 1);       // throws if _Mysize == 0
  7830. ; 1693 :                }
  7831. ; 1694 :
  7832. ; 1695 :        reference front()
  7833. ; 1696 :                {       // return first element of mutable sequence
  7834. ; 1697 :                return (*begin());
  7835. ; 1698 :                }
  7836. ; 1699 :
  7837. ; 1700 :        const_reference front() const
  7838. ; 1701 :                {       // return first element of nonmutable sequence
  7839. ; 1702 :                return (*begin());
  7840. ; 1703 :                }
  7841. ; 1704 :
  7842. ; 1705 :        reference back()
  7843. ; 1706 :                {       // return last element of mutable sequence
  7844. ; 1707 :                return (*(end() - 1));
  7845. ; 1708 :                }
  7846. ; 1709 :
  7847. ; 1710 :        const_reference back() const
  7848. ; 1711 :                {       // return last element of nonmutable sequence
  7849. ; 1712 :                return (*(end() - 1));
  7850. ; 1713 :                }
  7851. ; 1714 :  #endif /* _HAS_CPP0X */
  7852. ; 1715 :
  7853. ; 1716 :        const _Elem *c_str() const _NOEXCEPT
  7854. ; 1717 :                {       // return pointer to null-terminated nonmutable array
  7855. ; 1718 :                return (this->_Myptr());
  7856. ; 1719 :                }
  7857. ; 1720 :
  7858. ; 1721 :        const _Elem *data() const _NOEXCEPT
  7859. ; 1722 :                {       // return pointer to nonmutable array
  7860. ; 1723 :                return (c_str());
  7861. ; 1724 :                }
  7862. ; 1725 :
  7863. ; 1726 :        size_type length() const _NOEXCEPT
  7864. ; 1727 :                {       // return length of sequence
  7865. ; 1728 :                return (this->_Mysize);
  7866. ; 1729 :                }
  7867. ; 1730 :
  7868. ; 1731 :        size_type size() const _NOEXCEPT
  7869. ; 1732 :                {       // return length of sequence
  7870. ; 1733 :                return (this->_Mysize);
  7871. ; 1734 :                }
  7872. ; 1735 :
  7873. ; 1736 :        size_type max_size() const _NOEXCEPT
  7874. ; 1737 :                {       // return maximum possible length of sequence
  7875. ; 1738 :                size_type _Num = this->_Getal().max_size();
  7876. ; 1739 :                return (_Num <= 1 ? 1 : _Num - 1);
  7877. ; 1740 :                }
  7878. ; 1741 :
  7879. ; 1742 :        void resize(size_type _Newsize)
  7880. ; 1743 :                {       // determine new length, padding with null elements as needed
  7881. ; 1744 :                resize(_Newsize, _Elem());
  7882. ; 1745 :                }
  7883. ; 1746 :
  7884. ; 1747 :        void resize(size_type _Newsize, _Elem _Ch)
  7885. ; 1748 :                {       // determine new length, padding with _Ch elements as needed
  7886. ; 1749 :                if (_Newsize <= this->_Mysize)
  7887. ; 1750 :                        _Eos(_Newsize);
  7888. ; 1751 :                else
  7889. ; 1752 :                        append(_Newsize - this->_Mysize, _Ch);
  7890. ; 1753 :                }
  7891. ; 1754 :
  7892. ; 1755 :        size_type capacity() const _NOEXCEPT
  7893. ; 1756 :                {       // return current length of allocated storage
  7894. ; 1757 :                return (this->_Myres);
  7895. ; 1758 :                }
  7896. ; 1759 :
  7897. ; 1760 :        void reserve(size_type _Newcap = 0)
  7898. ; 1761 :                {       // determine new minimum length of allocated storage
  7899. ; 1762 :                if (this->_Mysize <= _Newcap && this->_Myres != _Newcap)
  7900. ; 1763 :                        {       // change reservation
  7901. ; 1764 :                        size_type _Size = this->_Mysize;
  7902. ; 1765 :                        if (_Grow(_Newcap, true))
  7903. ; 1766 :                                _Eos(_Size);
  7904. ; 1767 :                        }
  7905. ; 1768 :                }
  7906. ; 1769 :
  7907. ; 1770 :        bool empty() const _NOEXCEPT
  7908. ; 1771 :                {       // test if sequence is empty
  7909. ; 1772 :                return (this->_Mysize == 0);
  7910. ; 1773 :                }
  7911. ; 1774 :
  7912. ; 1775 :        _SCL_INSECURE_DEPRECATE
  7913. ; 1776 :
  7914. ; 1777 :        size_type copy(_Elem *_Ptr,
  7915. ; 1778 :                size_type _Count, size_type _Off = 0) const
  7916. ; 1779 :                {       // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
  7917. ; 1780 :  #if _ITERATOR_DEBUG_LEVEL == 2
  7918. ; 1781 :                if (_Count != 0)
  7919. ; 1782 :                        _DEBUG_POINTER(_Ptr);
  7920. ; 1783 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  7921. ; 1784 :
  7922. ; 1785 :                if (this->_Mysize < _Off)
  7923. ; 1786 :                        _Xran();        // _Off off end
  7924. ; 1787 :                if (this->_Mysize - _Off < _Count)
  7925. ; 1788 :                        _Count = this->_Mysize - _Off;
  7926. ; 1789 :                _Traits::copy(_Ptr, this->_Myptr() + _Off, _Count);
  7927. ; 1790 :                return (_Count);
  7928. ; 1791 :                }
  7929. ; 1792 :
  7930. ; 1793 :        size_type _Copy_s(_Elem *_Dest, size_type _Dest_size,
  7931. ; 1794 :                size_type _Count, size_type _Off = 0) const
  7932. ; 1795 :                {       // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Count)
  7933. ; 1796 :  #if _ITERATOR_DEBUG_LEVEL == 2
  7934. ; 1797 :                if (_Count != 0)
  7935. ; 1798 :                        _DEBUG_POINTER(_Dest);
  7936. ; 1799 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  7937. ; 1800 :
  7938. ; 1801 :                if (this->_Mysize < _Off)
  7939. ; 1802 :                        _Xran();        // _Off off end
  7940. ; 1803 :                if (this->_Mysize - _Off < _Count)
  7941. ; 1804 :                        _Count = this->_Mysize - _Off;
  7942. ; 1805 :                _Traits::_Copy_s(_Dest, _Dest_size, this->_Myptr() + _Off, _Count);
  7943. ; 1806 :                return (_Count);
  7944. ; 1807 :                }
  7945. ; 1808 :
  7946. ; 1809 :        void _Swap_bx(_Myt& _Right)
  7947. ; 1810 :                {       // exchange _Bx with _Right._Bx
  7948. ; 1811 :                if (this->_BUF_SIZE <= this->_Myres)
  7949. ; 1812 :                        if (this->_BUF_SIZE <= _Right._Myres)
  7950. ; 1813 :                                _Swap_adl(this->_Bx._Ptr, _Right._Bx._Ptr);
  7951. ; 1814 :                        else
  7952. ; 1815 :                                {       // swap large with small
  7953. ; 1816 :                                pointer _Ptr = this->_Bx._Ptr;
  7954. ; 1817 :                                this->_Getal().destroy(&this->_Bx._Ptr);
  7955. ; 1818 :                                _Traits::copy(this->_Bx._Buf,
  7956. ; 1819 :                                        _Right._Bx._Buf, _Right._Mysize + 1);
  7957. ; 1820 :                                this->_Getal().construct(&_Right._Bx._Ptr, _Ptr);
  7958. ; 1821 :                                }
  7959. ; 1822 :                else
  7960. ; 1823 :                        if (_Right._Myres < this->_BUF_SIZE)
  7961. ; 1824 :                                _STD swap(this->_Bx._Buf, _Right._Bx._Buf);
  7962. ; 1825 :                        else
  7963. ; 1826 :                                {       // swap small with large
  7964. ; 1827 :                                pointer _Ptr = _Right._Bx._Ptr;
  7965. ; 1828 :                                this->_Getal().destroy(&_Right._Bx._Ptr);
  7966. ; 1829 :                                _Traits::copy(_Right._Bx._Buf,
  7967. ; 1830 :                                        this->_Bx._Buf, this->_Mysize + 1);
  7968. ; 1831 :                                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
  7969. ; 1832 :                                }
  7970. ; 1833 :                }
  7971. ; 1834 :
  7972. ; 1835 :        void swap(_Myt& _Right)
  7973. ; 1836 :                {       // exchange contents with _Right
  7974. ; 1837 :                if (this == &_Right)
  7975. ; 1838 :                        ;       // same object, do nothing
  7976. ; 1839 :                else if (this->_Getal() == _Right._Getal())
  7977. ; 1840 :                        {       // same allocator, swap control information
  7978. ; 1841 :                        this->_Swap_all(_Right);
  7979. ; 1842 :                        _Swap_bx(_Right);
  7980. ; 1843 :                        _STD swap(this->_Mysize, _Right._Mysize);
  7981. ; 1844 :                        _STD swap(this->_Myres, _Right._Myres);
  7982. ; 1845 :                        }
  7983. ; 1846 :
  7984. ; 1847 :  #if _HAS_CPP0X
  7985. ; 1848 :                else if (_Alty::propagate_on_container_swap::value)
  7986. ; 1849 :                        {       // swap allocators and control information
  7987. ; 1850 :                        this->_Swap_alloc(_Right);
  7988. ; 1851 :                        _Swap_bx(_Right);
  7989. ; 1852 :                        _STD swap(this->_Bx, _Right._Bx);       // pointer bitwise copyable?
  7990. ; 1853 :                        _STD swap(this->_Mysize, _Right._Mysize);
  7991. ; 1854 :                        _STD swap(this->_Myres, _Right._Myres);
  7992. ; 1855 :                        }
  7993. ; 1856 :  #endif /* _HAS_CPP0X */
  7994. ; 1857 :
  7995. ; 1858 :                else
  7996. ; 1859 :                        {       // different allocator, do multiple assigns
  7997. ; 1860 :                        _Myt _Tmp = *this;
  7998. ; 1861 :
  7999. ; 1862 :                        *this = _Right;
  8000. ; 1863 :                        _Right = _Tmp;
  8001. ; 1864 :                        }
  8002. ; 1865 :                }
  8003. ; 1866 :
  8004. ; 1867 :        size_type find(const _Myt& _Right, size_type _Off = 0) const _NOEXCEPT
  8005. ; 1868 :                {       // look for _Right beginning at or after _Off
  8006. ; 1869 :                return (find(_Right._Myptr(), _Off, _Right.size()));
  8007. ; 1870 :                }
  8008. ; 1871 :
  8009. ; 1872 :        size_type find(const _Elem *_Ptr,
  8010. ; 1873 :                size_type _Off, size_type _Count) const
  8011. ; 1874 :                {       // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
  8012. ; 1875 :  #if _ITERATOR_DEBUG_LEVEL == 2
  8013. ; 1876 :                if (_Count != 0)
  8014. ; 1877 :                        _DEBUG_POINTER(_Ptr);
  8015. ; 1878 :  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
  8016. ; 1879 :
  8017. ; 1880 :                if (_Count == 0 && _Off <= this->_Mysize)