1 ------------------------------------------------------------------------------
3 -- GNAT RUN-TIME COMPONENTS --
5 -- A D A . S T R I N G S . W I D E _ S U P E R B O U N D E D --
9 -- Copyright (C) 2003-2009, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. --
18 -- As a special exception under Section 7 of GPL version 3, you are granted --
19 -- additional permissions described in the GCC Runtime Library Exception, --
20 -- version 3.1, as published by the Free Software Foundation. --
22 -- You should have received a copy of the GNU General Public License and --
23 -- a copy of the GCC Runtime Library Exception along with this program; --
24 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
25 -- <http://www.gnu.org/licenses/>. --
27 -- GNAT was originally developed by the GNAT team at New York University. --
28 -- Extensive contributions were provided by Ada Core Technologies Inc. --
30 ------------------------------------------------------------------------------
32 with Ada
.Strings
.Wide_Maps
; use Ada
.Strings
.Wide_Maps
;
33 with Ada
.Strings
.Wide_Search
;
35 package body Ada
.Strings
.Wide_Superbounded
is
43 Right
: Super_String
) return Super_String
45 Result
: Super_String
(Left
.Max_Length
);
46 Llen
: constant Natural := Left
.Current_Length
;
47 Rlen
: constant Natural := Right
.Current_Length
;
48 Nlen
: constant Natural := Llen
+ Rlen
;
51 if Nlen
> Left
.Max_Length
then
52 raise Ada
.Strings
.Length_Error
;
54 Result
.Current_Length
:= Nlen
;
55 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
56 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
64 Right
: Wide_String) return Super_String
66 Result
: Super_String
(Left
.Max_Length
);
67 Llen
: constant Natural := Left
.Current_Length
;
69 Nlen
: constant Natural := Llen
+ Right
'Length;
72 if Nlen
> Left
.Max_Length
then
73 raise Ada
.Strings
.Length_Error
;
75 Result
.Current_Length
:= Nlen
;
76 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
77 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
;
84 Right
: Super_String
) return Super_String
86 Result
: Super_String
(Right
.Max_Length
);
87 Llen
: constant Natural := Left
'Length;
88 Rlen
: constant Natural := Right
.Current_Length
;
89 Nlen
: constant Natural := Llen
+ Rlen
;
92 if Nlen
> Right
.Max_Length
then
93 raise Ada
.Strings
.Length_Error
;
95 Result
.Current_Length
:= Nlen
;
96 Result
.Data
(1 .. Llen
) := Left
;
97 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
104 (Left
: Super_String
;
105 Right
: Wide_Character) return Super_String
107 Result
: Super_String
(Left
.Max_Length
);
108 Llen
: constant Natural := Left
.Current_Length
;
111 if Llen
= Left
.Max_Length
then
112 raise Ada
.Strings
.Length_Error
;
114 Result
.Current_Length
:= Llen
+ 1;
115 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
116 Result
.Data
(Result
.Current_Length
) := Right
;
123 (Left
: Wide_Character;
124 Right
: Super_String
) return Super_String
126 Result
: Super_String
(Right
.Max_Length
);
127 Rlen
: constant Natural := Right
.Current_Length
;
130 if Rlen
= Right
.Max_Length
then
131 raise Ada
.Strings
.Length_Error
;
133 Result
.Current_Length
:= Rlen
+ 1;
134 Result
.Data
(1) := Left
;
135 Result
.Data
(2 .. Result
.Current_Length
) := Right
.Data
(1 .. Rlen
);
146 (Left
: Super_String
;
147 Right
: Super_String
) return Boolean
150 return Left
.Current_Length
= Right
.Current_Length
151 and then Left
.Data
(1 .. Left
.Current_Length
) =
152 Right
.Data
(1 .. Right
.Current_Length
);
156 (Left
: Super_String
;
157 Right
: Wide_String) return Boolean
160 return Left
.Current_Length
= Right
'Length
161 and then Left
.Data
(1 .. Left
.Current_Length
) = Right
;
166 Right
: Super_String
) return Boolean
169 return Left
'Length = Right
.Current_Length
170 and then Left
= Right
.Data
(1 .. Right
.Current_Length
);
178 (Left
: Super_String
;
179 Right
: Super_String
) return Boolean
182 return Left
.Data
(1 .. Left
.Current_Length
) >
183 Right
.Data
(1 .. Right
.Current_Length
);
187 (Left
: Super_String
;
188 Right
: Wide_String) return Boolean
191 return Left
.Data
(1 .. Left
.Current_Length
) > Right
;
196 Right
: Super_String
) return Boolean
199 return Left
> Right
.Data
(1 .. Right
.Current_Length
);
202 ----------------------
203 -- Greater_Or_Equal --
204 ----------------------
206 function Greater_Or_Equal
207 (Left
: Super_String
;
208 Right
: Super_String
) return Boolean
211 return Left
.Data
(1 .. Left
.Current_Length
) >=
212 Right
.Data
(1 .. Right
.Current_Length
);
213 end Greater_Or_Equal
;
215 function Greater_Or_Equal
216 (Left
: Super_String
;
217 Right
: Wide_String) return Boolean
220 return Left
.Data
(1 .. Left
.Current_Length
) >= Right
;
221 end Greater_Or_Equal
;
223 function Greater_Or_Equal
225 Right
: Super_String
) return Boolean
228 return Left
>= Right
.Data
(1 .. Right
.Current_Length
);
229 end Greater_Or_Equal
;
236 (Left
: Super_String
;
237 Right
: Super_String
) return Boolean
240 return Left
.Data
(1 .. Left
.Current_Length
) <
241 Right
.Data
(1 .. Right
.Current_Length
);
245 (Left
: Super_String
;
246 Right
: Wide_String) return Boolean
249 return Left
.Data
(1 .. Left
.Current_Length
) < Right
;
254 Right
: Super_String
) return Boolean
257 return Left
< Right
.Data
(1 .. Right
.Current_Length
);
264 function Less_Or_Equal
265 (Left
: Super_String
;
266 Right
: Super_String
) return Boolean
269 return Left
.Data
(1 .. Left
.Current_Length
) <=
270 Right
.Data
(1 .. Right
.Current_Length
);
273 function Less_Or_Equal
274 (Left
: Super_String
;
275 Right
: Wide_String) return Boolean
278 return Left
.Data
(1 .. Left
.Current_Length
) <= Right
;
281 function Less_Or_Equal
283 Right
: Super_String
) return Boolean
286 return Left
<= Right
.Data
(1 .. Right
.Current_Length
);
289 ----------------------
290 -- Set_Super_String --
291 ----------------------
293 procedure Set_Super_String
294 (Target
: out Super_String
;
295 Source
: Wide_String;
296 Drop
: Truncation
:= Error
)
298 Slen
: constant Natural := Source
'Length;
299 Max_Length
: constant Positive := Target
.Max_Length
;
302 if Slen
<= Max_Length
then
303 Target
.Current_Length
:= Slen
;
304 Target
.Data
(1 .. Slen
) := Source
;
308 when Strings
.Right
=>
309 Target
.Current_Length
:= Max_Length
;
310 Target
.Data
(1 .. Max_Length
) :=
311 Source
(Source
'First .. Source
'First - 1 + Max_Length
);
314 Target
.Current_Length
:= Max_Length
;
315 Target
.Data
(1 .. Max_Length
) :=
316 Source
(Source
'Last - (Max_Length
- 1) .. Source
'Last);
318 when Strings
.Error
=>
319 raise Ada
.Strings
.Length_Error
;
322 end Set_Super_String
;
328 -- Case of Super_String and Super_String
330 function Super_Append
331 (Left
: Super_String
;
332 Right
: Super_String
;
333 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
335 Max_Length
: constant Positive := Left
.Max_Length
;
336 Result
: Super_String
(Max_Length
);
337 Llen
: constant Natural := Left
.Current_Length
;
338 Rlen
: constant Natural := Right
.Current_Length
;
339 Nlen
: constant Natural := Llen
+ Rlen
;
342 if Nlen
<= Max_Length
then
343 Result
.Current_Length
:= Nlen
;
344 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
345 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
348 Result
.Current_Length
:= Max_Length
;
351 when Strings
.Right
=>
352 if Llen
>= Max_Length
then -- only case is Llen = Max_Length
353 Result
.Data
:= Left
.Data
;
356 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
357 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
358 Right
.Data
(1 .. Max_Length
- Llen
);
362 if Rlen
>= Max_Length
then -- only case is Rlen = Max_Length
363 Result
.Data
:= Right
.Data
;
366 Result
.Data
(1 .. Max_Length
- Rlen
) :=
367 Left
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
368 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
369 Right
.Data
(1 .. Rlen
);
372 when Strings
.Error
=>
373 raise Ada
.Strings
.Length_Error
;
380 procedure Super_Append
381 (Source
: in out Super_String
;
382 New_Item
: Super_String
;
383 Drop
: Truncation
:= Error
)
385 Max_Length
: constant Positive := Source
.Max_Length
;
386 Llen
: constant Natural := Source
.Current_Length
;
387 Rlen
: constant Natural := New_Item
.Current_Length
;
388 Nlen
: constant Natural := Llen
+ Rlen
;
391 if Nlen
<= Max_Length
then
392 Source
.Current_Length
:= Nlen
;
393 Source
.Data
(Llen
+ 1 .. Nlen
) := New_Item
.Data
(1 .. Rlen
);
396 Source
.Current_Length
:= Max_Length
;
399 when Strings
.Right
=>
400 if Llen
< Max_Length
then
401 Source
.Data
(Llen
+ 1 .. Max_Length
) :=
402 New_Item
.Data
(1 .. Max_Length
- Llen
);
406 if Rlen
>= Max_Length
then -- only case is Rlen = Max_Length
407 Source
.Data
:= New_Item
.Data
;
410 Source
.Data
(1 .. Max_Length
- Rlen
) :=
411 Source
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
412 Source
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
413 New_Item
.Data
(1 .. Rlen
);
416 when Strings
.Error
=>
417 raise Ada
.Strings
.Length_Error
;
423 -- Case of Super_String and Wide_String
425 function Super_Append
426 (Left
: Super_String
;
428 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
430 Max_Length
: constant Positive := Left
.Max_Length
;
431 Result
: Super_String
(Max_Length
);
432 Llen
: constant Natural := Left
.Current_Length
;
433 Rlen
: constant Natural := Right
'Length;
434 Nlen
: constant Natural := Llen
+ Rlen
;
437 if Nlen
<= Max_Length
then
438 Result
.Current_Length
:= Nlen
;
439 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
440 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
;
443 Result
.Current_Length
:= Max_Length
;
446 when Strings
.Right
=>
447 if Llen
>= Max_Length
then -- only case is Llen = Max_Length
448 Result
.Data
:= Left
.Data
;
451 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
452 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
453 Right
(Right
'First .. Right
'First - 1 +
459 if Rlen
>= Max_Length
then
460 Result
.Data
(1 .. Max_Length
) :=
461 Right
(Right
'Last - (Max_Length
- 1) .. Right
'Last);
464 Result
.Data
(1 .. Max_Length
- Rlen
) :=
465 Left
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
466 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
470 when Strings
.Error
=>
471 raise Ada
.Strings
.Length_Error
;
478 procedure Super_Append
479 (Source
: in out Super_String
;
480 New_Item
: Wide_String;
481 Drop
: Truncation
:= Error
)
483 Max_Length
: constant Positive := Source
.Max_Length
;
484 Llen
: constant Natural := Source
.Current_Length
;
485 Rlen
: constant Natural := New_Item
'Length;
486 Nlen
: constant Natural := Llen
+ Rlen
;
489 if Nlen
<= Max_Length
then
490 Source
.Current_Length
:= Nlen
;
491 Source
.Data
(Llen
+ 1 .. Nlen
) := New_Item
;
494 Source
.Current_Length
:= Max_Length
;
497 when Strings
.Right
=>
498 if Llen
< Max_Length
then
499 Source
.Data
(Llen
+ 1 .. Max_Length
) :=
500 New_Item
(New_Item
'First ..
501 New_Item
'First - 1 + Max_Length
- Llen
);
505 if Rlen
>= Max_Length
then
506 Source
.Data
(1 .. Max_Length
) :=
507 New_Item
(New_Item
'Last - (Max_Length
- 1) ..
511 Source
.Data
(1 .. Max_Length
- Rlen
) :=
512 Source
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
513 Source
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
517 when Strings
.Error
=>
518 raise Ada
.Strings
.Length_Error
;
524 -- Case of Wide_String and Super_String
526 function Super_Append
528 Right
: Super_String
;
529 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
531 Max_Length
: constant Positive := Right
.Max_Length
;
532 Result
: Super_String
(Max_Length
);
533 Llen
: constant Natural := Left
'Length;
534 Rlen
: constant Natural := Right
.Current_Length
;
535 Nlen
: constant Natural := Llen
+ Rlen
;
538 if Nlen
<= Max_Length
then
539 Result
.Current_Length
:= Nlen
;
540 Result
.Data
(1 .. Llen
) := Left
;
541 Result
.Data
(Llen
+ 1 .. Llen
+ Rlen
) := Right
.Data
(1 .. Rlen
);
544 Result
.Current_Length
:= Max_Length
;
547 when Strings
.Right
=>
548 if Llen
>= Max_Length
then
549 Result
.Data
(1 .. Max_Length
) :=
550 Left
(Left
'First .. Left
'First + (Max_Length
- 1));
553 Result
.Data
(1 .. Llen
) := Left
;
554 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
555 Right
.Data
(1 .. Max_Length
- Llen
);
559 if Rlen
>= Max_Length
then
560 Result
.Data
(1 .. Max_Length
) :=
561 Right
.Data
(Rlen
- (Max_Length
- 1) .. Rlen
);
564 Result
.Data
(1 .. Max_Length
- Rlen
) :=
565 Left
(Left
'Last - (Max_Length
- Rlen
- 1) .. Left
'Last);
566 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
567 Right
.Data
(1 .. Rlen
);
570 when Strings
.Error
=>
571 raise Ada
.Strings
.Length_Error
;
578 -- Case of Super_String and Wide_Character
580 function Super_Append
581 (Left
: Super_String
;
582 Right
: Wide_Character;
583 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
585 Max_Length
: constant Positive := Left
.Max_Length
;
586 Result
: Super_String
(Max_Length
);
587 Llen
: constant Natural := Left
.Current_Length
;
590 if Llen
< Max_Length
then
591 Result
.Current_Length
:= Llen
+ 1;
592 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
593 Result
.Data
(Llen
+ 1) := Right
;
598 when Strings
.Right
=>
602 Result
.Current_Length
:= Max_Length
;
603 Result
.Data
(1 .. Max_Length
- 1) :=
604 Left
.Data
(2 .. Max_Length
);
605 Result
.Data
(Max_Length
) := Right
;
608 when Strings
.Error
=>
609 raise Ada
.Strings
.Length_Error
;
614 procedure Super_Append
615 (Source
: in out Super_String
;
616 New_Item
: Wide_Character;
617 Drop
: Truncation
:= Error
)
619 Max_Length
: constant Positive := Source
.Max_Length
;
620 Llen
: constant Natural := Source
.Current_Length
;
623 if Llen
< Max_Length
then
624 Source
.Current_Length
:= Llen
+ 1;
625 Source
.Data
(Llen
+ 1) := New_Item
;
628 Source
.Current_Length
:= Max_Length
;
631 when Strings
.Right
=>
635 Source
.Data
(1 .. Max_Length
- 1) :=
636 Source
.Data
(2 .. Max_Length
);
637 Source
.Data
(Max_Length
) := New_Item
;
639 when Strings
.Error
=>
640 raise Ada
.Strings
.Length_Error
;
646 -- Case of Wide_Character and Super_String
648 function Super_Append
649 (Left
: Wide_Character;
650 Right
: Super_String
;
651 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
653 Max_Length
: constant Positive := Right
.Max_Length
;
654 Result
: Super_String
(Max_Length
);
655 Rlen
: constant Natural := Right
.Current_Length
;
658 if Rlen
< Max_Length
then
659 Result
.Current_Length
:= Rlen
+ 1;
660 Result
.Data
(1) := Left
;
661 Result
.Data
(2 .. Rlen
+ 1) := Right
.Data
(1 .. Rlen
);
666 when Strings
.Right
=>
667 Result
.Current_Length
:= Max_Length
;
668 Result
.Data
(1) := Left
;
669 Result
.Data
(2 .. Max_Length
) :=
670 Right
.Data
(1 .. Max_Length
- 1);
676 when Strings
.Error
=>
677 raise Ada
.Strings
.Length_Error
;
687 (Source
: Super_String
;
688 Pattern
: Wide_String;
689 Mapping
: Wide_Maps
.Wide_Character_Mapping
:= Wide_Maps
.Identity
)
695 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Mapping
);
699 (Source
: Super_String
;
700 Pattern
: Wide_String;
701 Mapping
: Wide_Maps
.Wide_Character_Mapping_Function
) return Natural
706 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Mapping
);
710 (Source
: Super_String
;
711 Set
: Wide_Maps
.Wide_Character_Set
) return Natural
714 return Wide_Search
.Count
(Source
.Data
(1 .. Source
.Current_Length
), Set
);
721 function Super_Delete
722 (Source
: Super_String
;
724 Through
: Natural) return Super_String
726 Result
: Super_String
(Source
.Max_Length
);
727 Slen
: constant Natural := Source
.Current_Length
;
728 Num_Delete
: constant Integer := Through
- From
+ 1;
731 if Num_Delete
<= 0 then
734 elsif From
> Slen
+ 1 then
735 raise Ada
.Strings
.Index_Error
;
737 elsif Through
>= Slen
then
738 Result
.Current_Length
:= From
- 1;
739 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
743 Result
.Current_Length
:= Slen
- Num_Delete
;
744 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
745 Result
.Data
(From
.. Result
.Current_Length
) :=
746 Source
.Data
(Through
+ 1 .. Slen
);
751 procedure Super_Delete
752 (Source
: in out Super_String
;
756 Slen
: constant Natural := Source
.Current_Length
;
757 Num_Delete
: constant Integer := Through
- From
+ 1;
760 if Num_Delete
<= 0 then
763 elsif From
> Slen
+ 1 then
764 raise Ada
.Strings
.Index_Error
;
766 elsif Through
>= Slen
then
767 Source
.Current_Length
:= From
- 1;
770 Source
.Current_Length
:= Slen
- Num_Delete
;
771 Source
.Data
(From
.. Source
.Current_Length
) :=
772 Source
.Data
(Through
+ 1 .. Slen
);
780 function Super_Element
781 (Source
: Super_String
;
782 Index
: Positive) return Wide_Character
785 if Index
<= Source
.Current_Length
then
786 return Source
.Data
(Index
);
788 raise Strings
.Index_Error
;
792 ----------------------
793 -- Super_Find_Token --
794 ----------------------
796 procedure Super_Find_Token
797 (Source
: Super_String
;
798 Set
: Wide_Maps
.Wide_Character_Set
;
799 Test
: Strings
.Membership
;
800 First
: out Positive;
804 Wide_Search
.Find_Token
805 (Source
.Data
(1 .. Source
.Current_Length
), Set
, Test
, First
, Last
);
806 end Super_Find_Token
;
813 (Source
: Super_String
;
815 Pad
: Wide_Character := Wide_Space
;
816 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
818 Max_Length
: constant Positive := Source
.Max_Length
;
819 Result
: Super_String
(Max_Length
);
820 Slen
: constant Natural := Source
.Current_Length
;
821 Npad
: constant Integer := Count
- Slen
;
825 Result
.Current_Length
:= Count
;
826 Result
.Data
(1 .. Count
) := Source
.Data
(1 .. Count
);
828 elsif Count
<= Max_Length
then
829 Result
.Current_Length
:= Count
;
830 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
831 Result
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
834 Result
.Current_Length
:= Max_Length
;
837 when Strings
.Right
=>
838 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
839 Result
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
842 if Npad
>= Max_Length
then
843 Result
.Data
:= (others => Pad
);
846 Result
.Data
(1 .. Max_Length
- Npad
) :=
847 Source
.Data
(Count
- Max_Length
+ 1 .. Slen
);
848 Result
.Data
(Max_Length
- Npad
+ 1 .. Max_Length
) :=
852 when Strings
.Error
=>
853 raise Ada
.Strings
.Length_Error
;
861 (Source
: in out Super_String
;
863 Pad
: Wide_Character := Wide_Space
;
864 Drop
: Truncation
:= Error
)
866 Max_Length
: constant Positive := Source
.Max_Length
;
867 Slen
: constant Natural := Source
.Current_Length
;
868 Npad
: constant Integer := Count
- Slen
;
869 Temp
: Wide_String (1 .. Max_Length
);
873 Source
.Current_Length
:= Count
;
875 elsif Count
<= Max_Length
then
876 Source
.Current_Length
:= Count
;
877 Source
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
880 Source
.Current_Length
:= Max_Length
;
883 when Strings
.Right
=>
884 Source
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
887 if Npad
> Max_Length
then
888 Source
.Data
:= (others => Pad
);
892 Source
.Data
(1 .. Max_Length
- Npad
) :=
893 Temp
(Count
- Max_Length
+ 1 .. Slen
);
895 for J
in Max_Length
- Npad
+ 1 .. Max_Length
loop
896 Source
.Data
(J
) := Pad
;
900 when Strings
.Error
=>
901 raise Ada
.Strings
.Length_Error
;
911 (Source
: Super_String
;
912 Pattern
: Wide_String;
913 Going
: Strings
.Direction
:= Strings
.Forward
;
914 Mapping
: Wide_Maps
.Wide_Character_Mapping
:= Wide_Maps
.Identity
)
918 return Wide_Search
.Index
919 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Going
, Mapping
);
923 (Source
: Super_String
;
924 Pattern
: Wide_String;
925 Going
: Direction
:= Forward
;
926 Mapping
: Wide_Maps
.Wide_Character_Mapping_Function
) return Natural
929 return Wide_Search
.Index
930 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Going
, Mapping
);
934 (Source
: Super_String
;
935 Set
: Wide_Maps
.Wide_Character_Set
;
936 Test
: Strings
.Membership
:= Strings
.Inside
;
937 Going
: Strings
.Direction
:= Strings
.Forward
) return Natural
940 return Wide_Search
.Index
941 (Source
.Data
(1 .. Source
.Current_Length
), Set
, Test
, Going
);
945 (Source
: Super_String
;
946 Pattern
: Wide_String;
948 Going
: Direction
:= Forward
;
949 Mapping
: Wide_Maps
.Wide_Character_Mapping
:= Wide_Maps
.Identity
)
953 return Wide_Search
.Index
954 (Source
.Data
(1 .. Source
.Current_Length
),
955 Pattern
, From
, Going
, Mapping
);
959 (Source
: Super_String
;
960 Pattern
: Wide_String;
962 Going
: Direction
:= Forward
;
963 Mapping
: Wide_Maps
.Wide_Character_Mapping_Function
) return Natural
966 return Wide_Search
.Index
967 (Source
.Data
(1 .. Source
.Current_Length
),
968 Pattern
, From
, Going
, Mapping
);
972 (Source
: Super_String
;
973 Set
: Wide_Maps
.Wide_Character_Set
;
975 Test
: Membership
:= Inside
;
976 Going
: Direction
:= Forward
) return Natural
979 return Wide_Search
.Index
980 (Source
.Data
(1 .. Source
.Current_Length
), Set
, From
, Test
, Going
);
983 ---------------------------
984 -- Super_Index_Non_Blank --
985 ---------------------------
987 function Super_Index_Non_Blank
988 (Source
: Super_String
;
989 Going
: Strings
.Direction
:= Strings
.Forward
) return Natural
993 Wide_Search
.Index_Non_Blank
994 (Source
.Data
(1 .. Source
.Current_Length
), Going
);
995 end Super_Index_Non_Blank
;
997 function Super_Index_Non_Blank
998 (Source
: Super_String
;
1000 Going
: Direction
:= Forward
) return Natural
1004 Wide_Search
.Index_Non_Blank
1005 (Source
.Data
(1 .. Source
.Current_Length
), From
, Going
);
1006 end Super_Index_Non_Blank
;
1012 function Super_Insert
1013 (Source
: Super_String
;
1015 New_Item
: Wide_String;
1016 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1018 Max_Length
: constant Positive := Source
.Max_Length
;
1019 Result
: Super_String
(Max_Length
);
1020 Slen
: constant Natural := Source
.Current_Length
;
1021 Nlen
: constant Natural := New_Item
'Length;
1022 Tlen
: constant Natural := Slen
+ Nlen
;
1023 Blen
: constant Natural := Before
- 1;
1024 Alen
: constant Integer := Slen
- Blen
;
1025 Droplen
: constant Integer := Tlen
- Max_Length
;
1027 -- Tlen is the length of the total string before possible truncation.
1028 -- Blen, Alen are the lengths of the before and after pieces of the
1033 raise Ada
.Strings
.Index_Error
;
1035 elsif Droplen
<= 0 then
1036 Result
.Current_Length
:= Tlen
;
1037 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1038 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1039 Result
.Data
(Before
+ Nlen
.. Tlen
) :=
1040 Source
.Data
(Before
.. Slen
);
1043 Result
.Current_Length
:= Max_Length
;
1046 when Strings
.Right
=>
1047 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1049 if Droplen
> Alen
then
1050 Result
.Data
(Before
.. Max_Length
) :=
1051 New_Item
(New_Item
'First
1052 .. New_Item
'First + Max_Length
- Before
);
1054 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1055 Result
.Data
(Before
+ Nlen
.. Max_Length
) :=
1056 Source
.Data
(Before
.. Slen
- Droplen
);
1059 when Strings
.Left
=>
1060 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1061 Source
.Data
(Before
.. Slen
);
1063 if Droplen
>= Blen
then
1064 Result
.Data
(1 .. Max_Length
- Alen
) :=
1065 New_Item
(New_Item
'Last - (Max_Length
- Alen
) + 1
1069 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) :=
1071 Result
.Data
(1 .. Blen
- Droplen
) :=
1072 Source
.Data
(Droplen
+ 1 .. Blen
);
1075 when Strings
.Error
=>
1076 raise Ada
.Strings
.Length_Error
;
1083 procedure Super_Insert
1084 (Source
: in out Super_String
;
1086 New_Item
: Wide_String;
1087 Drop
: Strings
.Truncation
:= Strings
.Error
)
1090 -- We do a double copy here because this is one of the situations
1091 -- in which we move data to the right, and at least at the moment,
1092 -- GNAT is not handling such cases correctly ???
1094 Source
:= Super_Insert
(Source
, Before
, New_Item
, Drop
);
1101 function Super_Length
(Source
: Super_String
) return Natural is
1103 return Source
.Current_Length
;
1106 ---------------------
1107 -- Super_Overwrite --
1108 ---------------------
1110 function Super_Overwrite
1111 (Source
: Super_String
;
1112 Position
: Positive;
1113 New_Item
: Wide_String;
1114 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1116 Max_Length
: constant Positive := Source
.Max_Length
;
1117 Result
: Super_String
(Max_Length
);
1118 Endpos
: constant Natural := Position
+ New_Item
'Length - 1;
1119 Slen
: constant Natural := Source
.Current_Length
;
1123 if Position
> Slen
+ 1 then
1124 raise Ada
.Strings
.Index_Error
;
1126 elsif New_Item
'Length = 0 then
1129 elsif Endpos
<= Slen
then
1130 Result
.Current_Length
:= Source
.Current_Length
;
1131 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
1132 Result
.Data
(Position
.. Endpos
) := New_Item
;
1135 elsif Endpos
<= Max_Length
then
1136 Result
.Current_Length
:= Endpos
;
1137 Result
.Data
(1 .. Position
- 1) := Source
.Data
(1 .. Position
- 1);
1138 Result
.Data
(Position
.. Endpos
) := New_Item
;
1142 Result
.Current_Length
:= Max_Length
;
1143 Droplen
:= Endpos
- Max_Length
;
1146 when Strings
.Right
=>
1147 Result
.Data
(1 .. Position
- 1) :=
1148 Source
.Data
(1 .. Position
- 1);
1150 Result
.Data
(Position
.. Max_Length
) :=
1151 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1154 when Strings
.Left
=>
1155 if New_Item
'Length >= Max_Length
then
1156 Result
.Data
(1 .. Max_Length
) :=
1157 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1162 Result
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1163 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1165 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1170 when Strings
.Error
=>
1171 raise Ada
.Strings
.Length_Error
;
1174 end Super_Overwrite
;
1176 procedure Super_Overwrite
1177 (Source
: in out Super_String
;
1178 Position
: Positive;
1179 New_Item
: Wide_String;
1180 Drop
: Strings
.Truncation
:= Strings
.Error
)
1182 Max_Length
: constant Positive := Source
.Max_Length
;
1183 Endpos
: constant Positive := Position
+ New_Item
'Length - 1;
1184 Slen
: constant Natural := Source
.Current_Length
;
1188 if Position
> Slen
+ 1 then
1189 raise Ada
.Strings
.Index_Error
;
1191 elsif Endpos
<= Slen
then
1192 Source
.Data
(Position
.. Endpos
) := New_Item
;
1194 elsif Endpos
<= Max_Length
then
1195 Source
.Data
(Position
.. Endpos
) := New_Item
;
1196 Source
.Current_Length
:= Endpos
;
1199 Source
.Current_Length
:= Max_Length
;
1200 Droplen
:= Endpos
- Max_Length
;
1203 when Strings
.Right
=>
1204 Source
.Data
(Position
.. Max_Length
) :=
1205 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1207 when Strings
.Left
=>
1208 if New_Item
'Length > Max_Length
then
1209 Source
.Data
(1 .. Max_Length
) :=
1210 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1214 Source
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1215 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1218 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1222 when Strings
.Error
=>
1223 raise Ada
.Strings
.Length_Error
;
1226 end Super_Overwrite
;
1228 ---------------------------
1229 -- Super_Replace_Element --
1230 ---------------------------
1232 procedure Super_Replace_Element
1233 (Source
: in out Super_String
;
1235 By
: Wide_Character)
1238 if Index
<= Source
.Current_Length
then
1239 Source
.Data
(Index
) := By
;
1241 raise Ada
.Strings
.Index_Error
;
1243 end Super_Replace_Element
;
1245 -------------------------
1246 -- Super_Replace_Slice --
1247 -------------------------
1249 function Super_Replace_Slice
1250 (Source
: Super_String
;
1254 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1256 Max_Length
: constant Positive := Source
.Max_Length
;
1257 Slen
: constant Natural := Source
.Current_Length
;
1260 if Low
> Slen
+ 1 then
1261 raise Strings
.Index_Error
;
1263 elsif High
< Low
then
1264 return Super_Insert
(Source
, Low
, By
, Drop
);
1268 Blen
: constant Natural := Natural'Max (0, Low
- 1);
1269 Alen
: constant Natural := Natural'Max (0, Slen
- High
);
1270 Tlen
: constant Natural := Blen
+ By
'Length + Alen
;
1271 Droplen
: constant Integer := Tlen
- Max_Length
;
1272 Result
: Super_String
(Max_Length
);
1274 -- Tlen is the total length of the result string before any
1275 -- truncation. Blen and Alen are the lengths of the pieces
1276 -- of the original string that end up in the result string
1277 -- before and after the replaced slice.
1280 if Droplen
<= 0 then
1281 Result
.Current_Length
:= Tlen
;
1282 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1283 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1284 Result
.Data
(Low
+ By
'Length .. Tlen
) :=
1285 Source
.Data
(High
+ 1 .. Slen
);
1288 Result
.Current_Length
:= Max_Length
;
1291 when Strings
.Right
=>
1292 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1294 if Droplen
> Alen
then
1295 Result
.Data
(Low
.. Max_Length
) :=
1296 By
(By
'First .. By
'First + Max_Length
- Low
);
1298 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1299 Result
.Data
(Low
+ By
'Length .. Max_Length
) :=
1300 Source
.Data
(High
+ 1 .. Slen
- Droplen
);
1303 when Strings
.Left
=>
1304 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1305 Source
.Data
(High
+ 1 .. Slen
);
1307 if Droplen
>= Blen
then
1308 Result
.Data
(1 .. Max_Length
- Alen
) :=
1309 By
(By
'Last - (Max_Length
- Alen
) + 1 .. By
'Last);
1312 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) := By
;
1313 Result
.Data
(1 .. Blen
- Droplen
) :=
1314 Source
.Data
(Droplen
+ 1 .. Blen
);
1317 when Strings
.Error
=>
1318 raise Ada
.Strings
.Length_Error
;
1325 end Super_Replace_Slice
;
1327 procedure Super_Replace_Slice
1328 (Source
: in out Super_String
;
1332 Drop
: Strings
.Truncation
:= Strings
.Error
)
1335 -- We do a double copy here because this is one of the situations
1336 -- in which we move data to the right, and at least at the moment,
1337 -- GNAT is not handling such cases correctly ???
1339 Source
:= Super_Replace_Slice
(Source
, Low
, High
, By
, Drop
);
1340 end Super_Replace_Slice
;
1342 ---------------------
1343 -- Super_Replicate --
1344 ---------------------
1346 function Super_Replicate
1348 Item
: Wide_Character;
1349 Drop
: Truncation
:= Error
;
1350 Max_Length
: Positive) return Super_String
1352 Result
: Super_String
(Max_Length
);
1355 if Count
<= Max_Length
then
1356 Result
.Current_Length
:= Count
;
1358 elsif Drop
= Strings
.Error
then
1359 raise Ada
.Strings
.Length_Error
;
1362 Result
.Current_Length
:= Max_Length
;
1365 Result
.Data
(1 .. Result
.Current_Length
) := (others => Item
);
1367 end Super_Replicate
;
1369 function Super_Replicate
1372 Drop
: Truncation
:= Error
;
1373 Max_Length
: Positive) return Super_String
1375 Length
: constant Integer := Count
* Item
'Length;
1376 Result
: Super_String
(Max_Length
);
1380 if Length
<= Max_Length
then
1381 Result
.Current_Length
:= Length
;
1386 for J
in 1 .. Count
loop
1387 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1388 Indx
:= Indx
+ Item
'Length;
1393 Result
.Current_Length
:= Max_Length
;
1396 when Strings
.Right
=>
1399 while Indx
+ Item
'Length <= Max_Length
+ 1 loop
1400 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1401 Indx
:= Indx
+ Item
'Length;
1404 Result
.Data
(Indx
.. Max_Length
) :=
1405 Item
(Item
'First .. Item
'First + Max_Length
- Indx
);
1407 when Strings
.Left
=>
1410 while Indx
- Item
'Length >= 1 loop
1411 Result
.Data
(Indx
- (Item
'Length - 1) .. Indx
) := Item
;
1412 Indx
:= Indx
- Item
'Length;
1415 Result
.Data
(1 .. Indx
) :=
1416 Item
(Item
'Last - Indx
+ 1 .. Item
'Last);
1418 when Strings
.Error
=>
1419 raise Ada
.Strings
.Length_Error
;
1424 end Super_Replicate
;
1426 function Super_Replicate
1428 Item
: Super_String
;
1429 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1435 Item
.Data
(1 .. Item
.Current_Length
),
1438 end Super_Replicate
;
1444 function Super_Slice
1445 (Source
: Super_String
;
1447 High
: Natural) return Wide_String
1450 -- Note: test of High > Length is in accordance with AI95-00128
1452 if Low
> Source
.Current_Length
+ 1
1453 or else High
> Source
.Current_Length
1457 return Source
.Data
(Low
.. High
);
1461 function Super_Slice
1462 (Source
: Super_String
;
1464 High
: Natural) return Super_String
1466 Result
: Super_String
(Source
.Max_Length
);
1469 if Low
> Source
.Current_Length
+ 1
1470 or else High
> Source
.Current_Length
1474 Result
.Current_Length
:= High
- Low
+ 1;
1475 Result
.Data
(1 .. Result
.Current_Length
) := Source
.Data
(Low
.. High
);
1481 procedure Super_Slice
1482 (Source
: Super_String
;
1483 Target
: out Super_String
;
1488 if Low
> Source
.Current_Length
+ 1
1489 or else High
> Source
.Current_Length
1493 Target
.Current_Length
:= High
- Low
+ 1;
1494 Target
.Data
(1 .. Target
.Current_Length
) := Source
.Data
(Low
.. High
);
1503 (Source
: Super_String
;
1505 Pad
: Wide_Character := Wide_Space
;
1506 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1508 Max_Length
: constant Positive := Source
.Max_Length
;
1509 Result
: Super_String
(Max_Length
);
1510 Slen
: constant Natural := Source
.Current_Length
;
1511 Npad
: constant Integer := Count
- Slen
;
1515 Result
.Current_Length
:= Count
;
1516 Result
.Data
(1 .. Count
) :=
1517 Source
.Data
(Slen
- (Count
- 1) .. Slen
);
1519 elsif Count
<= Max_Length
then
1520 Result
.Current_Length
:= Count
;
1521 Result
.Data
(1 .. Npad
) := (others => Pad
);
1522 Result
.Data
(Npad
+ 1 .. Count
) := Source
.Data
(1 .. Slen
);
1525 Result
.Current_Length
:= Max_Length
;
1528 when Strings
.Right
=>
1529 if Npad
>= Max_Length
then
1530 Result
.Data
:= (others => Pad
);
1533 Result
.Data
(1 .. Npad
) := (others => Pad
);
1534 Result
.Data
(Npad
+ 1 .. Max_Length
) :=
1535 Source
.Data
(1 .. Max_Length
- Npad
);
1538 when Strings
.Left
=>
1539 Result
.Data
(1 .. Max_Length
- Slen
) := (others => Pad
);
1540 Result
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1541 Source
.Data
(1 .. Slen
);
1543 when Strings
.Error
=>
1544 raise Ada
.Strings
.Length_Error
;
1551 procedure Super_Tail
1552 (Source
: in out Super_String
;
1554 Pad
: Wide_Character := Wide_Space
;
1555 Drop
: Truncation
:= Error
)
1557 Max_Length
: constant Positive := Source
.Max_Length
;
1558 Slen
: constant Natural := Source
.Current_Length
;
1559 Npad
: constant Integer := Count
- Slen
;
1561 Temp
: constant Wide_String (1 .. Max_Length
) := Source
.Data
;
1565 Source
.Current_Length
:= Count
;
1566 Source
.Data
(1 .. Count
) :=
1567 Temp
(Slen
- (Count
- 1) .. Slen
);
1569 elsif Count
<= Max_Length
then
1570 Source
.Current_Length
:= Count
;
1571 Source
.Data
(1 .. Npad
) := (others => Pad
);
1572 Source
.Data
(Npad
+ 1 .. Count
) := Temp
(1 .. Slen
);
1575 Source
.Current_Length
:= Max_Length
;
1578 when Strings
.Right
=>
1579 if Npad
>= Max_Length
then
1580 Source
.Data
:= (others => Pad
);
1583 Source
.Data
(1 .. Npad
) := (others => Pad
);
1584 Source
.Data
(Npad
+ 1 .. Max_Length
) :=
1585 Temp
(1 .. Max_Length
- Npad
);
1588 when Strings
.Left
=>
1589 for J
in 1 .. Max_Length
- Slen
loop
1590 Source
.Data
(J
) := Pad
;
1593 Source
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1596 when Strings
.Error
=>
1597 raise Ada
.Strings
.Length_Error
;
1602 ---------------------
1603 -- Super_To_String --
1604 ---------------------
1606 function Super_To_String
(Source
: Super_String
) return Wide_String is
1608 return Source
.Data
(1 .. Source
.Current_Length
);
1609 end Super_To_String
;
1611 ---------------------
1612 -- Super_Translate --
1613 ---------------------
1615 function Super_Translate
1616 (Source
: Super_String
;
1617 Mapping
: Wide_Maps
.Wide_Character_Mapping
) return Super_String
1619 Result
: Super_String
(Source
.Max_Length
);
1622 Result
.Current_Length
:= Source
.Current_Length
;
1624 for J
in 1 .. Source
.Current_Length
loop
1625 Result
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1629 end Super_Translate
;
1631 procedure Super_Translate
1632 (Source
: in out Super_String
;
1633 Mapping
: Wide_Maps
.Wide_Character_Mapping
)
1636 for J
in 1 .. Source
.Current_Length
loop
1637 Source
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1639 end Super_Translate
;
1641 function Super_Translate
1642 (Source
: Super_String
;
1643 Mapping
: Wide_Maps
.Wide_Character_Mapping_Function
) return Super_String
1645 Result
: Super_String
(Source
.Max_Length
);
1648 Result
.Current_Length
:= Source
.Current_Length
;
1650 for J
in 1 .. Source
.Current_Length
loop
1651 Result
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1655 end Super_Translate
;
1657 procedure Super_Translate
1658 (Source
: in out Super_String
;
1659 Mapping
: Wide_Maps
.Wide_Character_Mapping_Function
)
1662 for J
in 1 .. Source
.Current_Length
loop
1663 Source
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1665 end Super_Translate
;
1672 (Source
: Super_String
;
1673 Side
: Trim_End
) return Super_String
1675 Result
: Super_String
(Source
.Max_Length
);
1676 Last
: Natural := Source
.Current_Length
;
1677 First
: Positive := 1;
1680 if Side
= Left
or else Side
= Both
then
1681 while First
<= Last
and then Source
.Data
(First
) = ' ' loop
1686 if Side
= Right
or else Side
= Both
then
1687 while Last
>= First
and then Source
.Data
(Last
) = ' ' loop
1692 Result
.Current_Length
:= Last
- First
+ 1;
1693 Result
.Data
(1 .. Result
.Current_Length
) := Source
.Data
(First
.. Last
);
1697 procedure Super_Trim
1698 (Source
: in out Super_String
;
1701 Max_Length
: constant Positive := Source
.Max_Length
;
1702 Last
: Natural := Source
.Current_Length
;
1703 First
: Positive := 1;
1704 Temp
: Wide_String (1 .. Max_Length
);
1707 Temp
(1 .. Last
) := Source
.Data
(1 .. Last
);
1709 if Side
= Left
or else Side
= Both
then
1710 while First
<= Last
and then Temp
(First
) = ' ' loop
1715 if Side
= Right
or else Side
= Both
then
1716 while Last
>= First
and then Temp
(Last
) = ' ' loop
1721 Source
.Data
:= (others => Wide_NUL
);
1722 Source
.Current_Length
:= Last
- First
+ 1;
1723 Source
.Data
(1 .. Source
.Current_Length
) := Temp
(First
.. Last
);
1727 (Source
: Super_String
;
1728 Left
: Wide_Maps
.Wide_Character_Set
;
1729 Right
: Wide_Maps
.Wide_Character_Set
) return Super_String
1731 Result
: Super_String
(Source
.Max_Length
);
1734 for First
in 1 .. Source
.Current_Length
loop
1735 if not Is_In
(Source
.Data
(First
), Left
) then
1736 for Last
in reverse First
.. Source
.Current_Length
loop
1737 if not Is_In
(Source
.Data
(Last
), Right
) then
1738 Result
.Current_Length
:= Last
- First
+ 1;
1739 Result
.Data
(1 .. Result
.Current_Length
) :=
1740 Source
.Data
(First
.. Last
);
1747 Result
.Current_Length
:= 0;
1751 procedure Super_Trim
1752 (Source
: in out Super_String
;
1753 Left
: Wide_Maps
.Wide_Character_Set
;
1754 Right
: Wide_Maps
.Wide_Character_Set
)
1757 for First
in 1 .. Source
.Current_Length
loop
1758 if not Is_In
(Source
.Data
(First
), Left
) then
1759 for Last
in reverse First
.. Source
.Current_Length
loop
1760 if not Is_In
(Source
.Data
(Last
), Right
) then
1762 Source
.Current_Length
:= Last
;
1765 Source
.Current_Length
:= Last
- First
+ 1;
1766 Source
.Data
(1 .. Source
.Current_Length
) :=
1767 Source
.Data
(First
.. Last
);
1769 for J
in Source
.Current_Length
+ 1 ..
1772 Source
.Data
(J
) := Wide_NUL
;
1780 Source
.Current_Length
:= 0;
1785 Source
.Current_Length
:= 0;
1794 Right
: Wide_Character;
1795 Max_Length
: Positive) return Super_String
1797 Result
: Super_String
(Max_Length
);
1800 if Left
> Max_Length
then
1801 raise Ada
.Strings
.Length_Error
;
1804 Result
.Current_Length
:= Left
;
1806 for J
in 1 .. Left
loop
1807 Result
.Data
(J
) := Right
;
1816 Right
: Wide_String;
1817 Max_Length
: Positive) return Super_String
1819 Result
: Super_String
(Max_Length
);
1820 Pos
: Positive := 1;
1821 Rlen
: constant Natural := Right
'Length;
1822 Nlen
: constant Natural := Left
* Rlen
;
1825 if Nlen
> Max_Length
then
1826 raise Ada
.Strings
.Index_Error
;
1829 Result
.Current_Length
:= Nlen
;
1832 for J
in 1 .. Left
loop
1833 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) := Right
;
1844 Right
: Super_String
) return Super_String
1846 Result
: Super_String
(Right
.Max_Length
);
1847 Pos
: Positive := 1;
1848 Rlen
: constant Natural := Right
.Current_Length
;
1849 Nlen
: constant Natural := Left
* Rlen
;
1852 if Nlen
> Right
.Max_Length
then
1853 raise Ada
.Strings
.Length_Error
;
1856 Result
.Current_Length
:= Nlen
;
1859 for J
in 1 .. Left
loop
1860 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) :=
1861 Right
.Data
(1 .. Rlen
);
1870 ---------------------
1871 -- To_Super_String --
1872 ---------------------
1874 function To_Super_String
1875 (Source
: Wide_String;
1876 Max_Length
: Natural;
1877 Drop
: Truncation
:= Error
) return Super_String
1879 Result
: Super_String
(Max_Length
);
1880 Slen
: constant Natural := Source
'Length;
1883 if Slen
<= Max_Length
then
1884 Result
.Current_Length
:= Slen
;
1885 Result
.Data
(1 .. Slen
) := Source
;
1889 when Strings
.Right
=>
1890 Result
.Current_Length
:= Max_Length
;
1891 Result
.Data
(1 .. Max_Length
) :=
1892 Source
(Source
'First .. Source
'First - 1 + Max_Length
);
1894 when Strings
.Left
=>
1895 Result
.Current_Length
:= Max_Length
;
1896 Result
.Data
(1 .. Max_Length
) :=
1897 Source
(Source
'Last - (Max_Length
- 1) .. Source
'Last);
1899 when Strings
.Error
=>
1900 raise Ada
.Strings
.Length_Error
;
1905 end To_Super_String
;
1907 end Ada
.Strings
.Wide_Superbounded
;