1 // Main templates for the -*- C++ -*- string classes.
2 // Copyright (C) 1994, 1995 Free Software Foundation
4 // This file is part of the GNU ANSI C++ Library. This library is free
5 // software; you can redistribute it and/or modify it under the
6 // terms of the GNU General Public License as published by the
7 // Free Software Foundation; either version 2, or (at your option)
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
15 // You should have received a copy of the GNU General Public License
16 // along with this library; see the file COPYING. If not, write to the Free
17 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 // As a special exception, if you link this library with files
20 // compiled with a GNU compiler to produce an executable, this does not cause
21 // the resulting executable to be covered by the GNU General Public License.
22 // This exception does not however invalidate any other reasons why
23 // the executable file might be covered by the GNU General Public License.
25 // Written by Jason Merrill based upon the specification by Takanori Adachi
26 // in ANSI X3J16/94-0013R2.
36 #include <std/straits.h>
38 // NOTE : This does NOT conform to the draft standard and is likely to change
42 class istream
; class ostream
;
46 #ifdef __STL_USE_EXCEPTIONS
48 extern void __out_of_range (const char *);
49 extern void __length_error (const char *);
51 #define OUTOFRANGE(cond) \
52 do { if (cond) __out_of_range (#cond); } while (0)
53 #define LENGTHERROR(cond) \
54 do { if (cond) __length_error (#cond); } while (0)
59 #define OUTOFRANGE(cond) assert (!(cond))
60 #define LENGTHERROR(cond) assert (!(cond))
64 template <class charT
, class traits
= string_char_traits
<charT
>,
65 class Allocator
= alloc
>
73 charT
* data () { return reinterpret_cast<charT
*>(this + 1); }
74 charT
& operator[] (size_t s
) { return data () [s
]; }
75 charT
* grab () { if (selfish
) return clone (); ++ref
; return data (); }
76 void release () { if (--ref
== 0) delete this; }
78 inline static void * operator new (size_t, size_t);
79 inline static void operator delete (void *);
80 inline static Rep
* create (size_t);
83 inline void copy (size_t, const charT
*, size_t);
84 inline void move (size_t, const charT
*, size_t);
85 inline void set (size_t, const charT
, size_t);
87 inline static bool excess_slop (size_t, size_t);
88 inline static size_t frob_size (size_t);
91 Rep
&operator= (const Rep
&);
96 typedef traits traits_type
;
97 typedef typename
traits::char_type value_type
;
98 typedef Allocator allocator_type
;
100 typedef size_t size_type
;
101 typedef ptrdiff_t difference_type
;
102 typedef charT
& reference
;
103 typedef const charT
& const_reference
;
104 typedef charT
* pointer
;
105 typedef const charT
* const_pointer
;
106 typedef pointer iterator
;
107 typedef const_pointer const_iterator
;
108 typedef ::reverse_iterator
<iterator
> reverse_iterator
;
109 typedef ::reverse_iterator
<const_iterator
> const_reverse_iterator
;
110 static const size_type npos
= static_cast<size_type
>(-1);
113 Rep
*rep () const { return reinterpret_cast<Rep
*>(dat
) - 1; }
114 void repup (Rep
*p
) { rep ()->release (); dat
= p
->data (); }
117 const charT
* data () const
118 { return rep ()->data(); }
119 size_type
length () const
120 { return rep ()->len
; }
121 size_type
size () const
122 { return rep ()->len
; }
123 size_type
capacity () const
124 { return rep ()->res
; }
125 size_type
max_size () const
126 { return (npos
- 1)/sizeof (charT
); } // XXX
128 { return size () == 0; }
130 // _lib.string.cons_ construct/copy/destroy:
131 basic_string
& operator= (const basic_string
& str
)
133 if (&str
!= this) { rep ()->release (); dat
= str
.rep ()->grab (); }
137 explicit basic_string (): dat (nilRep
.grab ()) { }
138 basic_string (const basic_string
& str
): dat (str
.rep ()->grab ()) { }
139 basic_string (const basic_string
& str
, size_type pos
, size_type n
= npos
)
140 : dat (nilRep
.grab ()) { assign (str
, pos
, n
); }
141 basic_string (const charT
* s
, size_type n
)
142 : dat (nilRep
.grab ()) { assign (s
, n
); }
143 basic_string (const charT
* s
)
144 : dat (nilRep
.grab ()) { assign (s
); }
145 basic_string (size_type n
, charT c
)
146 : dat (nilRep
.grab ()) { assign (n
, c
); }
147 #ifdef __STL_MEMBER_TEMPLATES
148 template<class InputIterator
>
149 basic_string(InputIterator begin
, InputIterator end
)
151 basic_string(const_iterator begin
, const_iterator end
)
153 : dat (nilRep
.grab ()) { assign (begin
, end
); }
156 { rep ()->release (); }
158 void swap (basic_string
&s
) { charT
*d
= dat
; dat
= s
.dat
; s
.dat
= d
; }
160 basic_string
& append (const basic_string
& str
, size_type pos
= 0,
162 { return replace (length (), 0, str
, pos
, n
); }
163 basic_string
& append (const charT
* s
, size_type n
)
164 { return replace (length (), 0, s
, n
); }
165 basic_string
& append (const charT
* s
)
166 { return append (s
, traits::length (s
)); }
167 basic_string
& append (size_type n
, charT c
)
168 { return replace (length (), 0, n
, c
); }
169 #ifdef __STL_MEMBER_TEMPLATES
170 template<class InputIterator
>
171 basic_string
& append(InputIterator first
, InputIterator last
)
173 basic_string
& append(const_iterator first
, const_iterator last
)
175 { return replace (iend (), iend (), first
, last
); }
177 basic_string
& assign (const basic_string
& str
, size_type pos
= 0,
179 { return replace (0, npos
, str
, pos
, n
); }
180 basic_string
& assign (const charT
* s
, size_type n
)
181 { return replace (0, npos
, s
, n
); }
182 basic_string
& assign (const charT
* s
)
183 { return assign (s
, traits::length (s
)); }
184 basic_string
& assign (size_type n
, charT c
)
185 { return replace (0, npos
, n
, c
); }
186 #ifdef __STL_MEMBER_TEMPLATES
187 template<class InputIterator
>
188 basic_string
& assign(InputIterator first
, InputIterator last
)
190 basic_string
& assign(const_iterator first
, const_iterator last
)
192 { return replace (ibegin (), iend (), first
, last
); }
194 basic_string
& operator= (const charT
* s
)
195 { return assign (s
); }
196 basic_string
& operator= (charT c
)
197 { return assign (1, c
); }
199 basic_string
& operator+= (const basic_string
& rhs
)
200 { return append (rhs
); }
201 basic_string
& operator+= (const charT
* s
)
202 { return append (s
); }
203 basic_string
& operator+= (charT c
)
204 { return append (1, c
); }
206 basic_string
& insert (size_type pos1
, const basic_string
& str
,
207 size_type pos2
= 0, size_type n
= npos
)
208 { return replace (pos1
, 0, str
, pos2
, n
); }
209 basic_string
& insert (size_type pos
, const charT
* s
, size_type n
)
210 { return replace (pos
, 0, s
, n
); }
211 basic_string
& insert (size_type pos
, const charT
* s
)
212 { return insert (pos
, s
, traits::length (s
)); }
213 basic_string
& insert (size_type pos
, size_type n
, charT c
)
214 { return replace (pos
, 0, n
, c
); }
215 iterator
insert(iterator p
, charT c
)
216 { size_type __o
= p
- ibegin ();
217 insert (p
- ibegin (), 1, c
); selfish ();
218 return ibegin () + __o
; }
219 iterator
insert(iterator p
, size_type n
, charT c
)
220 { size_type __o
= p
- ibegin ();
221 insert (p
- ibegin (), n
, c
); selfish ();
222 return ibegin () + __o
; }
223 #ifdef __STL_MEMBER_TEMPLATES
224 template<class InputIterator
>
225 void insert(iterator p
, InputIterator first
, InputIterator last
)
227 void insert(iterator p
, const_iterator first
, const_iterator last
)
229 { replace (p
, p
, first
, last
); }
231 basic_string
& erase (size_type pos
= 0, size_type n
= npos
)
232 { return replace (pos
, n
, (size_type
)0, (charT
)0); }
233 iterator
erase(iterator p
)
234 { size_type __o
= p
- begin();
235 replace (__o
, 1, (size_type
)0, (charT
)0); selfish ();
236 return ibegin() + __o
; }
237 iterator
erase(iterator f
, iterator l
)
238 { size_type __o
= f
- ibegin();
239 replace (__o
, l
-f
, (size_type
)0, (charT
)0);selfish ();
240 return ibegin() + __o
; }
242 basic_string
& replace (size_type pos1
, size_type n1
, const basic_string
& str
,
243 size_type pos2
= 0, size_type n2
= npos
);
244 basic_string
& replace (size_type pos
, size_type n1
, const charT
* s
,
246 basic_string
& replace (size_type pos
, size_type n1
, const charT
* s
)
247 { return replace (pos
, n1
, s
, traits::length (s
)); }
248 basic_string
& replace (size_type pos
, size_type n1
, size_type n2
, charT c
);
249 basic_string
& replace (size_type pos
, size_type n
, charT c
)
250 { return replace (pos
, n
, 1, c
); }
251 basic_string
& replace (iterator i1
, iterator i2
, const basic_string
& str
)
252 { return replace (i1
- ibegin (), i2
- i1
, str
); }
253 basic_string
& replace (iterator i1
, iterator i2
, const charT
* s
, size_type n
)
254 { return replace (i1
- ibegin (), i2
- i1
, s
, n
); }
255 basic_string
& replace (iterator i1
, iterator i2
, const charT
* s
)
256 { return replace (i1
- ibegin (), i2
- i1
, s
); }
257 basic_string
& replace (iterator i1
, iterator i2
, size_type n
, charT c
)
258 { return replace (i1
- ibegin (), i2
- i1
, n
, c
); }
259 #ifdef __STL_MEMBER_TEMPLATES
260 template<class InputIterator
>
261 basic_string
& replace(iterator i1
, iterator i2
,
262 InputIterator j1
, InputIterator j2
);
264 basic_string
& replace(iterator i1
, iterator i2
,
265 const_iterator j1
, const_iterator j2
);
269 static charT
eos () { return traits::eos (); }
270 void unique () { if (rep ()->ref
> 1) alloc (length (), true); }
271 void selfish () { unique (); rep ()->selfish
= true; }
274 charT
operator[] (size_type pos
) const
276 if (pos
== length ())
281 reference
operator[] (size_type pos
)
282 { selfish (); return (*rep ())[pos
]; }
284 reference
at (size_type pos
)
286 OUTOFRANGE (pos
>= length ());
289 const_reference
at (size_type pos
) const
291 OUTOFRANGE (pos
>= length ());
296 void terminate () const
297 { traits::assign ((*rep ())[length ()], eos ()); }
300 const charT
* c_str () const
301 { if (length () == 0) return ""; terminate (); return data (); }
302 void resize (size_type n
, charT c
);
303 void resize (size_type n
)
304 { resize (n
, eos ()); }
305 void reserve (size_type
) { }
307 size_type
copy (charT
* s
, size_type n
, size_type pos
= 0) const;
309 size_type
find (const basic_string
& str
, size_type pos
= 0) const
310 { return find (str
.data(), pos
, str
.length()); }
311 size_type
find (const charT
* s
, size_type pos
, size_type n
) const;
312 size_type
find (const charT
* s
, size_type pos
= 0) const
313 { return find (s
, pos
, traits::length (s
)); }
314 size_type
find (charT c
, size_type pos
= 0) const;
316 size_type
rfind (const basic_string
& str
, size_type pos
= npos
) const
317 { return rfind (str
.data(), pos
, str
.length()); }
318 size_type
rfind (const charT
* s
, size_type pos
, size_type n
) const;
319 size_type
rfind (const charT
* s
, size_type pos
= npos
) const
320 { return rfind (s
, pos
, traits::length (s
)); }
321 size_type
rfind (charT c
, size_type pos
= npos
) const;
323 size_type
find_first_of (const basic_string
& str
, size_type pos
= 0) const
324 { return find_first_of (str
.data(), pos
, str
.length()); }
325 size_type
find_first_of (const charT
* s
, size_type pos
, size_type n
) const;
326 size_type
find_first_of (const charT
* s
, size_type pos
= 0) const
327 { return find_first_of (s
, pos
, traits::length (s
)); }
328 size_type
find_first_of (charT c
, size_type pos
= 0) const
329 { return find (c
, pos
); }
331 size_type
find_last_of (const basic_string
& str
, size_type pos
= npos
) const
332 { return find_last_of (str
.data(), pos
, str
.length()); }
333 size_type
find_last_of (const charT
* s
, size_type pos
, size_type n
) const;
334 size_type
find_last_of (const charT
* s
, size_type pos
= npos
) const
335 { return find_last_of (s
, pos
, traits::length (s
)); }
336 size_type
find_last_of (charT c
, size_type pos
= npos
) const
337 { return rfind (c
, pos
); }
339 size_type
find_first_not_of (const basic_string
& str
, size_type pos
= 0) const
340 { return find_first_not_of (str
.data(), pos
, str
.length()); }
341 size_type
find_first_not_of (const charT
* s
, size_type pos
, size_type n
) const;
342 size_type
find_first_not_of (const charT
* s
, size_type pos
= 0) const
343 { return find_first_not_of (s
, pos
, traits::length (s
)); }
344 size_type
find_first_not_of (charT c
, size_type pos
= 0) const;
346 size_type
find_last_not_of (const basic_string
& str
, size_type pos
= npos
) const
347 { return find_last_not_of (str
.data(), pos
, str
.length()); }
348 size_type
find_last_not_of (const charT
* s
, size_type pos
, size_type n
) const;
349 size_type
find_last_not_of (const charT
* s
, size_type pos
= npos
) const
350 { return find_last_not_of (s
, pos
, traits::length (s
)); }
351 size_type
find_last_not_of (charT c
, size_type pos
= npos
) const;
353 basic_string
substr (size_type pos
= 0, size_type n
= npos
) const
354 { return basic_string (*this, pos
, n
); }
356 int compare (const basic_string
& str
, size_type pos
= 0, size_type n
= npos
) const;
357 // There is no 'strncmp' equivalent for charT pointers.
358 int compare (const charT
* s
, size_type pos
, size_type n
) const;
359 int compare (const charT
* s
, size_type pos
= 0) const
360 { return compare (s
, pos
, traits::length (s
)); }
362 iterator
begin () { selfish (); return &(*this)[0]; }
363 iterator
end () { selfish (); return &(*this)[length ()]; }
366 iterator
ibegin () const { return &(*rep ())[0]; }
367 iterator
iend () const { return &(*rep ())[length ()]; }
370 const_iterator
begin () const { return ibegin (); }
371 const_iterator
end () const { return iend (); }
373 reverse_iterator
rbegin() { return reverse_iterator (end ()); }
374 const_reverse_iterator
rbegin() const
375 { return const_reverse_iterator (end ()); }
376 reverse_iterator
rend() { return reverse_iterator (begin ()); }
377 const_reverse_iterator
rend() const
378 { return const_reverse_iterator (begin ()); }
381 void alloc (size_type size
, bool save
);
382 static size_type
_find (const charT
* ptr
, charT c
, size_type xpos
, size_type len
);
383 inline bool check_realloc (size_type s
) const;
389 #ifdef __STL_MEMBER_TEMPLATES
390 template <class charT
, class traits
, class Allocator
> template <class InputIterator
>
391 basic_string
<charT
, traits
, Allocator
>& basic_string
<charT
, traits
, Allocator
>::
392 replace (iterator i1
, iterator i2
, InputIterator j1
, InputIterator j2
)
394 template <class charT
, class traits
, class Allocator
>
395 basic_string
<charT
, traits
, Allocator
>& basic_string
<charT
, traits
, Allocator
>::
396 replace (iterator i1
, iterator i2
, const_iterator j1
, const_iterator j2
)
399 const size_type len
= length ();
400 size_type pos
= i1
- ibegin ();
401 size_type n1
= i2
- i1
;
402 size_type n2
= j2
- j1
;
404 OUTOFRANGE (pos
> len
);
407 LENGTHERROR (len
- n1
> max_size () - n2
);
408 size_t newlen
= len
- n1
+ n2
;
410 if (check_realloc (newlen
))
412 Rep
*p
= Rep::create (newlen
);
413 p
->copy (0, data (), pos
);
414 p
->copy (pos
+ n2
, data () + pos
+ n1
, len
- (pos
+ n1
));
415 for (; j1
!= j2
; ++j1
, ++pos
)
416 traits::assign ((*p
)[pos
], *j1
);
421 rep ()->move (pos
+ n2
, data () + pos
+ n1
, len
- (pos
+ n1
));
422 for (; j1
!= j2
; ++j1
, ++pos
)
423 traits::assign ((*rep ())[pos
], *j1
);
425 rep ()->len
= newlen
;
430 template <class charT
, class traits
, class Allocator
>
431 inline basic_string
<charT
, traits
, Allocator
>
432 operator+ (const basic_string
<charT
, traits
, Allocator
>& lhs
,
433 const basic_string
<charT
, traits
, Allocator
>& rhs
)
435 basic_string
<charT
, traits
, Allocator
> str (lhs
);
440 template <class charT
, class traits
, class Allocator
>
441 inline basic_string
<charT
, traits
, Allocator
>
442 operator+ (const charT
* lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
444 basic_string
<charT
, traits
, Allocator
> str (lhs
);
449 template <class charT
, class traits
, class Allocator
>
450 inline basic_string
<charT
, traits
, Allocator
>
451 operator+ (charT lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
453 basic_string
<charT
, traits
, Allocator
> str (1, lhs
);
458 template <class charT
, class traits
, class Allocator
>
459 inline basic_string
<charT
, traits
, Allocator
>
460 operator+ (const basic_string
<charT
, traits
, Allocator
>& lhs
, const charT
* rhs
)
462 basic_string
<charT
, traits
, Allocator
> str (lhs
);
467 template <class charT
, class traits
, class Allocator
>
468 inline basic_string
<charT
, traits
, Allocator
>
469 operator+ (const basic_string
<charT
, traits
, Allocator
>& lhs
, charT rhs
)
471 basic_string
<charT
, traits
, Allocator
> str (lhs
);
476 template <class charT
, class traits
, class Allocator
>
478 operator== (const basic_string
<charT
, traits
, Allocator
>& lhs
,
479 const basic_string
<charT
, traits
, Allocator
>& rhs
)
481 return (lhs
.compare (rhs
) == 0);
484 template <class charT
, class traits
, class Allocator
>
486 operator== (const charT
* lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
488 return (rhs
.compare (lhs
) == 0);
491 template <class charT
, class traits
, class Allocator
>
493 operator== (const basic_string
<charT
, traits
, Allocator
>& lhs
, const charT
* rhs
)
495 return (lhs
.compare (rhs
) == 0);
498 template <class charT
, class traits
, class Allocator
>
500 operator!= (const charT
* lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
502 return (rhs
.compare (lhs
) != 0);
505 template <class charT
, class traits
, class Allocator
>
507 operator!= (const basic_string
<charT
, traits
, Allocator
>& lhs
, const charT
* rhs
)
509 return (lhs
.compare (rhs
) != 0);
512 template <class charT
, class traits
, class Allocator
>
514 operator< (const basic_string
<charT
, traits
, Allocator
>& lhs
,
515 const basic_string
<charT
, traits
, Allocator
>& rhs
)
517 return (lhs
.compare (rhs
) < 0);
520 template <class charT
, class traits
, class Allocator
>
522 operator< (const charT
* lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
524 return (rhs
.compare (lhs
) > 0);
527 template <class charT
, class traits
, class Allocator
>
529 operator< (const basic_string
<charT
, traits
, Allocator
>& lhs
, const charT
* rhs
)
531 return (lhs
.compare (rhs
) < 0);
534 template <class charT
, class traits
, class Allocator
>
536 operator> (const charT
* lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
538 return (rhs
.compare (lhs
) < 0);
541 template <class charT
, class traits
, class Allocator
>
543 operator> (const basic_string
<charT
, traits
, Allocator
>& lhs
, const charT
* rhs
)
545 return (lhs
.compare (rhs
) > 0);
548 template <class charT
, class traits
, class Allocator
>
550 operator<= (const charT
* lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
552 return (rhs
.compare (lhs
) >= 0);
555 template <class charT
, class traits
, class Allocator
>
557 operator<= (const basic_string
<charT
, traits
, Allocator
>& lhs
, const charT
* rhs
)
559 return (lhs
.compare (rhs
) <= 0);
562 template <class charT
, class traits
, class Allocator
>
564 operator>= (const charT
* lhs
, const basic_string
<charT
, traits
, Allocator
>& rhs
)
566 return (rhs
.compare (lhs
) <= 0);
569 template <class charT
, class traits
, class Allocator
>
571 operator>= (const basic_string
<charT
, traits
, Allocator
>& lhs
, const charT
* rhs
)
573 return (lhs
.compare (rhs
) >= 0);
576 template <class charT
, class traits
, class Allocator
>
578 operator!= (const basic_string
<charT
, traits
, Allocator
>& lhs
,
579 const basic_string
<charT
, traits
, Allocator
>& rhs
)
581 return (lhs
.compare (rhs
) != 0);
584 template <class charT
, class traits
, class Allocator
>
586 operator> (const basic_string
<charT
, traits
, Allocator
>& lhs
,
587 const basic_string
<charT
, traits
, Allocator
>& rhs
)
589 return (lhs
.compare (rhs
) > 0);
592 template <class charT
, class traits
, class Allocator
>
594 operator<= (const basic_string
<charT
, traits
, Allocator
>& lhs
,
595 const basic_string
<charT
, traits
, Allocator
>& rhs
)
597 return (lhs
.compare (rhs
) <= 0);
600 template <class charT
, class traits
, class Allocator
>
602 operator>= (const basic_string
<charT
, traits
, Allocator
>& lhs
,
603 const basic_string
<charT
, traits
, Allocator
>& rhs
)
605 return (lhs
.compare (rhs
) >= 0);
608 class istream
; class ostream
;
609 template <class charT
, class traits
, class Allocator
> istream
&
610 operator>> (istream
&, basic_string
<charT
, traits
, Allocator
>&);
611 template <class charT
, class traits
, class Allocator
> ostream
&
612 operator<< (ostream
&, const basic_string
<charT
, traits
, Allocator
>&);
613 template <class charT
, class traits
, class Allocator
> istream
&
614 getline (istream
&, basic_string
<charT
, traits
, Allocator
>&, charT delim
= '\n');
618 #include <std/bastring.cc>