1 ------------------------------------------------------------------------------
3 -- GNAT RUNTIME COMPONENTS --
5 -- A D A . S T R I N G S . W I D E _ B O U N D E D --
10 -- Copyright (C) 1992-2001 Free Software Foundation, Inc. --
12 -- GNAT is free software; you can redistribute it and/or modify it under --
13 -- terms of the GNU General Public License as published by the Free Soft- --
14 -- ware Foundation; either version 2, or (at your option) any later ver- --
15 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
16 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
17 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
18 -- for more details. You should have received a copy of the GNU General --
19 -- Public License distributed with GNAT; see file COPYING. If not, write --
20 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
21 -- MA 02111-1307, USA. --
23 -- As a special exception, if other files instantiate generics from this --
24 -- unit, or you link this unit with other files to produce an executable, --
25 -- this unit does not by itself cause the resulting executable to be --
26 -- covered by the GNU General Public License. This exception does not --
27 -- however invalidate any other reasons why the executable file might be --
28 -- covered by the GNU Public License. --
30 -- GNAT was originally developed by the GNAT team at New York University. --
31 -- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
33 ------------------------------------------------------------------------------
35 with Ada
.Strings
.Wide_Maps
; use Ada
.Strings
.Wide_Maps
;
36 with Ada
.Strings
.Wide_Search
;
38 package body Ada
.Strings
.Wide_Bounded
is
40 package body Generic_Bounded_Length
is
47 (Left
: in Bounded_Wide_String
;
48 Right
: in Bounded_Wide_String
)
49 return Bounded_Wide_String
51 Result
: Bounded_Wide_String
;
52 Llen
: constant Length_Range
:= Left
.Length
;
53 Rlen
: constant Length_Range
:= Right
.Length
;
54 Nlen
: constant Natural := Llen
+ Rlen
;
57 if Nlen
> Max_Length
then
58 raise Ada
.Strings
.Length_Error
;
60 Result
.Length
:= Nlen
;
61 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
62 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
69 (Left
: in Bounded_Wide_String
;
70 Right
: in Wide_String)
71 return Bounded_Wide_String
73 Result
: Bounded_Wide_String
;
74 Llen
: constant Length_Range
:= Left
.Length
;
76 Nlen
: constant Natural := Llen
+ Right
'Length;
79 if Nlen
> Max_Length
then
80 raise Ada
.Strings
.Length_Error
;
82 Result
.Length
:= Nlen
;
83 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
84 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
;
90 (Left
: in Wide_String;
91 Right
: in Bounded_Wide_String
)
92 return Bounded_Wide_String
94 Result
: Bounded_Wide_String
;
95 Llen
: constant Length_Range
:= Left
'Length;
96 Rlen
: constant Length_Range
:= Right
.Length
;
97 Nlen
: constant Natural := Llen
+ Rlen
;
100 if Nlen
> Max_Length
then
101 raise Ada
.Strings
.Length_Error
;
103 Result
.Length
:= Nlen
;
104 Result
.Data
(1 .. Llen
) := Left
;
105 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
112 (Left
: in Bounded_Wide_String
;
113 Right
: in Wide_Character)
114 return Bounded_Wide_String
116 Result
: Bounded_Wide_String
;
117 Llen
: constant Length_Range
:= Left
.Length
;
120 if Llen
= Max_Length
then
121 raise Ada
.Strings
.Length_Error
;
123 Result
.Length
:= Llen
+ 1;
124 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
125 Result
.Data
(Result
.Length
) := Right
;
132 (Left
: in Wide_Character;
133 Right
: in Bounded_Wide_String
)
134 return Bounded_Wide_String
136 Result
: Bounded_Wide_String
;
137 Rlen
: Length_Range
:= Right
.Length
;
140 if Rlen
= Max_Length
then
141 raise Ada
.Strings
.Length_Error
;
143 Result
.Length
:= Rlen
+ 1;
144 Result
.Data
(1) := Left
;
145 Result
.Data
(2 .. Result
.Length
) := Right
.Data
(1 .. Rlen
);
157 Right
: in Wide_Character)
158 return Bounded_Wide_String
160 Result
: Bounded_Wide_String
;
163 if Left
> Max_Length
then
164 raise Ada
.Strings
.Length_Error
;
166 Result
.Length
:= Left
;
168 for J
in 1 .. Left
loop
169 Result
.Data
(J
) := Right
;
178 Right
: in Wide_String)
179 return Bounded_Wide_String
181 Result
: Bounded_Wide_String
;
183 Rlen
: constant Natural := Right
'Length;
184 Nlen
: constant Natural := Left
* Rlen
;
187 if Nlen
> Max_Length
then
188 raise Ada
.Strings
.Index_Error
;
190 Result
.Length
:= Nlen
;
193 for J
in 1 .. Left
loop
194 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) := Right
;
205 Right
: in Bounded_Wide_String
)
206 return Bounded_Wide_String
208 Result
: Bounded_Wide_String
;
210 Rlen
: constant Length_Range
:= Right
.Length
;
211 Nlen
: constant Natural := Left
* Rlen
;
214 if Nlen
> Max_Length
then
215 raise Ada
.Strings
.Length_Error
;
218 Result
.Length
:= Nlen
;
221 for J
in 1 .. Left
loop
222 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) :=
223 Right
.Data
(1 .. Rlen
);
237 (Left
: in Bounded_Wide_String
;
238 Right
: in Bounded_Wide_String
)
242 return Left
.Data
(1 .. Left
.Length
) < Right
.Data
(1 .. Right
.Length
);
246 (Left
: in Bounded_Wide_String
;
247 Right
: in Wide_String)
251 return Left
.Data
(1 .. Left
.Length
) < Right
;
255 (Left
: in Wide_String;
256 Right
: in Bounded_Wide_String
)
260 return Left
< Right
.Data
(1 .. Right
.Length
);
268 (Left
: in Bounded_Wide_String
;
269 Right
: in Bounded_Wide_String
)
273 return Left
.Data
(1 .. Left
.Length
) <= Right
.Data
(1 .. Right
.Length
);
277 (Left
: in Bounded_Wide_String
;
278 Right
: in Wide_String)
282 return Left
.Data
(1 .. Left
.Length
) <= Right
;
286 (Left
: in Wide_String;
287 Right
: in Bounded_Wide_String
)
291 return Left
<= Right
.Data
(1 .. Right
.Length
);
299 (Left
: in Bounded_Wide_String
;
300 Right
: in Bounded_Wide_String
)
304 return Left
.Length
= Right
.Length
305 and then Left
.Data
(1 .. Left
.Length
) =
306 Right
.Data
(1 .. Right
.Length
);
310 (Left
: in Bounded_Wide_String
;
311 Right
: in Wide_String)
315 return Left
.Length
= Right
'Length
316 and then Left
.Data
(1 .. Left
.Length
) = Right
;
320 (Left
: in Wide_String;
321 Right
: in Bounded_Wide_String
)
325 return Left
'Length = Right
.Length
326 and then Left
= Right
.Data
(1 .. Right
.Length
);
334 (Left
: in Bounded_Wide_String
;
335 Right
: in Bounded_Wide_String
)
339 return Left
.Data
(1 .. Left
.Length
) > Right
.Data
(1 .. Right
.Length
);
343 (Left
: in Bounded_Wide_String
;
344 Right
: in Wide_String)
348 return Left
.Data
(1 .. Left
.Length
) > Right
;
352 (Left
: in Wide_String;
353 Right
: in Bounded_Wide_String
)
357 return Left
> Right
.Data
(1 .. Right
.Length
);
365 (Left
: in Bounded_Wide_String
;
366 Right
: in Bounded_Wide_String
)
370 return Left
.Data
(1 .. Left
.Length
) >= Right
.Data
(1 .. Right
.Length
);
374 (Left
: in Bounded_Wide_String
;
375 Right
: in Wide_String)
379 return Left
.Data
(1 .. Left
.Length
) >= Right
;
383 (Left
: in Wide_String;
384 Right
: in Bounded_Wide_String
)
388 return Left
>= Right
.Data
(1 .. Right
.Length
);
395 -- Case of Bounded_Wide_String and Bounded_Wide_String
398 (Left
, Right
: in Bounded_Wide_String
;
399 Drop
: in Strings
.Truncation
:= Strings
.Error
)
400 return Bounded_Wide_String
402 Result
: Bounded_Wide_String
;
403 Llen
: constant Length_Range
:= Left
.Length
;
404 Rlen
: constant Length_Range
:= Right
.Length
;
405 Nlen
: constant Natural := Llen
+ Rlen
;
408 if Nlen
<= Max_Length
then
409 Result
.Length
:= Nlen
;
410 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
411 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
414 Result
.Length
:= Max_Length
;
417 when Strings
.Right
=>
418 if Llen
>= Max_Length
then -- only case is Llen = Max_Length
419 Result
.Data
:= Right
.Data
;
422 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
423 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
424 Right
.Data
(1 .. Max_Length
- Llen
);
428 if Rlen
>= Max_Length
then -- only case is Rlen = Max_Length
429 Result
.Data
:= Right
.Data
;
432 Result
.Data
(1 .. Max_Length
- Rlen
) :=
433 Left
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
434 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
435 Right
.Data
(1 .. Rlen
);
438 when Strings
.Error
=>
439 raise Ada
.Strings
.Length_Error
;
447 (Source
: in out Bounded_Wide_String
;
448 New_Item
: in Bounded_Wide_String
;
449 Drop
: in Truncation
:= Error
)
451 Llen
: constant Length_Range
:= Source
.Length
;
452 Rlen
: constant Length_Range
:= New_Item
.Length
;
453 Nlen
: constant Natural := Llen
+ Rlen
;
456 if Nlen
<= Max_Length
then
457 Source
.Length
:= Nlen
;
458 Source
.Data
(Llen
+ 1 .. Nlen
) := New_Item
.Data
(1 .. Rlen
);
461 Source
.Length
:= Max_Length
;
464 when Strings
.Right
=>
465 if Llen
< Max_Length
then
466 Source
.Data
(Llen
+ 1 .. Max_Length
) :=
467 New_Item
.Data
(1 .. Max_Length
- Llen
);
471 if Rlen
>= Max_Length
then -- only case is Rlen = Max_Length
472 Source
.Data
:= New_Item
.Data
;
475 Source
.Data
(1 .. Max_Length
- Rlen
) :=
476 Source
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
477 Source
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
478 New_Item
.Data
(1 .. Rlen
);
481 when Strings
.Error
=>
482 raise Ada
.Strings
.Length_Error
;
488 -- Case of Bounded_Wide_String and Wide_String
491 (Left
: in Bounded_Wide_String
;
492 Right
: in Wide_String;
493 Drop
: in Strings
.Truncation
:= Strings
.Error
)
494 return Bounded_Wide_String
496 Result
: Bounded_Wide_String
;
497 Llen
: constant Length_Range
:= Left
.Length
;
498 Rlen
: constant Length_Range
:= Right
'Length;
499 Nlen
: constant Natural := Llen
+ Rlen
;
502 if Nlen
<= Max_Length
then
503 Result
.Length
:= Nlen
;
504 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
505 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
;
508 Result
.Length
:= Max_Length
;
511 when Strings
.Right
=>
512 if Llen
>= Max_Length
then -- only case is Llen = Max_Length
513 Result
.Data
:= Left
.Data
;
516 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
517 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
518 Right
(Right
'First .. Right
'First - 1 +
524 if Rlen
>= Max_Length
then
525 Result
.Data
(1 .. Max_Length
) :=
526 Right
(Right
'Last - (Max_Length
- 1) .. Right
'Last);
529 Result
.Data
(1 .. Max_Length
- Rlen
) :=
530 Left
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
531 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
535 when Strings
.Error
=>
536 raise Ada
.Strings
.Length_Error
;
544 (Source
: in out Bounded_Wide_String
;
545 New_Item
: in Wide_String;
546 Drop
: in Truncation
:= Error
)
548 Llen
: constant Length_Range
:= Source
.Length
;
549 Rlen
: constant Length_Range
:= New_Item
'Length;
550 Nlen
: constant Natural := Llen
+ Rlen
;
553 if Nlen
<= Max_Length
then
554 Source
.Length
:= Nlen
;
555 Source
.Data
(Llen
+ 1 .. Nlen
) := New_Item
;
558 Source
.Length
:= Max_Length
;
561 when Strings
.Right
=>
562 if Llen
< Max_Length
then
563 Source
.Data
(Llen
+ 1 .. Max_Length
) :=
564 New_Item
(New_Item
'First ..
565 New_Item
'First - 1 + Max_Length
- Llen
);
569 if Rlen
>= Max_Length
then
570 Source
.Data
(1 .. Max_Length
) :=
571 New_Item
(New_Item
'Last - (Max_Length
- 1) ..
575 Source
.Data
(1 .. Max_Length
- Rlen
) :=
576 Source
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
577 Source
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
581 when Strings
.Error
=>
582 raise Ada
.Strings
.Length_Error
;
588 -- Case of Wide_String and Bounded_Wide_String
591 (Left
: in Wide_String;
592 Right
: in Bounded_Wide_String
;
593 Drop
: in Strings
.Truncation
:= Strings
.Error
)
594 return Bounded_Wide_String
596 Result
: Bounded_Wide_String
;
597 Llen
: constant Length_Range
:= Left
'Length;
598 Rlen
: constant Length_Range
:= Right
.Length
;
599 Nlen
: constant Natural := Llen
+ Rlen
;
602 if Nlen
<= Max_Length
then
603 Result
.Length
:= Nlen
;
604 Result
.Data
(1 .. Llen
) := Left
;
605 Result
.Data
(Llen
+ 1 .. Llen
+ Rlen
) := Right
.Data
(1 .. Rlen
);
608 Result
.Length
:= Max_Length
;
611 when Strings
.Right
=>
612 if Llen
>= Max_Length
then
613 Result
.Data
(1 .. Max_Length
) :=
614 Left
(Left
'First .. Left
'First + (Max_Length
- 1));
617 Result
.Data
(1 .. Llen
) := Left
;
618 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
619 Right
.Data
(1 .. Max_Length
- Llen
);
623 if Rlen
>= Max_Length
then
624 Result
.Data
(1 .. Max_Length
) :=
625 Right
.Data
(Rlen
- (Max_Length
- 1) .. Rlen
);
628 Result
.Data
(1 .. Max_Length
- Rlen
) :=
629 Left
(Left
'Last - (Max_Length
- Rlen
- 1) .. Left
'Last);
630 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
631 Right
.Data
(1 .. Rlen
);
634 when Strings
.Error
=>
635 raise Ada
.Strings
.Length_Error
;
642 -- Case of Bounded_Wide_String and Wide_Character
645 (Left
: in Bounded_Wide_String
;
646 Right
: in Wide_Character;
647 Drop
: in Strings
.Truncation
:= Strings
.Error
)
648 return Bounded_Wide_String
650 Result
: Bounded_Wide_String
;
651 Llen
: constant Length_Range
:= Left
.Length
;
654 if Llen
< Max_Length
then
655 Result
.Length
:= Llen
+ 1;
656 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
657 Result
.Data
(Llen
+ 1) := Right
;
662 when Strings
.Right
=>
666 Result
.Length
:= Max_Length
;
667 Result
.Data
(1 .. Max_Length
- 1) :=
668 Left
.Data
(2 .. Max_Length
);
669 Result
.Data
(Max_Length
) := Right
;
672 when Strings
.Error
=>
673 raise Ada
.Strings
.Length_Error
;
679 (Source
: in out Bounded_Wide_String
;
680 New_Item
: in Wide_Character;
681 Drop
: in Truncation
:= Error
)
683 Llen
: constant Length_Range
:= Source
.Length
;
686 if Llen
< Max_Length
then
687 Source
.Length
:= Llen
+ 1;
688 Source
.Data
(Llen
+ 1) := New_Item
;
691 Source
.Length
:= Max_Length
;
694 when Strings
.Right
=>
698 Source
.Data
(1 .. Max_Length
- 1) :=
699 Source
.Data
(2 .. Max_Length
);
700 Source
.Data
(Max_Length
) := New_Item
;
702 when Strings
.Error
=>
703 raise Ada
.Strings
.Length_Error
;
709 -- Case of Wide_Character and Bounded_Wide_String
712 (Left
: in Wide_Character;
713 Right
: in Bounded_Wide_String
;
714 Drop
: in Strings
.Truncation
:= Strings
.Error
)
715 return Bounded_Wide_String
717 Result
: Bounded_Wide_String
;
718 Rlen
: constant Length_Range
:= Right
.Length
;
721 if Rlen
< Max_Length
then
722 Result
.Length
:= Rlen
+ 1;
723 Result
.Data
(1) := Left
;
724 Result
.Data
(2 .. Rlen
+ 1) := Right
.Data
(1 .. Rlen
);
729 when Strings
.Right
=>
730 Result
.Length
:= Max_Length
;
731 Result
.Data
(1) := Left
;
732 Result
.Data
(2 .. Max_Length
) :=
733 Right
.Data
(1 .. Max_Length
- 1);
739 when Strings
.Error
=>
740 raise Ada
.Strings
.Length_Error
;
750 (Source
: in Bounded_Wide_String
;
751 Pattern
: in Wide_String;
752 Mapping
: in Wide_Maps
.Wide_Character_Mapping
:= Wide_Maps
.Identity
)
758 (Source
.Data
(1 .. Source
.Length
), Pattern
, Mapping
);
762 (Source
: in Bounded_Wide_String
;
763 Pattern
: in Wide_String;
764 Mapping
: in Wide_Maps
.Wide_Character_Mapping_Function
)
770 (Source
.Data
(1 .. Source
.Length
), Pattern
, Mapping
);
774 (Source
: in Bounded_Wide_String
;
775 Set
: in Wide_Maps
.Wide_Character_Set
)
779 return Wide_Search
.Count
(Source
.Data
(1 .. Source
.Length
), Set
);
787 (Source
: in Bounded_Wide_String
;
789 Through
: in Natural)
790 return Bounded_Wide_String
792 Slen
: constant Natural := Source
.Length
;
793 Num_Delete
: constant Integer := Through
- From
+ 1;
794 Result
: Bounded_Wide_String
;
797 if Num_Delete
<= 0 then
800 elsif From
> Slen
+ 1 then
801 raise Ada
.Strings
.Index_Error
;
803 elsif Through
>= Slen
then
804 Result
.Length
:= From
- 1;
805 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
809 Result
.Length
:= Slen
- Num_Delete
;
810 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
811 Result
.Data
(From
.. Result
.Length
) :=
812 Source
.Data
(Through
+ 1 .. Slen
);
818 (Source
: in out Bounded_Wide_String
;
820 Through
: in Natural)
822 Slen
: constant Natural := Source
.Length
;
823 Num_Delete
: constant Integer := Through
- From
+ 1;
826 if Num_Delete
<= 0 then
829 elsif From
> Slen
+ 1 then
830 raise Ada
.Strings
.Index_Error
;
832 elsif Through
>= Slen
then
833 Source
.Length
:= From
- 1;
836 Source
.Length
:= Slen
- Num_Delete
;
837 Source
.Data
(From
.. Source
.Length
) :=
838 Source
.Data
(Through
+ 1 .. Slen
);
847 (Source
: in Bounded_Wide_String
;
849 return Wide_Character
852 if Index
in 1 .. Source
.Length
then
853 return Source
.Data
(Index
);
855 raise Strings
.Index_Error
;
864 (Source
: in Bounded_Wide_String
;
865 Set
: in Wide_Maps
.Wide_Character_Set
;
866 Test
: in Strings
.Membership
;
867 First
: out Positive;
871 Wide_Search
.Find_Token
872 (Source
.Data
(1 .. Source
.Length
), Set
, Test
, First
, Last
);
881 (Source
: in Bounded_Wide_String
;
883 Pad
: in Wide_Character := Wide_Space
;
884 Drop
: in Strings
.Truncation
:= Strings
.Error
)
885 return Bounded_Wide_String
887 Result
: Bounded_Wide_String
;
888 Slen
: constant Natural := Source
.Length
;
889 Npad
: constant Integer := Count
- Slen
;
893 Result
.Length
:= Count
;
894 Result
.Data
(1 .. Count
) := Source
.Data
(1 .. Count
);
896 elsif Count
<= Max_Length
then
897 Result
.Length
:= Count
;
898 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
899 Result
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
902 Result
.Length
:= Max_Length
;
905 when Strings
.Right
=>
906 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
907 Result
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
910 if Npad
>= Max_Length
then
911 Result
.Data
:= (others => Pad
);
914 Result
.Data
(1 .. Max_Length
- Npad
) :=
915 Source
.Data
(Count
- Max_Length
+ 1 .. Slen
);
916 Result
.Data
(Max_Length
- Npad
+ 1 .. Max_Length
) :=
920 when Strings
.Error
=>
921 raise Ada
.Strings
.Length_Error
;
929 (Source
: in out Bounded_Wide_String
;
931 Pad
: in Wide_Character := Wide_Space
;
932 Drop
: in Truncation
:= Error
)
934 Slen
: constant Natural := Source
.Length
;
935 Npad
: constant Integer := Count
- Slen
;
936 Temp
: Wide_String (1 .. Max_Length
);
940 Source
.Length
:= Count
;
942 elsif Count
<= Max_Length
then
943 Source
.Length
:= Count
;
944 Source
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
947 Source
.Length
:= Max_Length
;
950 when Strings
.Right
=>
951 Source
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
954 if Npad
> Max_Length
then
955 Source
.Data
:= (others => Pad
);
959 Source
.Data
(1 .. Max_Length
- Npad
) :=
960 Temp
(Count
- Max_Length
+ 1 .. Slen
);
962 for J
in Max_Length
- Npad
+ 1 .. Max_Length
loop
963 Source
.Data
(J
) := Pad
;
967 when Strings
.Error
=>
968 raise Ada
.Strings
.Length_Error
;
979 (Source
: in Bounded_Wide_String
;
980 Pattern
: in Wide_String;
981 Going
: in Strings
.Direction
:= Strings
.Forward
;
982 Mapping
: in Wide_Maps
.Wide_Character_Mapping
:= Wide_Maps
.Identity
)
986 return Wide_Search
.Index
987 (Source
.Data
(1 .. Source
.Length
), Pattern
, Going
, Mapping
);
991 (Source
: in Bounded_Wide_String
;
992 Pattern
: in Wide_String;
993 Going
: in Direction
:= Forward
;
994 Mapping
: in Wide_Maps
.Wide_Character_Mapping_Function
)
998 return Wide_Search
.Index
999 (Source
.Data
(1 .. Source
.Length
), Pattern
, Going
, Mapping
);
1003 (Source
: in Bounded_Wide_String
;
1004 Set
: in Wide_Maps
.Wide_Character_Set
;
1005 Test
: in Strings
.Membership
:= Strings
.Inside
;
1006 Going
: in Strings
.Direction
:= Strings
.Forward
)
1010 return Wide_Search
.Index
1011 (Source
.Data
(1 .. Source
.Length
), Set
, Test
, Going
);
1014 ---------------------
1015 -- Index_Non_Blank --
1016 ---------------------
1018 function Index_Non_Blank
1019 (Source
: in Bounded_Wide_String
;
1020 Going
: in Strings
.Direction
:= Strings
.Forward
)
1025 Wide_Search
.Index_Non_Blank
1026 (Source
.Data
(1 .. Source
.Length
), Going
);
1027 end Index_Non_Blank
;
1034 (Source
: in Bounded_Wide_String
;
1035 Before
: in Positive;
1036 New_Item
: in Wide_String;
1037 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1038 return Bounded_Wide_String
1040 Slen
: constant Natural := Source
.Length
;
1041 Nlen
: constant Natural := New_Item
'Length;
1042 Tlen
: constant Natural := Slen
+ Nlen
;
1043 Blen
: constant Natural := Before
- 1;
1044 Alen
: constant Integer := Slen
- Blen
;
1045 Droplen
: constant Integer := Tlen
- Max_Length
;
1046 Result
: Bounded_Wide_String
;
1048 -- Tlen is the length of the total string before possible truncation.
1049 -- Blen, Alen are the lengths of the before and after pieces of the
1054 raise Ada
.Strings
.Index_Error
;
1056 elsif Droplen
<= 0 then
1057 Result
.Length
:= Tlen
;
1058 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1059 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1060 Result
.Data
(Before
+ Nlen
.. Tlen
) :=
1061 Source
.Data
(Before
.. Slen
);
1064 Result
.Length
:= Max_Length
;
1067 when Strings
.Right
=>
1068 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1070 if Droplen
> Alen
then
1071 Result
.Data
(Before
.. Max_Length
) :=
1072 New_Item
(New_Item
'First
1073 .. New_Item
'First + Max_Length
- Before
);
1075 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1076 Result
.Data
(Before
+ Nlen
.. Max_Length
) :=
1077 Source
.Data
(Before
.. Slen
- Droplen
);
1080 when Strings
.Left
=>
1081 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1082 Source
.Data
(Before
.. Slen
);
1084 if Droplen
>= Blen
then
1085 Result
.Data
(1 .. Max_Length
- Alen
) :=
1086 New_Item
(New_Item
'Last - (Max_Length
- Alen
) + 1
1090 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) :=
1092 Result
.Data
(1 .. Blen
- Droplen
) :=
1093 Source
.Data
(Droplen
+ 1 .. Blen
);
1096 when Strings
.Error
=>
1097 raise Ada
.Strings
.Length_Error
;
1105 (Source
: in out Bounded_Wide_String
;
1106 Before
: in Positive;
1107 New_Item
: in Wide_String;
1108 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1111 -- We do a double copy here because this is one of the situations
1112 -- in which we move data to the right, and at least at the moment,
1113 -- GNAT is not handling such cases correctly ???
1115 Source
:= Insert
(Source
, Before
, New_Item
, Drop
);
1122 function Length
(Source
: in Bounded_Wide_String
) return Length_Range
is
1124 return Source
.Length
;
1132 (Source
: in Bounded_Wide_String
;
1133 Position
: in Positive;
1134 New_Item
: in Wide_String;
1135 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1136 return Bounded_Wide_String
1138 Result
: Bounded_Wide_String
;
1139 Endpos
: constant Natural := Position
+ New_Item
'Length - 1;
1140 Slen
: constant Natural := Source
.Length
;
1144 if Position
> Slen
+ 1 then
1145 raise Ada
.Strings
.Index_Error
;
1147 elsif New_Item
'Length = 0 then
1150 elsif Endpos
<= Slen
then
1151 Result
.Length
:= Source
.Length
;
1152 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
1153 Result
.Data
(Position
.. Endpos
) := New_Item
;
1156 elsif Endpos
<= Max_Length
then
1157 Result
.Length
:= Endpos
;
1158 Result
.Data
(1 .. Position
- 1) := Source
.Data
(1 .. Position
- 1);
1159 Result
.Data
(Position
.. Endpos
) := New_Item
;
1163 Result
.Length
:= Max_Length
;
1164 Droplen
:= Endpos
- Max_Length
;
1167 when Strings
.Right
=>
1168 Result
.Data
(1 .. Position
- 1) :=
1169 Source
.Data
(1 .. Position
- 1);
1171 Result
.Data
(Position
.. Max_Length
) :=
1172 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1175 when Strings
.Left
=>
1176 if New_Item
'Length >= Max_Length
then
1177 Result
.Data
(1 .. Max_Length
) :=
1178 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1183 Result
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1184 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1186 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1191 when Strings
.Error
=>
1192 raise Ada
.Strings
.Length_Error
;
1198 (Source
: in out Bounded_Wide_String
;
1199 Position
: in Positive;
1200 New_Item
: in Wide_String;
1201 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1203 Endpos
: constant Positive := Position
+ New_Item
'Length - 1;
1204 Slen
: constant Natural := Source
.Length
;
1208 if Position
> Slen
+ 1 then
1209 raise Ada
.Strings
.Index_Error
;
1211 elsif Endpos
<= Slen
then
1212 Source
.Data
(Position
.. Endpos
) := New_Item
;
1214 elsif Endpos
<= Max_Length
then
1215 Source
.Data
(Position
.. Endpos
) := New_Item
;
1216 Source
.Length
:= Endpos
;
1219 Source
.Length
:= Max_Length
;
1220 Droplen
:= Endpos
- Max_Length
;
1223 when Strings
.Right
=>
1224 Source
.Data
(Position
.. Max_Length
) :=
1225 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1227 when Strings
.Left
=>
1228 if New_Item
'Length > Max_Length
then
1229 Source
.Data
(1 .. Max_Length
) :=
1230 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1234 Source
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1235 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1238 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1242 when Strings
.Error
=>
1243 raise Ada
.Strings
.Length_Error
;
1248 ---------------------
1249 -- Replace_Element --
1250 ---------------------
1252 procedure Replace_Element
1253 (Source
: in out Bounded_Wide_String
;
1254 Index
: in Positive;
1255 By
: in Wide_Character)
1258 if Index
<= Source
.Length
then
1259 Source
.Data
(Index
) := By
;
1261 raise Ada
.Strings
.Index_Error
;
1263 end Replace_Element
;
1269 function Replace_Slice
1270 (Source
: in Bounded_Wide_String
;
1273 By
: in Wide_String;
1274 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1275 return Bounded_Wide_String
1277 Slen
: constant Natural := Source
.Length
;
1280 if Low
> Slen
+ 1 then
1281 raise Strings
.Index_Error
;
1283 elsif High
< Low
then
1284 return Insert
(Source
, Low
, By
, Drop
);
1288 Blen
: constant Natural := Natural'Max (0, Low
- 1);
1289 Alen
: constant Natural := Natural'Max (0, Slen
- High
);
1290 Tlen
: constant Natural := Blen
+ By
'Length + Alen
;
1291 Droplen
: constant Integer := Tlen
- Max_Length
;
1292 Result
: Bounded_Wide_String
;
1294 -- Tlen is the total length of the result string before any
1295 -- truncation. Blen and Alen are the lengths of the pieces
1296 -- of the original string that end up in the result string
1297 -- before and after the replaced slice.
1300 if Droplen
<= 0 then
1301 Result
.Length
:= Tlen
;
1302 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1303 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1304 Result
.Data
(Low
+ By
'Length .. Tlen
) :=
1305 Source
.Data
(High
+ 1 .. Slen
);
1308 Result
.Length
:= Max_Length
;
1311 when Strings
.Right
=>
1312 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1314 if Droplen
> Alen
then
1315 Result
.Data
(Low
.. Max_Length
) :=
1316 By
(By
'First .. By
'First + Max_Length
- Low
);
1318 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1319 Result
.Data
(Low
+ By
'Length .. Max_Length
) :=
1320 Source
.Data
(High
+ 1 .. Slen
- Droplen
);
1323 when Strings
.Left
=>
1324 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1325 Source
.Data
(High
+ 1 .. Slen
);
1327 if Droplen
>= Blen
then
1328 Result
.Data
(1 .. Max_Length
- Alen
) :=
1329 By
(By
'Last - (Max_Length
- Alen
) + 1 .. By
'Last);
1332 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) := By
;
1333 Result
.Data
(1 .. Blen
- Droplen
) :=
1334 Source
.Data
(Droplen
+ 1 .. Blen
);
1337 when Strings
.Error
=>
1338 raise Ada
.Strings
.Length_Error
;
1347 procedure Replace_Slice
1348 (Source
: in out Bounded_Wide_String
;
1351 By
: in Wide_String;
1352 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1355 -- We do a double copy here because this is one of the situations
1356 -- in which we move data to the right, and at least at the moment,
1357 -- GNAT is not handling such cases correctly ???
1359 Source
:= Replace_Slice
(Source
, Low
, High
, By
, Drop
);
1367 (Count
: in Natural;
1368 Item
: in Wide_Character;
1369 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1370 return Bounded_Wide_String
1372 Result
: Bounded_Wide_String
;
1375 if Count
<= Max_Length
then
1376 Result
.Length
:= Count
;
1378 elsif Drop
= Strings
.Error
then
1379 raise Ada
.Strings
.Length_Error
;
1382 Result
.Length
:= Max_Length
;
1385 Result
.Data
(1 .. Result
.Length
) := (others => Item
);
1390 (Count
: in Natural;
1391 Item
: in Wide_String;
1392 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1393 return Bounded_Wide_String
1395 Length
: constant Integer := Count
* Item
'Length;
1396 Result
: Bounded_Wide_String
;
1400 if Length
<= Max_Length
then
1401 Result
.Length
:= Length
;
1406 for J
in 1 .. Count
loop
1407 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1408 Indx
:= Indx
+ Item
'Length;
1413 Result
.Length
:= Max_Length
;
1416 when Strings
.Right
=>
1419 while Indx
+ Item
'Length <= Max_Length
+ 1 loop
1420 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1421 Indx
:= Indx
+ Item
'Length;
1424 Result
.Data
(Indx
.. Max_Length
) :=
1425 Item
(Item
'First .. Item
'First + Max_Length
- Indx
);
1427 when Strings
.Left
=>
1430 while Indx
- Item
'Length >= 1 loop
1431 Result
.Data
(Indx
- (Item
'Length - 1) .. Indx
) := Item
;
1432 Indx
:= Indx
- Item
'Length;
1435 Result
.Data
(1 .. Indx
) :=
1436 Item
(Item
'Last - Indx
+ 1 .. Item
'Last);
1438 when Strings
.Error
=>
1439 raise Ada
.Strings
.Length_Error
;
1447 (Count
: in Natural;
1448 Item
: in Bounded_Wide_String
;
1449 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1450 return Bounded_Wide_String
1453 return Replicate
(Count
, Item
.Data
(1 .. Item
.Length
), Drop
);
1461 (Source
: Bounded_Wide_String
;
1467 -- Note: test of High > Length is in accordance with AI95-00128
1469 if Low
> Source
.Length
+ 1 or else High
> Source
.Length
then
1474 Result
: Wide_String (1 .. High
- Low
+ 1);
1477 Result
:= Source
.Data
(Low
.. High
);
1488 (Source
: in Bounded_Wide_String
;
1490 Pad
: in Wide_Character := Wide_Space
;
1491 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1492 return Bounded_Wide_String
1494 Result
: Bounded_Wide_String
;
1495 Slen
: constant Natural := Source
.Length
;
1496 Npad
: constant Integer := Count
- Slen
;
1500 Result
.Length
:= Count
;
1501 Result
.Data
(1 .. Count
) :=
1502 Source
.Data
(Slen
- (Count
- 1) .. Slen
);
1504 elsif Count
<= Max_Length
then
1505 Result
.Length
:= Count
;
1506 Result
.Data
(1 .. Npad
) := (others => Pad
);
1507 Result
.Data
(Npad
+ 1 .. Count
) := Source
.Data
(1 .. Slen
);
1510 Result
.Length
:= Max_Length
;
1513 when Strings
.Right
=>
1514 if Npad
>= Max_Length
then
1515 Result
.Data
:= (others => Pad
);
1518 Result
.Data
(1 .. Npad
) := (others => Pad
);
1519 Result
.Data
(Npad
+ 1 .. Max_Length
) :=
1520 Source
.Data
(1 .. Max_Length
- Npad
);
1523 when Strings
.Left
=>
1524 Result
.Data
(1 .. Max_Length
- Slen
) := (others => Pad
);
1525 Result
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1526 Source
.Data
(1 .. Slen
);
1528 when Strings
.Error
=>
1529 raise Ada
.Strings
.Length_Error
;
1537 (Source
: in out Bounded_Wide_String
;
1539 Pad
: in Wide_Character := Wide_Space
;
1540 Drop
: in Truncation
:= Error
)
1542 Slen
: constant Natural := Source
.Length
;
1543 Npad
: constant Integer := Count
- Slen
;
1544 Temp
: Wide_String (1 .. Max_Length
) := Source
.Data
;
1548 Source
.Length
:= Count
;
1549 Source
.Data
(1 .. Count
) :=
1550 Temp
(Slen
- (Count
- 1) .. Slen
);
1552 elsif Count
<= Max_Length
then
1553 Source
.Length
:= Count
;
1554 Source
.Data
(1 .. Npad
) := (others => Pad
);
1555 Source
.Data
(Npad
+ 1 .. Count
) := Temp
(1 .. Slen
);
1558 Source
.Length
:= Max_Length
;
1561 when Strings
.Right
=>
1562 if Npad
>= Max_Length
then
1563 Source
.Data
:= (others => Pad
);
1566 Source
.Data
(1 .. Npad
) := (others => Pad
);
1567 Source
.Data
(Npad
+ 1 .. Max_Length
) :=
1568 Temp
(1 .. Max_Length
- Npad
);
1571 when Strings
.Left
=>
1572 for J
in 1 .. Max_Length
- Slen
loop
1573 Source
.Data
(J
) := Pad
;
1576 Source
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1579 when Strings
.Error
=>
1580 raise Ada
.Strings
.Length_Error
;
1586 ----------------------------
1587 -- To_Bounded_Wide_String --
1588 ----------------------------
1590 function To_Bounded_Wide_String
1591 (Source
: in Wide_String;
1592 Drop
: in Strings
.Truncation
:= Strings
.Error
)
1593 return Bounded_Wide_String
1595 Slen
: constant Natural := Source
'Length;
1596 Result
: Bounded_Wide_String
;
1599 if Slen
<= Max_Length
then
1600 Result
.Length
:= Slen
;
1601 Result
.Data
(1 .. Slen
) := Source
;
1605 when Strings
.Right
=>
1606 Result
.Length
:= Max_Length
;
1607 Result
.Data
(1 .. Max_Length
) :=
1608 Source
(Source
'First .. Source
'First - 1 + Max_Length
);
1610 when Strings
.Left
=>
1611 Result
.Length
:= Max_Length
;
1612 Result
.Data
(1 .. Max_Length
) :=
1613 Source
(Source
'Last - (Max_Length
- 1) .. Source
'Last);
1615 when Strings
.Error
=>
1616 raise Ada
.Strings
.Length_Error
;
1621 end To_Bounded_Wide_String
;
1623 --------------------
1624 -- To_Wide_String --
1625 --------------------
1627 function To_Wide_String
1628 (Source
: in Bounded_Wide_String
)
1632 return Source
.Data
(1 .. Source
.Length
);
1640 (Source
: in Bounded_Wide_String
;
1641 Mapping
: in Wide_Maps
.Wide_Character_Mapping
)
1642 return Bounded_Wide_String
1644 Result
: Bounded_Wide_String
;
1647 Result
.Length
:= Source
.Length
;
1649 for J
in 1 .. Source
.Length
loop
1650 Result
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1657 (Source
: in out Bounded_Wide_String
;
1658 Mapping
: in Wide_Maps
.Wide_Character_Mapping
)
1661 for J
in 1 .. Source
.Length
loop
1662 Source
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1667 (Source
: in Bounded_Wide_String
;
1668 Mapping
: in Wide_Maps
.Wide_Character_Mapping_Function
)
1669 return Bounded_Wide_String
1671 Result
: Bounded_Wide_String
;
1674 Result
.Length
:= Source
.Length
;
1676 for J
in 1 .. Source
.Length
loop
1677 Result
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1684 (Source
: in out Bounded_Wide_String
;
1685 Mapping
: in Wide_Maps
.Wide_Character_Mapping_Function
)
1688 for J
in 1 .. Source
.Length
loop
1689 Source
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1698 (Source
: in Bounded_Wide_String
;
1700 return Bounded_Wide_String
1702 Result
: Bounded_Wide_String
;
1703 Last
: Natural := Source
.Length
;
1704 First
: Positive := 1;
1707 if Side
= Left
or else Side
= Both
then
1708 while First
<= Last
and then Source
.Data
(First
) = ' ' loop
1713 if Side
= Right
or else Side
= Both
then
1714 while Last
>= First
and then Source
.Data
(Last
) = ' ' loop
1719 Result
.Length
:= Last
- First
+ 1;
1720 Result
.Data
(1 .. Result
.Length
) := Source
.Data
(First
.. Last
);
1726 (Source
: in out Bounded_Wide_String
;
1729 Last
: Length_Range
:= Source
.Length
;
1730 First
: Positive := 1;
1731 Temp
: Wide_String (1 .. Max_Length
);
1734 Temp
(1 .. Last
) := Source
.Data
(1 .. Last
);
1736 if Side
= Left
or else Side
= Both
then
1737 while First
<= Last
and then Temp
(First
) = ' ' loop
1742 if Side
= Right
or else Side
= Both
then
1743 while Last
>= First
and then Temp
(Last
) = ' ' loop
1748 Source
.Length
:= Last
- First
+ 1;
1749 Source
.Data
(1 .. Source
.Length
) := Temp
(First
.. Last
);
1754 (Source
: in Bounded_Wide_String
;
1755 Left
: in Wide_Maps
.Wide_Character_Set
;
1756 Right
: in Wide_Maps
.Wide_Character_Set
)
1757 return Bounded_Wide_String
1759 Result
: Bounded_Wide_String
;
1762 for First
in 1 .. Source
.Length
loop
1763 if not Is_In
(Source
.Data
(First
), Left
) then
1764 for Last
in reverse First
.. Source
.Length
loop
1765 if not Is_In
(Source
.Data
(Last
), Right
) then
1766 Result
.Length
:= Last
- First
+ 1;
1767 Result
.Data
(1 .. Result
.Length
) :=
1768 Source
.Data
(First
.. Last
);
1780 (Source
: in out Bounded_Wide_String
;
1781 Left
: in Wide_Maps
.Wide_Character_Set
;
1782 Right
: in Wide_Maps
.Wide_Character_Set
)
1785 for First
in 1 .. Source
.Length
loop
1786 if not Is_In
(Source
.Data
(First
), Left
) then
1787 for Last
in reverse First
.. Source
.Length
loop
1788 if not Is_In
(Source
.Data
(Last
), Right
) then
1790 Source
.Length
:= Last
;
1793 Source
.Length
:= Last
- First
+ 1;
1794 Source
.Data
(1 .. Source
.Length
) :=
1795 Source
.Data
(First
.. Last
);
1809 end Generic_Bounded_Length
;
1811 end Ada
.Strings
.Wide_Bounded
;