1 ------------------------------------------------------------------------------
3 -- GNAT RUN-TIME COMPONENTS --
5 -- A D A . S T R I N G S . 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
.Maps
; use Ada
.Strings
.Maps
;
33 with Ada
.Strings
.Search
;
35 package body Ada
.Strings
.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
: 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
: 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
;
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
: 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
: 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
: 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
: 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
: 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
;
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
: Truncation
:= 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 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
;
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 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 Character
580 function Super_Append
581 (Left
: Super_String
;
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
: 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 Character and Super_String
648 function Super_Append
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
;
689 Mapping
: Maps
.Character_Mapping
:= Maps
.Identity
) return Natural
694 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Mapping
);
698 (Source
: Super_String
;
700 Mapping
: Maps
.Character_Mapping_Function
) return Natural
705 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Mapping
);
709 (Source
: Super_String
;
710 Set
: Maps
.Character_Set
) return Natural
713 return Search
.Count
(Source
.Data
(1 .. Source
.Current_Length
), Set
);
720 function Super_Delete
721 (Source
: Super_String
;
723 Through
: Natural) return Super_String
725 Result
: Super_String
(Source
.Max_Length
);
726 Slen
: constant Natural := Source
.Current_Length
;
727 Num_Delete
: constant Integer := Through
- From
+ 1;
730 if Num_Delete
<= 0 then
733 elsif From
> Slen
+ 1 then
734 raise Ada
.Strings
.Index_Error
;
736 elsif Through
>= Slen
then
737 Result
.Current_Length
:= From
- 1;
738 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
742 Result
.Current_Length
:= Slen
- Num_Delete
;
743 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
744 Result
.Data
(From
.. Result
.Current_Length
) :=
745 Source
.Data
(Through
+ 1 .. Slen
);
750 procedure Super_Delete
751 (Source
: in out Super_String
;
755 Slen
: constant Natural := Source
.Current_Length
;
756 Num_Delete
: constant Integer := Through
- From
+ 1;
759 if Num_Delete
<= 0 then
762 elsif From
> Slen
+ 1 then
763 raise Ada
.Strings
.Index_Error
;
765 elsif Through
>= Slen
then
766 Source
.Current_Length
:= From
- 1;
769 Source
.Current_Length
:= Slen
- Num_Delete
;
770 Source
.Data
(From
.. Source
.Current_Length
) :=
771 Source
.Data
(Through
+ 1 .. Slen
);
779 function Super_Element
780 (Source
: Super_String
;
781 Index
: Positive) return Character
784 if Index
<= Source
.Current_Length
then
785 return Source
.Data
(Index
);
787 raise Strings
.Index_Error
;
791 ----------------------
792 -- Super_Find_Token --
793 ----------------------
795 procedure Super_Find_Token
796 (Source
: Super_String
;
797 Set
: Maps
.Character_Set
;
798 Test
: Strings
.Membership
;
799 First
: out Positive;
804 (Source
.Data
(1 .. Source
.Current_Length
), Set
, Test
, First
, Last
);
805 end Super_Find_Token
;
812 (Source
: Super_String
;
814 Pad
: Character := Space
;
815 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
817 Max_Length
: constant Positive := Source
.Max_Length
;
818 Result
: Super_String
(Max_Length
);
819 Slen
: constant Natural := Source
.Current_Length
;
820 Npad
: constant Integer := Count
- Slen
;
824 Result
.Current_Length
:= Count
;
825 Result
.Data
(1 .. Count
) := Source
.Data
(1 .. Count
);
827 elsif Count
<= Max_Length
then
828 Result
.Current_Length
:= Count
;
829 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
830 Result
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
833 Result
.Current_Length
:= Max_Length
;
836 when Strings
.Right
=>
837 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
838 Result
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
841 if Npad
>= Max_Length
then
842 Result
.Data
:= (others => Pad
);
845 Result
.Data
(1 .. Max_Length
- Npad
) :=
846 Source
.Data
(Count
- Max_Length
+ 1 .. Slen
);
847 Result
.Data
(Max_Length
- Npad
+ 1 .. Max_Length
) :=
851 when Strings
.Error
=>
852 raise Ada
.Strings
.Length_Error
;
860 (Source
: in out Super_String
;
862 Pad
: Character := Space
;
863 Drop
: Truncation
:= Error
)
865 Max_Length
: constant Positive := Source
.Max_Length
;
866 Slen
: constant Natural := Source
.Current_Length
;
867 Npad
: constant Integer := Count
- Slen
;
868 Temp
: String (1 .. Max_Length
);
872 Source
.Current_Length
:= Count
;
874 elsif Count
<= Max_Length
then
875 Source
.Current_Length
:= Count
;
876 Source
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
879 Source
.Current_Length
:= Max_Length
;
882 when Strings
.Right
=>
883 Source
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
886 if Npad
> Max_Length
then
887 Source
.Data
:= (others => Pad
);
891 Source
.Data
(1 .. Max_Length
- Npad
) :=
892 Temp
(Count
- Max_Length
+ 1 .. Slen
);
894 for J
in Max_Length
- Npad
+ 1 .. Max_Length
loop
895 Source
.Data
(J
) := Pad
;
899 when Strings
.Error
=>
900 raise Ada
.Strings
.Length_Error
;
910 (Source
: Super_String
;
912 Going
: Strings
.Direction
:= Strings
.Forward
;
913 Mapping
: Maps
.Character_Mapping
:= Maps
.Identity
) return Natural
917 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Going
, Mapping
);
921 (Source
: Super_String
;
923 Going
: Direction
:= Forward
;
924 Mapping
: Maps
.Character_Mapping_Function
) return Natural
928 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Going
, Mapping
);
932 (Source
: Super_String
;
933 Set
: Maps
.Character_Set
;
934 Test
: Strings
.Membership
:= Strings
.Inside
;
935 Going
: Strings
.Direction
:= Strings
.Forward
) return Natural
939 (Source
.Data
(1 .. Source
.Current_Length
), Set
, Test
, Going
);
943 (Source
: Super_String
;
946 Going
: Direction
:= Forward
;
947 Mapping
: Maps
.Character_Mapping
:= Maps
.Identity
) return Natural
951 (Source
.Data
(1 .. Source
.Current_Length
),
952 Pattern
, From
, Going
, Mapping
);
956 (Source
: Super_String
;
959 Going
: Direction
:= Forward
;
960 Mapping
: Maps
.Character_Mapping_Function
) return Natural
964 (Source
.Data
(1 .. Source
.Current_Length
),
965 Pattern
, From
, Going
, Mapping
);
969 (Source
: Super_String
;
970 Set
: Maps
.Character_Set
;
972 Test
: Membership
:= Inside
;
973 Going
: Direction
:= Forward
) return Natural
977 (Source
.Data
(1 .. Source
.Current_Length
), Set
, From
, Test
, Going
);
980 ---------------------------
981 -- Super_Index_Non_Blank --
982 ---------------------------
984 function Super_Index_Non_Blank
985 (Source
: Super_String
;
986 Going
: Strings
.Direction
:= Strings
.Forward
) return Natural
990 Search
.Index_Non_Blank
991 (Source
.Data
(1 .. Source
.Current_Length
), Going
);
992 end Super_Index_Non_Blank
;
994 function Super_Index_Non_Blank
995 (Source
: Super_String
;
997 Going
: Direction
:= Forward
) return Natural
1001 Search
.Index_Non_Blank
1002 (Source
.Data
(1 .. Source
.Current_Length
), From
, Going
);
1003 end Super_Index_Non_Blank
;
1009 function Super_Insert
1010 (Source
: Super_String
;
1013 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1015 Max_Length
: constant Positive := Source
.Max_Length
;
1016 Result
: Super_String
(Max_Length
);
1017 Slen
: constant Natural := Source
.Current_Length
;
1018 Nlen
: constant Natural := New_Item
'Length;
1019 Tlen
: constant Natural := Slen
+ Nlen
;
1020 Blen
: constant Natural := Before
- 1;
1021 Alen
: constant Integer := Slen
- Blen
;
1022 Droplen
: constant Integer := Tlen
- Max_Length
;
1024 -- Tlen is the length of the total string before possible truncation.
1025 -- Blen, Alen are the lengths of the before and after pieces of the
1030 raise Ada
.Strings
.Index_Error
;
1032 elsif Droplen
<= 0 then
1033 Result
.Current_Length
:= Tlen
;
1034 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1035 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1036 Result
.Data
(Before
+ Nlen
.. Tlen
) :=
1037 Source
.Data
(Before
.. Slen
);
1040 Result
.Current_Length
:= Max_Length
;
1043 when Strings
.Right
=>
1044 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1046 if Droplen
> Alen
then
1047 Result
.Data
(Before
.. Max_Length
) :=
1048 New_Item
(New_Item
'First
1049 .. New_Item
'First + Max_Length
- Before
);
1051 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1052 Result
.Data
(Before
+ Nlen
.. Max_Length
) :=
1053 Source
.Data
(Before
.. Slen
- Droplen
);
1056 when Strings
.Left
=>
1057 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1058 Source
.Data
(Before
.. Slen
);
1060 if Droplen
>= Blen
then
1061 Result
.Data
(1 .. Max_Length
- Alen
) :=
1062 New_Item
(New_Item
'Last - (Max_Length
- Alen
) + 1
1066 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) :=
1068 Result
.Data
(1 .. Blen
- Droplen
) :=
1069 Source
.Data
(Droplen
+ 1 .. Blen
);
1072 when Strings
.Error
=>
1073 raise Ada
.Strings
.Length_Error
;
1080 procedure Super_Insert
1081 (Source
: in out Super_String
;
1084 Drop
: Strings
.Truncation
:= Strings
.Error
)
1087 -- We do a double copy here because this is one of the situations
1088 -- in which we move data to the right, and at least at the moment,
1089 -- GNAT is not handling such cases correctly ???
1091 Source
:= Super_Insert
(Source
, Before
, New_Item
, Drop
);
1098 function Super_Length
(Source
: Super_String
) return Natural is
1100 return Source
.Current_Length
;
1103 ---------------------
1104 -- Super_Overwrite --
1105 ---------------------
1107 function Super_Overwrite
1108 (Source
: Super_String
;
1109 Position
: Positive;
1111 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1113 Max_Length
: constant Positive := Source
.Max_Length
;
1114 Result
: Super_String
(Max_Length
);
1115 Endpos
: constant Natural := Position
+ New_Item
'Length - 1;
1116 Slen
: constant Natural := Source
.Current_Length
;
1120 if Position
> Slen
+ 1 then
1121 raise Ada
.Strings
.Index_Error
;
1123 elsif New_Item
'Length = 0 then
1126 elsif Endpos
<= Slen
then
1127 Result
.Current_Length
:= Source
.Current_Length
;
1128 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
1129 Result
.Data
(Position
.. Endpos
) := New_Item
;
1132 elsif Endpos
<= Max_Length
then
1133 Result
.Current_Length
:= Endpos
;
1134 Result
.Data
(1 .. Position
- 1) := Source
.Data
(1 .. Position
- 1);
1135 Result
.Data
(Position
.. Endpos
) := New_Item
;
1139 Result
.Current_Length
:= Max_Length
;
1140 Droplen
:= Endpos
- Max_Length
;
1143 when Strings
.Right
=>
1144 Result
.Data
(1 .. Position
- 1) :=
1145 Source
.Data
(1 .. Position
- 1);
1147 Result
.Data
(Position
.. Max_Length
) :=
1148 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1151 when Strings
.Left
=>
1152 if New_Item
'Length >= Max_Length
then
1153 Result
.Data
(1 .. Max_Length
) :=
1154 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1159 Result
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1160 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1162 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1167 when Strings
.Error
=>
1168 raise Ada
.Strings
.Length_Error
;
1171 end Super_Overwrite
;
1173 procedure Super_Overwrite
1174 (Source
: in out Super_String
;
1175 Position
: Positive;
1177 Drop
: Strings
.Truncation
:= Strings
.Error
)
1179 Max_Length
: constant Positive := Source
.Max_Length
;
1180 Endpos
: constant Positive := Position
+ New_Item
'Length - 1;
1181 Slen
: constant Natural := Source
.Current_Length
;
1185 if Position
> Slen
+ 1 then
1186 raise Ada
.Strings
.Index_Error
;
1188 elsif Endpos
<= Slen
then
1189 Source
.Data
(Position
.. Endpos
) := New_Item
;
1191 elsif Endpos
<= Max_Length
then
1192 Source
.Data
(Position
.. Endpos
) := New_Item
;
1193 Source
.Current_Length
:= Endpos
;
1196 Source
.Current_Length
:= Max_Length
;
1197 Droplen
:= Endpos
- Max_Length
;
1200 when Strings
.Right
=>
1201 Source
.Data
(Position
.. Max_Length
) :=
1202 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1204 when Strings
.Left
=>
1205 if New_Item
'Length > Max_Length
then
1206 Source
.Data
(1 .. Max_Length
) :=
1207 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1211 Source
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1212 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1215 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1219 when Strings
.Error
=>
1220 raise Ada
.Strings
.Length_Error
;
1223 end Super_Overwrite
;
1225 ---------------------------
1226 -- Super_Replace_Element --
1227 ---------------------------
1229 procedure Super_Replace_Element
1230 (Source
: in out Super_String
;
1235 if Index
<= Source
.Current_Length
then
1236 Source
.Data
(Index
) := By
;
1238 raise Ada
.Strings
.Index_Error
;
1240 end Super_Replace_Element
;
1242 -------------------------
1243 -- Super_Replace_Slice --
1244 -------------------------
1246 function Super_Replace_Slice
1247 (Source
: Super_String
;
1251 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1253 Max_Length
: constant Positive := Source
.Max_Length
;
1254 Slen
: constant Natural := Source
.Current_Length
;
1257 if Low
> Slen
+ 1 then
1258 raise Strings
.Index_Error
;
1260 elsif High
< Low
then
1261 return Super_Insert
(Source
, Low
, By
, Drop
);
1265 Blen
: constant Natural := Natural'Max (0, Low
- 1);
1266 Alen
: constant Natural := Natural'Max (0, Slen
- High
);
1267 Tlen
: constant Natural := Blen
+ By
'Length + Alen
;
1268 Droplen
: constant Integer := Tlen
- Max_Length
;
1269 Result
: Super_String
(Max_Length
);
1271 -- Tlen is the total length of the result string before any
1272 -- truncation. Blen and Alen are the lengths of the pieces
1273 -- of the original string that end up in the result string
1274 -- before and after the replaced slice.
1277 if Droplen
<= 0 then
1278 Result
.Current_Length
:= Tlen
;
1279 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1280 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1281 Result
.Data
(Low
+ By
'Length .. Tlen
) :=
1282 Source
.Data
(High
+ 1 .. Slen
);
1285 Result
.Current_Length
:= Max_Length
;
1288 when Strings
.Right
=>
1289 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1291 if Droplen
> Alen
then
1292 Result
.Data
(Low
.. Max_Length
) :=
1293 By
(By
'First .. By
'First + Max_Length
- Low
);
1295 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1296 Result
.Data
(Low
+ By
'Length .. Max_Length
) :=
1297 Source
.Data
(High
+ 1 .. Slen
- Droplen
);
1300 when Strings
.Left
=>
1301 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1302 Source
.Data
(High
+ 1 .. Slen
);
1304 if Droplen
>= Blen
then
1305 Result
.Data
(1 .. Max_Length
- Alen
) :=
1306 By
(By
'Last - (Max_Length
- Alen
) + 1 .. By
'Last);
1309 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) := By
;
1310 Result
.Data
(1 .. Blen
- Droplen
) :=
1311 Source
.Data
(Droplen
+ 1 .. Blen
);
1314 when Strings
.Error
=>
1315 raise Ada
.Strings
.Length_Error
;
1322 end Super_Replace_Slice
;
1324 procedure Super_Replace_Slice
1325 (Source
: in out Super_String
;
1329 Drop
: Strings
.Truncation
:= Strings
.Error
)
1332 -- We do a double copy here because this is one of the situations
1333 -- in which we move data to the right, and at least at the moment,
1334 -- GNAT is not handling such cases correctly ???
1336 Source
:= Super_Replace_Slice
(Source
, Low
, High
, By
, Drop
);
1337 end Super_Replace_Slice
;
1339 ---------------------
1340 -- Super_Replicate --
1341 ---------------------
1343 function Super_Replicate
1346 Drop
: Truncation
:= Error
;
1347 Max_Length
: Positive) return Super_String
1349 Result
: Super_String
(Max_Length
);
1352 if Count
<= Max_Length
then
1353 Result
.Current_Length
:= Count
;
1355 elsif Drop
= Strings
.Error
then
1356 raise Ada
.Strings
.Length_Error
;
1359 Result
.Current_Length
:= Max_Length
;
1362 Result
.Data
(1 .. Result
.Current_Length
) := (others => Item
);
1364 end Super_Replicate
;
1366 function Super_Replicate
1369 Drop
: Truncation
:= Error
;
1370 Max_Length
: Positive) return Super_String
1372 Length
: constant Integer := Count
* Item
'Length;
1373 Result
: Super_String
(Max_Length
);
1377 if Length
<= Max_Length
then
1378 Result
.Current_Length
:= Length
;
1383 for J
in 1 .. Count
loop
1384 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1385 Indx
:= Indx
+ Item
'Length;
1390 Result
.Current_Length
:= Max_Length
;
1393 when Strings
.Right
=>
1396 while Indx
+ Item
'Length <= Max_Length
+ 1 loop
1397 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1398 Indx
:= Indx
+ Item
'Length;
1401 Result
.Data
(Indx
.. Max_Length
) :=
1402 Item
(Item
'First .. Item
'First + Max_Length
- Indx
);
1404 when Strings
.Left
=>
1407 while Indx
- Item
'Length >= 1 loop
1408 Result
.Data
(Indx
- (Item
'Length - 1) .. Indx
) := Item
;
1409 Indx
:= Indx
- Item
'Length;
1412 Result
.Data
(1 .. Indx
) :=
1413 Item
(Item
'Last - Indx
+ 1 .. Item
'Last);
1415 when Strings
.Error
=>
1416 raise Ada
.Strings
.Length_Error
;
1421 end Super_Replicate
;
1423 function Super_Replicate
1425 Item
: Super_String
;
1426 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1432 Item
.Data
(1 .. Item
.Current_Length
),
1435 end Super_Replicate
;
1441 function Super_Slice
1442 (Source
: Super_String
;
1444 High
: Natural) return String
1447 -- Note: test of High > Length is in accordance with AI95-00128
1449 if Low
> Source
.Current_Length
+ 1
1450 or else High
> Source
.Current_Length
1454 return Source
.Data
(Low
.. High
);
1458 function Super_Slice
1459 (Source
: Super_String
;
1461 High
: Natural) return Super_String
1463 Result
: Super_String
(Source
.Max_Length
);
1466 if Low
> Source
.Current_Length
+ 1
1467 or else High
> Source
.Current_Length
1471 Result
.Current_Length
:= High
- Low
+ 1;
1472 Result
.Data
(1 .. Result
.Current_Length
) := Source
.Data
(Low
.. High
);
1478 procedure Super_Slice
1479 (Source
: Super_String
;
1480 Target
: out Super_String
;
1485 if Low
> Source
.Current_Length
+ 1
1486 or else High
> Source
.Current_Length
1490 Target
.Current_Length
:= High
- Low
+ 1;
1491 Target
.Data
(1 .. Target
.Current_Length
) := Source
.Data
(Low
.. High
);
1500 (Source
: Super_String
;
1502 Pad
: Character := Space
;
1503 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1505 Max_Length
: constant Positive := Source
.Max_Length
;
1506 Result
: Super_String
(Max_Length
);
1507 Slen
: constant Natural := Source
.Current_Length
;
1508 Npad
: constant Integer := Count
- Slen
;
1512 Result
.Current_Length
:= Count
;
1513 Result
.Data
(1 .. Count
) :=
1514 Source
.Data
(Slen
- (Count
- 1) .. Slen
);
1516 elsif Count
<= Max_Length
then
1517 Result
.Current_Length
:= Count
;
1518 Result
.Data
(1 .. Npad
) := (others => Pad
);
1519 Result
.Data
(Npad
+ 1 .. Count
) := Source
.Data
(1 .. Slen
);
1522 Result
.Current_Length
:= Max_Length
;
1525 when Strings
.Right
=>
1526 if Npad
>= Max_Length
then
1527 Result
.Data
:= (others => Pad
);
1530 Result
.Data
(1 .. Npad
) := (others => Pad
);
1531 Result
.Data
(Npad
+ 1 .. Max_Length
) :=
1532 Source
.Data
(1 .. Max_Length
- Npad
);
1535 when Strings
.Left
=>
1536 Result
.Data
(1 .. Max_Length
- Slen
) := (others => Pad
);
1537 Result
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1538 Source
.Data
(1 .. Slen
);
1540 when Strings
.Error
=>
1541 raise Ada
.Strings
.Length_Error
;
1548 procedure Super_Tail
1549 (Source
: in out Super_String
;
1551 Pad
: Character := Space
;
1552 Drop
: Truncation
:= Error
)
1554 Max_Length
: constant Positive := Source
.Max_Length
;
1555 Slen
: constant Natural := Source
.Current_Length
;
1556 Npad
: constant Integer := Count
- Slen
;
1558 Temp
: constant String (1 .. Max_Length
) := Source
.Data
;
1562 Source
.Current_Length
:= Count
;
1563 Source
.Data
(1 .. Count
) :=
1564 Temp
(Slen
- (Count
- 1) .. Slen
);
1566 elsif Count
<= Max_Length
then
1567 Source
.Current_Length
:= Count
;
1568 Source
.Data
(1 .. Npad
) := (others => Pad
);
1569 Source
.Data
(Npad
+ 1 .. Count
) := Temp
(1 .. Slen
);
1572 Source
.Current_Length
:= Max_Length
;
1575 when Strings
.Right
=>
1576 if Npad
>= Max_Length
then
1577 Source
.Data
:= (others => Pad
);
1580 Source
.Data
(1 .. Npad
) := (others => Pad
);
1581 Source
.Data
(Npad
+ 1 .. Max_Length
) :=
1582 Temp
(1 .. Max_Length
- Npad
);
1585 when Strings
.Left
=>
1586 for J
in 1 .. Max_Length
- Slen
loop
1587 Source
.Data
(J
) := Pad
;
1590 Source
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1593 when Strings
.Error
=>
1594 raise Ada
.Strings
.Length_Error
;
1599 ---------------------
1600 -- Super_To_String --
1601 ---------------------
1603 function Super_To_String
(Source
: Super_String
) return String is
1605 return Source
.Data
(1 .. Source
.Current_Length
);
1606 end Super_To_String
;
1608 ---------------------
1609 -- Super_Translate --
1610 ---------------------
1612 function Super_Translate
1613 (Source
: Super_String
;
1614 Mapping
: Maps
.Character_Mapping
) return Super_String
1616 Result
: Super_String
(Source
.Max_Length
);
1619 Result
.Current_Length
:= Source
.Current_Length
;
1621 for J
in 1 .. Source
.Current_Length
loop
1622 Result
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1626 end Super_Translate
;
1628 procedure Super_Translate
1629 (Source
: in out Super_String
;
1630 Mapping
: Maps
.Character_Mapping
)
1633 for J
in 1 .. Source
.Current_Length
loop
1634 Source
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1636 end Super_Translate
;
1638 function Super_Translate
1639 (Source
: Super_String
;
1640 Mapping
: Maps
.Character_Mapping_Function
) return Super_String
1642 Result
: Super_String
(Source
.Max_Length
);
1645 Result
.Current_Length
:= Source
.Current_Length
;
1647 for J
in 1 .. Source
.Current_Length
loop
1648 Result
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1652 end Super_Translate
;
1654 procedure Super_Translate
1655 (Source
: in out Super_String
;
1656 Mapping
: Maps
.Character_Mapping_Function
)
1659 for J
in 1 .. Source
.Current_Length
loop
1660 Source
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1662 end Super_Translate
;
1669 (Source
: Super_String
;
1670 Side
: Trim_End
) return Super_String
1672 Result
: Super_String
(Source
.Max_Length
);
1673 Last
: Natural := Source
.Current_Length
;
1674 First
: Positive := 1;
1677 if Side
= Left
or else Side
= Both
then
1678 while First
<= Last
and then Source
.Data
(First
) = ' ' loop
1683 if Side
= Right
or else Side
= Both
then
1684 while Last
>= First
and then Source
.Data
(Last
) = ' ' loop
1689 Result
.Current_Length
:= Last
- First
+ 1;
1690 Result
.Data
(1 .. Result
.Current_Length
) := Source
.Data
(First
.. Last
);
1694 procedure Super_Trim
1695 (Source
: in out Super_String
;
1698 Max_Length
: constant Positive := Source
.Max_Length
;
1699 Last
: Natural := Source
.Current_Length
;
1700 First
: Positive := 1;
1701 Temp
: String (1 .. Max_Length
);
1704 Temp
(1 .. Last
) := Source
.Data
(1 .. Last
);
1706 if Side
= Left
or else Side
= Both
then
1707 while First
<= Last
and then Temp
(First
) = ' ' loop
1712 if Side
= Right
or else Side
= Both
then
1713 while Last
>= First
and then Temp
(Last
) = ' ' loop
1718 Source
.Data
:= (others => ASCII
.NUL
);
1719 Source
.Current_Length
:= Last
- First
+ 1;
1720 Source
.Data
(1 .. Source
.Current_Length
) := Temp
(First
.. Last
);
1724 (Source
: Super_String
;
1725 Left
: Maps
.Character_Set
;
1726 Right
: Maps
.Character_Set
) return Super_String
1728 Result
: Super_String
(Source
.Max_Length
);
1731 for First
in 1 .. Source
.Current_Length
loop
1732 if not Is_In
(Source
.Data
(First
), Left
) then
1733 for Last
in reverse First
.. Source
.Current_Length
loop
1734 if not Is_In
(Source
.Data
(Last
), Right
) then
1735 Result
.Current_Length
:= Last
- First
+ 1;
1736 Result
.Data
(1 .. Result
.Current_Length
) :=
1737 Source
.Data
(First
.. Last
);
1744 Result
.Current_Length
:= 0;
1748 procedure Super_Trim
1749 (Source
: in out Super_String
;
1750 Left
: Maps
.Character_Set
;
1751 Right
: Maps
.Character_Set
)
1754 for First
in 1 .. Source
.Current_Length
loop
1755 if not Is_In
(Source
.Data
(First
), Left
) then
1756 for Last
in reverse First
.. Source
.Current_Length
loop
1757 if not Is_In
(Source
.Data
(Last
), Right
) then
1759 Source
.Current_Length
:= Last
;
1762 Source
.Current_Length
:= Last
- First
+ 1;
1763 Source
.Data
(1 .. Source
.Current_Length
) :=
1764 Source
.Data
(First
.. Last
);
1766 for J
in Source
.Current_Length
+ 1 ..
1769 Source
.Data
(J
) := ASCII
.NUL
;
1777 Source
.Current_Length
:= 0;
1782 Source
.Current_Length
:= 0;
1792 Max_Length
: Positive) return Super_String
1794 Result
: Super_String
(Max_Length
);
1797 if Left
> Max_Length
then
1798 raise Ada
.Strings
.Length_Error
;
1801 Result
.Current_Length
:= Left
;
1803 for J
in 1 .. Left
loop
1804 Result
.Data
(J
) := Right
;
1814 Max_Length
: Positive) return Super_String
1816 Result
: Super_String
(Max_Length
);
1817 Pos
: Positive := 1;
1818 Rlen
: constant Natural := Right
'Length;
1819 Nlen
: constant Natural := Left
* Rlen
;
1822 if Nlen
> Max_Length
then
1823 raise Ada
.Strings
.Index_Error
;
1826 Result
.Current_Length
:= Nlen
;
1829 for J
in 1 .. Left
loop
1830 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) := Right
;
1841 Right
: Super_String
) return Super_String
1843 Result
: Super_String
(Right
.Max_Length
);
1844 Pos
: Positive := 1;
1845 Rlen
: constant Natural := Right
.Current_Length
;
1846 Nlen
: constant Natural := Left
* Rlen
;
1849 if Nlen
> Right
.Max_Length
then
1850 raise Ada
.Strings
.Length_Error
;
1853 Result
.Current_Length
:= Nlen
;
1856 for J
in 1 .. Left
loop
1857 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) :=
1858 Right
.Data
(1 .. Rlen
);
1867 ---------------------
1868 -- To_Super_String --
1869 ---------------------
1871 function To_Super_String
1873 Max_Length
: Natural;
1874 Drop
: Truncation
:= Error
) return Super_String
1876 Result
: Super_String
(Max_Length
);
1877 Slen
: constant Natural := Source
'Length;
1880 if Slen
<= Max_Length
then
1881 Result
.Current_Length
:= Slen
;
1882 Result
.Data
(1 .. Slen
) := Source
;
1886 when Strings
.Right
=>
1887 Result
.Current_Length
:= Max_Length
;
1888 Result
.Data
(1 .. Max_Length
) :=
1889 Source
(Source
'First .. Source
'First - 1 + Max_Length
);
1891 when Strings
.Left
=>
1892 Result
.Current_Length
:= Max_Length
;
1893 Result
.Data
(1 .. Max_Length
) :=
1894 Source
(Source
'Last - (Max_Length
- 1) .. Source
'Last);
1896 when Strings
.Error
=>
1897 raise Ada
.Strings
.Length_Error
;
1902 end To_Super_String
;
1904 end Ada
.Strings
.Superbounded
;