1 ------------------------------------------------------------------------------
3 -- GNAT RUN-TIME COMPONENTS --
5 -- A D A . S T R I N G S . W I D E _ W I D E _ S U P E R B O U N D E D --
9 -- Copyright (C) 2003-2016, 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_Wide_Maps
; use Ada
.Strings
.Wide_Wide_Maps
;
33 with Ada
.Strings
.Wide_Wide_Search
;
35 package body Ada
.Strings
.Wide_Wide_Superbounded
is
43 Right
: Super_String
) return Super_String
46 return Result
: Super_String
(Left
.Max_Length
) do
48 Llen
: constant Natural := Left
.Current_Length
;
49 Rlen
: constant Natural := Right
.Current_Length
;
50 Nlen
: constant Natural := Llen
+ Rlen
;
53 if Nlen
> Left
.Max_Length
then
54 raise Ada
.Strings
.Length_Error
;
56 Result
.Current_Length
:= Nlen
;
57 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
58 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
66 Right
: Wide_Wide_String
) return Super_String
69 return Result
: Super_String
(Left
.Max_Length
) do
71 Llen
: constant Natural := Left
.Current_Length
;
72 Nlen
: constant Natural := Llen
+ Right
'Length;
75 if Nlen
> Left
.Max_Length
then
76 raise Ada
.Strings
.Length_Error
;
78 Result
.Current_Length
:= Nlen
;
79 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
80 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
;
87 (Left
: Wide_Wide_String
;
88 Right
: Super_String
) return Super_String
91 return Result
: Super_String
(Right
.Max_Length
) do
93 Llen
: constant Natural := Left
'Length;
94 Rlen
: constant Natural := Right
.Current_Length
;
95 Nlen
: constant Natural := Llen
+ Rlen
;
98 if Nlen
> Right
.Max_Length
then
99 raise Ada
.Strings
.Length_Error
;
101 Result
.Current_Length
:= Nlen
;
102 Result
.Data
(1 .. Llen
) := Left
;
103 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
110 (Left
: Super_String
;
111 Right
: Wide_Wide_Character
) return Super_String
114 return Result
: Super_String
(Left
.Max_Length
) do
116 Llen
: constant Natural := Left
.Current_Length
;
119 if Llen
= Left
.Max_Length
then
120 raise Ada
.Strings
.Length_Error
;
122 Result
.Current_Length
:= Llen
+ 1;
123 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
124 Result
.Data
(Result
.Current_Length
) := Right
;
131 (Left
: Wide_Wide_Character
;
132 Right
: Super_String
) return Super_String
135 return Result
: Super_String
(Right
.Max_Length
) do
137 Rlen
: constant Natural := Right
.Current_Length
;
140 if Rlen
= Right
.Max_Length
then
141 raise Ada
.Strings
.Length_Error
;
143 Result
.Current_Length
:= Rlen
+ 1;
144 Result
.Data
(1) := Left
;
145 Result
.Data
(2 .. Result
.Current_Length
) :=
146 Right
.Data
(1 .. Rlen
);
157 (Left
: Super_String
;
158 Right
: Super_String
) return Boolean
161 return Left
.Current_Length
= Right
.Current_Length
162 and then Left
.Data
(1 .. Left
.Current_Length
) =
163 Right
.Data
(1 .. Right
.Current_Length
);
167 (Left
: Super_String
;
168 Right
: Wide_Wide_String
) return Boolean
171 return Left
.Current_Length
= Right
'Length
172 and then Left
.Data
(1 .. Left
.Current_Length
) = Right
;
176 (Left
: Wide_Wide_String
;
177 Right
: Super_String
) return Boolean
180 return Left
'Length = Right
.Current_Length
181 and then Left
= Right
.Data
(1 .. Right
.Current_Length
);
189 (Left
: Super_String
;
190 Right
: Super_String
) return Boolean
193 return Left
.Data
(1 .. Left
.Current_Length
) >
194 Right
.Data
(1 .. Right
.Current_Length
);
198 (Left
: Super_String
;
199 Right
: Wide_Wide_String
) return Boolean
202 return Left
.Data
(1 .. Left
.Current_Length
) > Right
;
206 (Left
: Wide_Wide_String
;
207 Right
: Super_String
) return Boolean
210 return Left
> Right
.Data
(1 .. Right
.Current_Length
);
213 ----------------------
214 -- Greater_Or_Equal --
215 ----------------------
217 function Greater_Or_Equal
218 (Left
: Super_String
;
219 Right
: Super_String
) return Boolean
222 return Left
.Data
(1 .. Left
.Current_Length
) >=
223 Right
.Data
(1 .. Right
.Current_Length
);
224 end Greater_Or_Equal
;
226 function Greater_Or_Equal
227 (Left
: Super_String
;
228 Right
: Wide_Wide_String
) return Boolean
231 return Left
.Data
(1 .. Left
.Current_Length
) >= Right
;
232 end Greater_Or_Equal
;
234 function Greater_Or_Equal
235 (Left
: Wide_Wide_String
;
236 Right
: Super_String
) return Boolean
239 return Left
>= Right
.Data
(1 .. Right
.Current_Length
);
240 end Greater_Or_Equal
;
247 (Left
: Super_String
;
248 Right
: Super_String
) return Boolean
251 return Left
.Data
(1 .. Left
.Current_Length
) <
252 Right
.Data
(1 .. Right
.Current_Length
);
256 (Left
: Super_String
;
257 Right
: Wide_Wide_String
) return Boolean
260 return Left
.Data
(1 .. Left
.Current_Length
) < Right
;
264 (Left
: Wide_Wide_String
;
265 Right
: Super_String
) return Boolean
268 return Left
< Right
.Data
(1 .. Right
.Current_Length
);
275 function Less_Or_Equal
276 (Left
: Super_String
;
277 Right
: Super_String
) return Boolean
280 return Left
.Data
(1 .. Left
.Current_Length
) <=
281 Right
.Data
(1 .. Right
.Current_Length
);
284 function Less_Or_Equal
285 (Left
: Super_String
;
286 Right
: Wide_Wide_String
) return Boolean
289 return Left
.Data
(1 .. Left
.Current_Length
) <= Right
;
292 function Less_Or_Equal
293 (Left
: Wide_Wide_String
;
294 Right
: Super_String
) return Boolean
297 return Left
<= Right
.Data
(1 .. Right
.Current_Length
);
300 ----------------------
301 -- Set_Super_String --
302 ----------------------
304 procedure Set_Super_String
305 (Target
: out Super_String
;
306 Source
: Wide_Wide_String
;
307 Drop
: Truncation
:= Error
)
309 Slen
: constant Natural := Source
'Length;
310 Max_Length
: constant Positive := Target
.Max_Length
;
313 if Slen
<= Max_Length
then
314 Target
.Current_Length
:= Slen
;
315 Target
.Data
(1 .. Slen
) := Source
;
319 when Strings
.Right
=>
320 Target
.Current_Length
:= Max_Length
;
321 Target
.Data
(1 .. Max_Length
) :=
322 Source
(Source
'First .. Source
'First - 1 + Max_Length
);
325 Target
.Current_Length
:= Max_Length
;
326 Target
.Data
(1 .. Max_Length
) :=
327 Source
(Source
'Last - (Max_Length
- 1) .. Source
'Last);
329 when Strings
.Error
=>
330 raise Ada
.Strings
.Length_Error
;
333 end Set_Super_String
;
339 -- Case of Super_String and Super_String
341 function Super_Append
342 (Left
: Super_String
;
343 Right
: Super_String
;
344 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
346 Max_Length
: constant Positive := Left
.Max_Length
;
347 Result
: Super_String
(Max_Length
);
348 Llen
: constant Natural := Left
.Current_Length
;
349 Rlen
: constant Natural := Right
.Current_Length
;
350 Nlen
: constant Natural := Llen
+ Rlen
;
353 if Nlen
<= Max_Length
then
354 Result
.Current_Length
:= Nlen
;
355 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
356 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
.Data
(1 .. Rlen
);
359 Result
.Current_Length
:= Max_Length
;
362 when Strings
.Right
=>
363 if Llen
>= Max_Length
then -- only case is Llen = Max_Length
364 Result
.Data
:= Left
.Data
;
367 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
368 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
369 Right
.Data
(1 .. Max_Length
- Llen
);
373 if Rlen
>= Max_Length
then -- only case is Rlen = Max_Length
374 Result
.Data
:= Right
.Data
;
377 Result
.Data
(1 .. Max_Length
- Rlen
) :=
378 Left
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
379 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
380 Right
.Data
(1 .. Rlen
);
383 when Strings
.Error
=>
384 raise Ada
.Strings
.Length_Error
;
391 procedure Super_Append
392 (Source
: in out Super_String
;
393 New_Item
: Super_String
;
394 Drop
: Truncation
:= Error
)
396 Max_Length
: constant Positive := Source
.Max_Length
;
397 Llen
: constant Natural := Source
.Current_Length
;
398 Rlen
: constant Natural := New_Item
.Current_Length
;
399 Nlen
: constant Natural := Llen
+ Rlen
;
402 if Nlen
<= Max_Length
then
403 Source
.Current_Length
:= Nlen
;
404 Source
.Data
(Llen
+ 1 .. Nlen
) := New_Item
.Data
(1 .. Rlen
);
407 Source
.Current_Length
:= Max_Length
;
410 when Strings
.Right
=>
411 if Llen
< Max_Length
then
412 Source
.Data
(Llen
+ 1 .. Max_Length
) :=
413 New_Item
.Data
(1 .. Max_Length
- Llen
);
417 if Rlen
>= Max_Length
then -- only case is Rlen = Max_Length
418 Source
.Data
:= New_Item
.Data
;
421 Source
.Data
(1 .. Max_Length
- Rlen
) :=
422 Source
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
423 Source
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
424 New_Item
.Data
(1 .. Rlen
);
427 when Strings
.Error
=>
428 raise Ada
.Strings
.Length_Error
;
434 -- Case of Super_String and Wide_Wide_String
436 function Super_Append
437 (Left
: Super_String
;
438 Right
: Wide_Wide_String
;
439 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
441 Max_Length
: constant Positive := Left
.Max_Length
;
442 Result
: Super_String
(Max_Length
);
443 Llen
: constant Natural := Left
.Current_Length
;
444 Rlen
: constant Natural := Right
'Length;
445 Nlen
: constant Natural := Llen
+ Rlen
;
448 if Nlen
<= Max_Length
then
449 Result
.Current_Length
:= Nlen
;
450 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
451 Result
.Data
(Llen
+ 1 .. Nlen
) := Right
;
454 Result
.Current_Length
:= Max_Length
;
457 when Strings
.Right
=>
458 if Llen
>= Max_Length
then -- only case is Llen = Max_Length
459 Result
.Data
:= Left
.Data
;
462 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
463 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
464 Right
(Right
'First .. Right
'First - 1 +
470 if Rlen
>= Max_Length
then
471 Result
.Data
(1 .. Max_Length
) :=
472 Right
(Right
'Last - (Max_Length
- 1) .. Right
'Last);
475 Result
.Data
(1 .. Max_Length
- Rlen
) :=
476 Left
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
477 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
481 when Strings
.Error
=>
482 raise Ada
.Strings
.Length_Error
;
489 procedure Super_Append
490 (Source
: in out Super_String
;
491 New_Item
: Wide_Wide_String
;
492 Drop
: Truncation
:= Error
)
494 Max_Length
: constant Positive := Source
.Max_Length
;
495 Llen
: constant Natural := Source
.Current_Length
;
496 Rlen
: constant Natural := New_Item
'Length;
497 Nlen
: constant Natural := Llen
+ Rlen
;
500 if Nlen
<= Max_Length
then
501 Source
.Current_Length
:= Nlen
;
502 Source
.Data
(Llen
+ 1 .. Nlen
) := New_Item
;
505 Source
.Current_Length
:= Max_Length
;
508 when Strings
.Right
=>
509 if Llen
< Max_Length
then
510 Source
.Data
(Llen
+ 1 .. Max_Length
) :=
511 New_Item
(New_Item
'First ..
512 New_Item
'First - 1 + Max_Length
- Llen
);
516 if Rlen
>= Max_Length
then
517 Source
.Data
(1 .. Max_Length
) :=
518 New_Item
(New_Item
'Last - (Max_Length
- 1) ..
522 Source
.Data
(1 .. Max_Length
- Rlen
) :=
523 Source
.Data
(Llen
- (Max_Length
- Rlen
- 1) .. Llen
);
524 Source
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
528 when Strings
.Error
=>
529 raise Ada
.Strings
.Length_Error
;
534 -- Case of Wide_Wide_String and Super_String
536 function Super_Append
537 (Left
: Wide_Wide_String
;
538 Right
: Super_String
;
539 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
541 Max_Length
: constant Positive := Right
.Max_Length
;
542 Result
: Super_String
(Max_Length
);
543 Llen
: constant Natural := Left
'Length;
544 Rlen
: constant Natural := Right
.Current_Length
;
545 Nlen
: constant Natural := Llen
+ Rlen
;
548 if Nlen
<= Max_Length
then
549 Result
.Current_Length
:= Nlen
;
550 Result
.Data
(1 .. Llen
) := Left
;
551 Result
.Data
(Llen
+ 1 .. Llen
+ Rlen
) := Right
.Data
(1 .. Rlen
);
554 Result
.Current_Length
:= Max_Length
;
557 when Strings
.Right
=>
558 if Llen
>= Max_Length
then
559 Result
.Data
(1 .. Max_Length
) :=
560 Left
(Left
'First .. Left
'First + (Max_Length
- 1));
563 Result
.Data
(1 .. Llen
) := Left
;
564 Result
.Data
(Llen
+ 1 .. Max_Length
) :=
565 Right
.Data
(1 .. Max_Length
- Llen
);
569 if Rlen
>= Max_Length
then
570 Result
.Data
(1 .. Max_Length
) :=
571 Right
.Data
(Rlen
- (Max_Length
- 1) .. Rlen
);
574 Result
.Data
(1 .. Max_Length
- Rlen
) :=
575 Left
(Left
'Last - (Max_Length
- Rlen
- 1) .. Left
'Last);
576 Result
.Data
(Max_Length
- Rlen
+ 1 .. Max_Length
) :=
577 Right
.Data
(1 .. Rlen
);
580 when Strings
.Error
=>
581 raise Ada
.Strings
.Length_Error
;
588 -- Case of Super_String and Wide_Wide_Character
590 function Super_Append
591 (Left
: Super_String
;
592 Right
: Wide_Wide_Character
;
593 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
595 Max_Length
: constant Positive := Left
.Max_Length
;
596 Result
: Super_String
(Max_Length
);
597 Llen
: constant Natural := Left
.Current_Length
;
600 if Llen
< Max_Length
then
601 Result
.Current_Length
:= Llen
+ 1;
602 Result
.Data
(1 .. Llen
) := Left
.Data
(1 .. Llen
);
603 Result
.Data
(Llen
+ 1) := Right
;
608 when Strings
.Right
=>
612 Result
.Current_Length
:= Max_Length
;
613 Result
.Data
(1 .. Max_Length
- 1) :=
614 Left
.Data
(2 .. Max_Length
);
615 Result
.Data
(Max_Length
) := Right
;
618 when Strings
.Error
=>
619 raise Ada
.Strings
.Length_Error
;
624 procedure Super_Append
625 (Source
: in out Super_String
;
626 New_Item
: Wide_Wide_Character
;
627 Drop
: Truncation
:= Error
)
629 Max_Length
: constant Positive := Source
.Max_Length
;
630 Llen
: constant Natural := Source
.Current_Length
;
633 if Llen
< Max_Length
then
634 Source
.Current_Length
:= Llen
+ 1;
635 Source
.Data
(Llen
+ 1) := New_Item
;
638 Source
.Current_Length
:= Max_Length
;
641 when Strings
.Right
=>
645 Source
.Data
(1 .. Max_Length
- 1) :=
646 Source
.Data
(2 .. Max_Length
);
647 Source
.Data
(Max_Length
) := New_Item
;
649 when Strings
.Error
=>
650 raise Ada
.Strings
.Length_Error
;
656 -- Case of Wide_Wide_Character and Super_String
658 function Super_Append
659 (Left
: Wide_Wide_Character
;
660 Right
: Super_String
;
661 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
663 Max_Length
: constant Positive := Right
.Max_Length
;
664 Result
: Super_String
(Max_Length
);
665 Rlen
: constant Natural := Right
.Current_Length
;
668 if Rlen
< Max_Length
then
669 Result
.Current_Length
:= Rlen
+ 1;
670 Result
.Data
(1) := Left
;
671 Result
.Data
(2 .. Rlen
+ 1) := Right
.Data
(1 .. Rlen
);
676 when Strings
.Right
=>
677 Result
.Current_Length
:= Max_Length
;
678 Result
.Data
(1) := Left
;
679 Result
.Data
(2 .. Max_Length
) :=
680 Right
.Data
(1 .. Max_Length
- 1);
686 when Strings
.Error
=>
687 raise Ada
.Strings
.Length_Error
;
697 (Source
: Super_String
;
698 Pattern
: Wide_Wide_String
;
699 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping
:=
700 Wide_Wide_Maps
.Identity
) return Natural
704 Wide_Wide_Search
.Count
705 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Mapping
);
709 (Source
: Super_String
;
710 Pattern
: Wide_Wide_String
;
711 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping_Function
)
716 Wide_Wide_Search
.Count
717 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Mapping
);
721 (Source
: Super_String
;
722 Set
: Wide_Wide_Maps
.Wide_Wide_Character_Set
) return Natural
725 return Wide_Wide_Search
.Count
726 (Source
.Data
(1 .. Source
.Current_Length
), Set
);
733 function Super_Delete
734 (Source
: Super_String
;
736 Through
: Natural) return Super_String
738 Result
: Super_String
(Source
.Max_Length
);
739 Slen
: constant Natural := Source
.Current_Length
;
740 Num_Delete
: constant Integer := Through
- From
+ 1;
743 if Num_Delete
<= 0 then
746 elsif From
> Slen
+ 1 then
747 raise Ada
.Strings
.Index_Error
;
749 elsif Through
>= Slen
then
750 Result
.Current_Length
:= From
- 1;
751 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
755 Result
.Current_Length
:= Slen
- Num_Delete
;
756 Result
.Data
(1 .. From
- 1) := Source
.Data
(1 .. From
- 1);
757 Result
.Data
(From
.. Result
.Current_Length
) :=
758 Source
.Data
(Through
+ 1 .. Slen
);
763 procedure Super_Delete
764 (Source
: in out Super_String
;
768 Slen
: constant Natural := Source
.Current_Length
;
769 Num_Delete
: constant Integer := Through
- From
+ 1;
772 if Num_Delete
<= 0 then
775 elsif From
> Slen
+ 1 then
776 raise Ada
.Strings
.Index_Error
;
778 elsif Through
>= Slen
then
779 Source
.Current_Length
:= From
- 1;
782 Source
.Current_Length
:= Slen
- Num_Delete
;
783 Source
.Data
(From
.. Source
.Current_Length
) :=
784 Source
.Data
(Through
+ 1 .. Slen
);
792 function Super_Element
793 (Source
: Super_String
;
794 Index
: Positive) return Wide_Wide_Character
797 if Index
<= Source
.Current_Length
then
798 return Source
.Data
(Index
);
800 raise Strings
.Index_Error
;
804 ----------------------
805 -- Super_Find_Token --
806 ----------------------
808 procedure Super_Find_Token
809 (Source
: Super_String
;
810 Set
: Wide_Wide_Maps
.Wide_Wide_Character_Set
;
812 Test
: Strings
.Membership
;
813 First
: out Positive;
817 Wide_Wide_Search
.Find_Token
818 (Source
.Data
(From
.. Source
.Current_Length
), Set
, Test
, First
, Last
);
819 end Super_Find_Token
;
821 procedure Super_Find_Token
822 (Source
: Super_String
;
823 Set
: Wide_Wide_Maps
.Wide_Wide_Character_Set
;
824 Test
: Strings
.Membership
;
825 First
: out Positive;
829 Wide_Wide_Search
.Find_Token
830 (Source
.Data
(1 .. Source
.Current_Length
), Set
, Test
, First
, Last
);
831 end Super_Find_Token
;
838 (Source
: Super_String
;
840 Pad
: Wide_Wide_Character
:= Wide_Wide_Space
;
841 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
843 Max_Length
: constant Positive := Source
.Max_Length
;
844 Result
: Super_String
(Max_Length
);
845 Slen
: constant Natural := Source
.Current_Length
;
846 Npad
: constant Integer := Count
- Slen
;
850 Result
.Current_Length
:= Count
;
851 Result
.Data
(1 .. Count
) := Source
.Data
(1 .. Count
);
853 elsif Count
<= Max_Length
then
854 Result
.Current_Length
:= Count
;
855 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
856 Result
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
859 Result
.Current_Length
:= Max_Length
;
862 when Strings
.Right
=>
863 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
864 Result
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
867 if Npad
>= Max_Length
then
868 Result
.Data
:= (others => Pad
);
871 Result
.Data
(1 .. Max_Length
- Npad
) :=
872 Source
.Data
(Count
- Max_Length
+ 1 .. Slen
);
873 Result
.Data
(Max_Length
- Npad
+ 1 .. Max_Length
) :=
877 when Strings
.Error
=>
878 raise Ada
.Strings
.Length_Error
;
886 (Source
: in out Super_String
;
888 Pad
: Wide_Wide_Character
:= Wide_Wide_Space
;
889 Drop
: Truncation
:= Error
)
891 Max_Length
: constant Positive := Source
.Max_Length
;
892 Slen
: constant Natural := Source
.Current_Length
;
893 Npad
: constant Integer := Count
- Slen
;
894 Temp
: Wide_Wide_String
(1 .. Max_Length
);
898 Source
.Current_Length
:= Count
;
900 elsif Count
<= Max_Length
then
901 Source
.Current_Length
:= Count
;
902 Source
.Data
(Slen
+ 1 .. Count
) := (others => Pad
);
905 Source
.Current_Length
:= Max_Length
;
908 when Strings
.Right
=>
909 Source
.Data
(Slen
+ 1 .. Max_Length
) := (others => Pad
);
912 if Npad
> Max_Length
then
913 Source
.Data
:= (others => Pad
);
917 Source
.Data
(1 .. Max_Length
- Npad
) :=
918 Temp
(Count
- Max_Length
+ 1 .. Slen
);
920 for J
in Max_Length
- Npad
+ 1 .. Max_Length
loop
921 Source
.Data
(J
) := Pad
;
925 when Strings
.Error
=>
926 raise Ada
.Strings
.Length_Error
;
936 (Source
: Super_String
;
937 Pattern
: Wide_Wide_String
;
938 Going
: Strings
.Direction
:= Strings
.Forward
;
939 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping
:=
940 Wide_Wide_Maps
.Identity
) return Natural
943 return Wide_Wide_Search
.Index
944 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Going
, Mapping
);
948 (Source
: Super_String
;
949 Pattern
: Wide_Wide_String
;
950 Going
: Direction
:= Forward
;
951 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping_Function
)
955 return Wide_Wide_Search
.Index
956 (Source
.Data
(1 .. Source
.Current_Length
), Pattern
, Going
, Mapping
);
960 (Source
: Super_String
;
961 Set
: Wide_Wide_Maps
.Wide_Wide_Character_Set
;
962 Test
: Strings
.Membership
:= Strings
.Inside
;
963 Going
: Strings
.Direction
:= Strings
.Forward
) return Natural
966 return Wide_Wide_Search
.Index
967 (Source
.Data
(1 .. Source
.Current_Length
), Set
, Test
, Going
);
971 (Source
: Super_String
;
972 Pattern
: Wide_Wide_String
;
974 Going
: Direction
:= Forward
;
975 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping
:=
976 Wide_Wide_Maps
.Identity
) return Natural
979 return Wide_Wide_Search
.Index
980 (Source
.Data
(1 .. Source
.Current_Length
),
981 Pattern
, From
, Going
, Mapping
);
985 (Source
: Super_String
;
986 Pattern
: Wide_Wide_String
;
988 Going
: Direction
:= Forward
;
989 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping_Function
)
993 return Wide_Wide_Search
.Index
994 (Source
.Data
(1 .. Source
.Current_Length
),
995 Pattern
, From
, Going
, Mapping
);
999 (Source
: Super_String
;
1000 Set
: Wide_Wide_Maps
.Wide_Wide_Character_Set
;
1002 Test
: Membership
:= Inside
;
1003 Going
: Direction
:= Forward
) return Natural
1006 return Wide_Wide_Search
.Index
1007 (Source
.Data
(1 .. Source
.Current_Length
), Set
, From
, Test
, Going
);
1010 ---------------------------
1011 -- Super_Index_Non_Blank --
1012 ---------------------------
1014 function Super_Index_Non_Blank
1015 (Source
: Super_String
;
1016 Going
: Strings
.Direction
:= Strings
.Forward
) return Natural
1020 Wide_Wide_Search
.Index_Non_Blank
1021 (Source
.Data
(1 .. Source
.Current_Length
), Going
);
1022 end Super_Index_Non_Blank
;
1024 function Super_Index_Non_Blank
1025 (Source
: Super_String
;
1027 Going
: Direction
:= Forward
) return Natural
1031 Wide_Wide_Search
.Index_Non_Blank
1032 (Source
.Data
(1 .. Source
.Current_Length
), From
, Going
);
1033 end Super_Index_Non_Blank
;
1039 function Super_Insert
1040 (Source
: Super_String
;
1042 New_Item
: Wide_Wide_String
;
1043 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1045 Max_Length
: constant Positive := Source
.Max_Length
;
1046 Result
: Super_String
(Max_Length
);
1047 Slen
: constant Natural := Source
.Current_Length
;
1048 Nlen
: constant Natural := New_Item
'Length;
1049 Tlen
: constant Natural := Slen
+ Nlen
;
1050 Blen
: constant Natural := Before
- 1;
1051 Alen
: constant Integer := Slen
- Blen
;
1052 Droplen
: constant Integer := Tlen
- Max_Length
;
1054 -- Tlen is the length of the total string before possible truncation.
1055 -- Blen, Alen are the lengths of the before and after pieces of the
1060 raise Ada
.Strings
.Index_Error
;
1062 elsif Droplen
<= 0 then
1063 Result
.Current_Length
:= Tlen
;
1064 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1065 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1066 Result
.Data
(Before
+ Nlen
.. Tlen
) :=
1067 Source
.Data
(Before
.. Slen
);
1070 Result
.Current_Length
:= Max_Length
;
1073 when Strings
.Right
=>
1074 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1076 if Droplen
> Alen
then
1077 Result
.Data
(Before
.. Max_Length
) :=
1078 New_Item
(New_Item
'First
1079 .. New_Item
'First + Max_Length
- Before
);
1081 Result
.Data
(Before
.. Before
+ Nlen
- 1) := New_Item
;
1082 Result
.Data
(Before
+ Nlen
.. Max_Length
) :=
1083 Source
.Data
(Before
.. Slen
- Droplen
);
1086 when Strings
.Left
=>
1087 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1088 Source
.Data
(Before
.. Slen
);
1090 if Droplen
>= Blen
then
1091 Result
.Data
(1 .. Max_Length
- Alen
) :=
1092 New_Item
(New_Item
'Last - (Max_Length
- Alen
) + 1
1096 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) :=
1098 Result
.Data
(1 .. Blen
- Droplen
) :=
1099 Source
.Data
(Droplen
+ 1 .. Blen
);
1102 when Strings
.Error
=>
1103 raise Ada
.Strings
.Length_Error
;
1110 procedure Super_Insert
1111 (Source
: in out Super_String
;
1113 New_Item
: Wide_Wide_String
;
1114 Drop
: Strings
.Truncation
:= Strings
.Error
)
1117 -- We do a double copy here because this is one of the situations
1118 -- in which we move data to the right, and at least at the moment,
1119 -- GNAT is not handling such cases correctly ???
1121 Source
:= Super_Insert
(Source
, Before
, New_Item
, Drop
);
1128 function Super_Length
(Source
: Super_String
) return Natural is
1130 return Source
.Current_Length
;
1133 ---------------------
1134 -- Super_Overwrite --
1135 ---------------------
1137 function Super_Overwrite
1138 (Source
: Super_String
;
1139 Position
: Positive;
1140 New_Item
: Wide_Wide_String
;
1141 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1143 Max_Length
: constant Positive := Source
.Max_Length
;
1144 Result
: Super_String
(Max_Length
);
1145 Endpos
: constant Natural := Position
+ New_Item
'Length - 1;
1146 Slen
: constant Natural := Source
.Current_Length
;
1150 if Position
> Slen
+ 1 then
1151 raise Ada
.Strings
.Index_Error
;
1153 elsif New_Item
'Length = 0 then
1156 elsif Endpos
<= Slen
then
1157 Result
.Current_Length
:= Source
.Current_Length
;
1158 Result
.Data
(1 .. Slen
) := Source
.Data
(1 .. Slen
);
1159 Result
.Data
(Position
.. Endpos
) := New_Item
;
1162 elsif Endpos
<= Max_Length
then
1163 Result
.Current_Length
:= Endpos
;
1164 Result
.Data
(1 .. Position
- 1) := Source
.Data
(1 .. Position
- 1);
1165 Result
.Data
(Position
.. Endpos
) := New_Item
;
1169 Result
.Current_Length
:= Max_Length
;
1170 Droplen
:= Endpos
- Max_Length
;
1173 when Strings
.Right
=>
1174 Result
.Data
(1 .. Position
- 1) :=
1175 Source
.Data
(1 .. Position
- 1);
1177 Result
.Data
(Position
.. Max_Length
) :=
1178 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1181 when Strings
.Left
=>
1182 if New_Item
'Length >= Max_Length
then
1183 Result
.Data
(1 .. Max_Length
) :=
1184 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1189 Result
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1190 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1192 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1197 when Strings
.Error
=>
1198 raise Ada
.Strings
.Length_Error
;
1201 end Super_Overwrite
;
1203 procedure Super_Overwrite
1204 (Source
: in out Super_String
;
1205 Position
: Positive;
1206 New_Item
: Wide_Wide_String
;
1207 Drop
: Strings
.Truncation
:= Strings
.Error
)
1209 Max_Length
: constant Positive := Source
.Max_Length
;
1210 Endpos
: constant Positive := Position
+ New_Item
'Length - 1;
1211 Slen
: constant Natural := Source
.Current_Length
;
1215 if Position
> Slen
+ 1 then
1216 raise Ada
.Strings
.Index_Error
;
1218 elsif Endpos
<= Slen
then
1219 Source
.Data
(Position
.. Endpos
) := New_Item
;
1221 elsif Endpos
<= Max_Length
then
1222 Source
.Data
(Position
.. Endpos
) := New_Item
;
1223 Source
.Current_Length
:= Endpos
;
1226 Source
.Current_Length
:= Max_Length
;
1227 Droplen
:= Endpos
- Max_Length
;
1230 when Strings
.Right
=>
1231 Source
.Data
(Position
.. Max_Length
) :=
1232 New_Item
(New_Item
'First .. New_Item
'Last - Droplen
);
1234 when Strings
.Left
=>
1235 if New_Item
'Length > Max_Length
then
1236 Source
.Data
(1 .. Max_Length
) :=
1237 New_Item
(New_Item
'Last - Max_Length
+ 1 ..
1241 Source
.Data
(1 .. Max_Length
- New_Item
'Length) :=
1242 Source
.Data
(Droplen
+ 1 .. Position
- 1);
1245 (Max_Length
- New_Item
'Length + 1 .. Max_Length
) :=
1249 when Strings
.Error
=>
1250 raise Ada
.Strings
.Length_Error
;
1253 end Super_Overwrite
;
1255 ---------------------------
1256 -- Super_Replace_Element --
1257 ---------------------------
1259 procedure Super_Replace_Element
1260 (Source
: in out Super_String
;
1262 By
: Wide_Wide_Character
)
1265 if Index
<= Source
.Current_Length
then
1266 Source
.Data
(Index
) := By
;
1268 raise Ada
.Strings
.Index_Error
;
1270 end Super_Replace_Element
;
1272 -------------------------
1273 -- Super_Replace_Slice --
1274 -------------------------
1276 function Super_Replace_Slice
1277 (Source
: Super_String
;
1280 By
: Wide_Wide_String
;
1281 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1283 Max_Length
: constant Positive := Source
.Max_Length
;
1284 Slen
: constant Natural := Source
.Current_Length
;
1287 if Low
> Slen
+ 1 then
1288 raise Strings
.Index_Error
;
1290 elsif High
< Low
then
1291 return Super_Insert
(Source
, Low
, By
, Drop
);
1295 Blen
: constant Natural := Natural'Max (0, Low
- 1);
1296 Alen
: constant Natural := Natural'Max (0, Slen
- High
);
1297 Tlen
: constant Natural := Blen
+ By
'Length + Alen
;
1298 Droplen
: constant Integer := Tlen
- Max_Length
;
1299 Result
: Super_String
(Max_Length
);
1301 -- Tlen is the total length of the result string before any
1302 -- truncation. Blen and Alen are the lengths of the pieces
1303 -- of the original string that end up in the result string
1304 -- before and after the replaced slice.
1307 if Droplen
<= 0 then
1308 Result
.Current_Length
:= Tlen
;
1309 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1310 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1311 Result
.Data
(Low
+ By
'Length .. Tlen
) :=
1312 Source
.Data
(High
+ 1 .. Slen
);
1315 Result
.Current_Length
:= Max_Length
;
1318 when Strings
.Right
=>
1319 Result
.Data
(1 .. Blen
) := Source
.Data
(1 .. Blen
);
1321 if Droplen
> Alen
then
1322 Result
.Data
(Low
.. Max_Length
) :=
1323 By
(By
'First .. By
'First + Max_Length
- Low
);
1325 Result
.Data
(Low
.. Low
+ By
'Length - 1) := By
;
1326 Result
.Data
(Low
+ By
'Length .. Max_Length
) :=
1327 Source
.Data
(High
+ 1 .. Slen
- Droplen
);
1330 when Strings
.Left
=>
1331 Result
.Data
(Max_Length
- (Alen
- 1) .. Max_Length
) :=
1332 Source
.Data
(High
+ 1 .. Slen
);
1334 if Droplen
>= Blen
then
1335 Result
.Data
(1 .. Max_Length
- Alen
) :=
1336 By
(By
'Last - (Max_Length
- Alen
) + 1 .. By
'Last);
1339 (Blen
- Droplen
+ 1 .. Max_Length
- Alen
) := By
;
1340 Result
.Data
(1 .. Blen
- Droplen
) :=
1341 Source
.Data
(Droplen
+ 1 .. Blen
);
1344 when Strings
.Error
=>
1345 raise Ada
.Strings
.Length_Error
;
1352 end Super_Replace_Slice
;
1354 procedure Super_Replace_Slice
1355 (Source
: in out Super_String
;
1358 By
: Wide_Wide_String
;
1359 Drop
: Strings
.Truncation
:= Strings
.Error
)
1362 -- We do a double copy here because this is one of the situations
1363 -- in which we move data to the right, and at least at the moment,
1364 -- GNAT is not handling such cases correctly ???
1366 Source
:= Super_Replace_Slice
(Source
, Low
, High
, By
, Drop
);
1367 end Super_Replace_Slice
;
1369 ---------------------
1370 -- Super_Replicate --
1371 ---------------------
1373 function Super_Replicate
1375 Item
: Wide_Wide_Character
;
1376 Drop
: Truncation
:= Error
;
1377 Max_Length
: Positive) return Super_String
1379 Result
: Super_String
(Max_Length
);
1382 if Count
<= Max_Length
then
1383 Result
.Current_Length
:= Count
;
1385 elsif Drop
= Strings
.Error
then
1386 raise Ada
.Strings
.Length_Error
;
1389 Result
.Current_Length
:= Max_Length
;
1392 Result
.Data
(1 .. Result
.Current_Length
) := (others => Item
);
1394 end Super_Replicate
;
1396 function Super_Replicate
1398 Item
: Wide_Wide_String
;
1399 Drop
: Truncation
:= Error
;
1400 Max_Length
: Positive) return Super_String
1402 Length
: constant Integer := Count
* Item
'Length;
1403 Result
: Super_String
(Max_Length
);
1407 if Length
<= Max_Length
then
1408 Result
.Current_Length
:= Length
;
1413 for J
in 1 .. Count
loop
1414 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1415 Indx
:= Indx
+ Item
'Length;
1420 Result
.Current_Length
:= Max_Length
;
1423 when Strings
.Right
=>
1426 while Indx
+ Item
'Length <= Max_Length
+ 1 loop
1427 Result
.Data
(Indx
.. Indx
+ Item
'Length - 1) := Item
;
1428 Indx
:= Indx
+ Item
'Length;
1431 Result
.Data
(Indx
.. Max_Length
) :=
1432 Item
(Item
'First .. Item
'First + Max_Length
- Indx
);
1434 when Strings
.Left
=>
1437 while Indx
- Item
'Length >= 1 loop
1438 Result
.Data
(Indx
- (Item
'Length - 1) .. Indx
) := Item
;
1439 Indx
:= Indx
- Item
'Length;
1442 Result
.Data
(1 .. Indx
) :=
1443 Item
(Item
'Last - Indx
+ 1 .. Item
'Last);
1445 when Strings
.Error
=>
1446 raise Ada
.Strings
.Length_Error
;
1451 end Super_Replicate
;
1453 function Super_Replicate
1455 Item
: Super_String
;
1456 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1462 Item
.Data
(1 .. Item
.Current_Length
),
1465 end Super_Replicate
;
1471 function Super_Slice
1472 (Source
: Super_String
;
1474 High
: Natural) return Wide_Wide_String
1477 -- Note: test of High > Length is in accordance with AI95-00128
1479 return R
: Wide_Wide_String
(Low
.. High
) do
1480 if Low
> Source
.Current_Length
+ 1
1481 or else High
> Source
.Current_Length
1486 R
:= Source
.Data
(Low
.. High
);
1490 function Super_Slice
1491 (Source
: Super_String
;
1493 High
: Natural) return Super_String
1496 return Result
: Super_String
(Source
.Max_Length
) do
1497 if Low
> Source
.Current_Length
+ 1
1498 or else High
> Source
.Current_Length
1502 Result
.Current_Length
:= High
- Low
+ 1;
1503 Result
.Data
(1 .. Result
.Current_Length
) :=
1504 Source
.Data
(Low
.. High
);
1509 procedure Super_Slice
1510 (Source
: Super_String
;
1511 Target
: out Super_String
;
1516 if Low
> Source
.Current_Length
+ 1
1517 or else High
> Source
.Current_Length
1521 Target
.Current_Length
:= High
- Low
+ 1;
1522 Target
.Data
(1 .. Target
.Current_Length
) := Source
.Data
(Low
.. High
);
1531 (Source
: Super_String
;
1533 Pad
: Wide_Wide_Character
:= Wide_Wide_Space
;
1534 Drop
: Strings
.Truncation
:= Strings
.Error
) return Super_String
1536 Max_Length
: constant Positive := Source
.Max_Length
;
1537 Result
: Super_String
(Max_Length
);
1538 Slen
: constant Natural := Source
.Current_Length
;
1539 Npad
: constant Integer := Count
- Slen
;
1543 Result
.Current_Length
:= Count
;
1544 Result
.Data
(1 .. Count
) :=
1545 Source
.Data
(Slen
- (Count
- 1) .. Slen
);
1547 elsif Count
<= Max_Length
then
1548 Result
.Current_Length
:= Count
;
1549 Result
.Data
(1 .. Npad
) := (others => Pad
);
1550 Result
.Data
(Npad
+ 1 .. Count
) := Source
.Data
(1 .. Slen
);
1553 Result
.Current_Length
:= Max_Length
;
1556 when Strings
.Right
=>
1557 if Npad
>= Max_Length
then
1558 Result
.Data
:= (others => Pad
);
1561 Result
.Data
(1 .. Npad
) := (others => Pad
);
1562 Result
.Data
(Npad
+ 1 .. Max_Length
) :=
1563 Source
.Data
(1 .. Max_Length
- Npad
);
1566 when Strings
.Left
=>
1567 Result
.Data
(1 .. Max_Length
- Slen
) := (others => Pad
);
1568 Result
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1569 Source
.Data
(1 .. Slen
);
1571 when Strings
.Error
=>
1572 raise Ada
.Strings
.Length_Error
;
1579 procedure Super_Tail
1580 (Source
: in out Super_String
;
1582 Pad
: Wide_Wide_Character
:= Wide_Wide_Space
;
1583 Drop
: Truncation
:= Error
)
1585 Max_Length
: constant Positive := Source
.Max_Length
;
1586 Slen
: constant Natural := Source
.Current_Length
;
1587 Npad
: constant Integer := Count
- Slen
;
1589 Temp
: constant Wide_Wide_String
(1 .. Max_Length
) := Source
.Data
;
1593 Source
.Current_Length
:= Count
;
1594 Source
.Data
(1 .. Count
) :=
1595 Temp
(Slen
- (Count
- 1) .. Slen
);
1597 elsif Count
<= Max_Length
then
1598 Source
.Current_Length
:= Count
;
1599 Source
.Data
(1 .. Npad
) := (others => Pad
);
1600 Source
.Data
(Npad
+ 1 .. Count
) := Temp
(1 .. Slen
);
1603 Source
.Current_Length
:= Max_Length
;
1606 when Strings
.Right
=>
1607 if Npad
>= Max_Length
then
1608 Source
.Data
:= (others => Pad
);
1611 Source
.Data
(1 .. Npad
) := (others => Pad
);
1612 Source
.Data
(Npad
+ 1 .. Max_Length
) :=
1613 Temp
(1 .. Max_Length
- Npad
);
1616 when Strings
.Left
=>
1617 for J
in 1 .. Max_Length
- Slen
loop
1618 Source
.Data
(J
) := Pad
;
1621 Source
.Data
(Max_Length
- Slen
+ 1 .. Max_Length
) :=
1624 when Strings
.Error
=>
1625 raise Ada
.Strings
.Length_Error
;
1630 ---------------------
1631 -- Super_To_String --
1632 ---------------------
1634 function Super_To_String
1635 (Source
: Super_String
) return Wide_Wide_String
1638 return R
: Wide_Wide_String
(1 .. Source
.Current_Length
) do
1639 R
:= Source
.Data
(1 .. Source
.Current_Length
);
1641 end Super_To_String
;
1643 ---------------------
1644 -- Super_Translate --
1645 ---------------------
1647 function Super_Translate
1648 (Source
: Super_String
;
1649 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping
)
1652 Result
: Super_String
(Source
.Max_Length
);
1655 Result
.Current_Length
:= Source
.Current_Length
;
1657 for J
in 1 .. Source
.Current_Length
loop
1658 Result
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1662 end Super_Translate
;
1664 procedure Super_Translate
1665 (Source
: in out Super_String
;
1666 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping
)
1669 for J
in 1 .. Source
.Current_Length
loop
1670 Source
.Data
(J
) := Value
(Mapping
, Source
.Data
(J
));
1672 end Super_Translate
;
1674 function Super_Translate
1675 (Source
: Super_String
;
1676 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping_Function
)
1679 Result
: Super_String
(Source
.Max_Length
);
1682 Result
.Current_Length
:= Source
.Current_Length
;
1684 for J
in 1 .. Source
.Current_Length
loop
1685 Result
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1689 end Super_Translate
;
1691 procedure Super_Translate
1692 (Source
: in out Super_String
;
1693 Mapping
: Wide_Wide_Maps
.Wide_Wide_Character_Mapping_Function
)
1696 for J
in 1 .. Source
.Current_Length
loop
1697 Source
.Data
(J
) := Mapping
.all (Source
.Data
(J
));
1699 end Super_Translate
;
1706 (Source
: Super_String
;
1707 Side
: Trim_End
) return Super_String
1709 Result
: Super_String
(Source
.Max_Length
);
1710 Last
: Natural := Source
.Current_Length
;
1711 First
: Positive := 1;
1714 if Side
= Left
or else Side
= Both
then
1715 while First
<= Last
and then Source
.Data
(First
) = ' ' loop
1720 if Side
= Right
or else Side
= Both
then
1721 while Last
>= First
and then Source
.Data
(Last
) = ' ' loop
1726 Result
.Current_Length
:= Last
- First
+ 1;
1727 Result
.Data
(1 .. Result
.Current_Length
) := Source
.Data
(First
.. Last
);
1731 procedure Super_Trim
1732 (Source
: in out Super_String
;
1735 Max_Length
: constant Positive := Source
.Max_Length
;
1736 Last
: Natural := Source
.Current_Length
;
1737 First
: Positive := 1;
1738 Temp
: Wide_Wide_String
(1 .. Max_Length
);
1741 Temp
(1 .. Last
) := Source
.Data
(1 .. Last
);
1743 if Side
= Left
or else Side
= Both
then
1744 while First
<= Last
and then Temp
(First
) = ' ' loop
1749 if Side
= Right
or else Side
= Both
then
1750 while Last
>= First
and then Temp
(Last
) = ' ' loop
1755 Source
.Data
:= (others => Wide_Wide_NUL
);
1756 Source
.Current_Length
:= Last
- First
+ 1;
1757 Source
.Data
(1 .. Source
.Current_Length
) := Temp
(First
.. Last
);
1761 (Source
: Super_String
;
1762 Left
: Wide_Wide_Maps
.Wide_Wide_Character_Set
;
1763 Right
: Wide_Wide_Maps
.Wide_Wide_Character_Set
) return Super_String
1765 Result
: Super_String
(Source
.Max_Length
);
1768 for First
in 1 .. Source
.Current_Length
loop
1769 if not Is_In
(Source
.Data
(First
), Left
) then
1770 for Last
in reverse First
.. Source
.Current_Length
loop
1771 if not Is_In
(Source
.Data
(Last
), Right
) then
1772 Result
.Current_Length
:= Last
- First
+ 1;
1773 Result
.Data
(1 .. Result
.Current_Length
) :=
1774 Source
.Data
(First
.. Last
);
1781 Result
.Current_Length
:= 0;
1785 procedure Super_Trim
1786 (Source
: in out Super_String
;
1787 Left
: Wide_Wide_Maps
.Wide_Wide_Character_Set
;
1788 Right
: Wide_Wide_Maps
.Wide_Wide_Character_Set
)
1791 for First
in 1 .. Source
.Current_Length
loop
1792 if not Is_In
(Source
.Data
(First
), Left
) then
1793 for Last
in reverse First
.. Source
.Current_Length
loop
1794 if not Is_In
(Source
.Data
(Last
), Right
) then
1796 Source
.Current_Length
:= Last
;
1799 Source
.Current_Length
:= Last
- First
+ 1;
1800 Source
.Data
(1 .. Source
.Current_Length
) :=
1801 Source
.Data
(First
.. Last
);
1803 for J
in Source
.Current_Length
+ 1 ..
1806 Source
.Data
(J
) := Wide_Wide_NUL
;
1814 Source
.Current_Length
:= 0;
1819 Source
.Current_Length
:= 0;
1828 Right
: Wide_Wide_Character
;
1829 Max_Length
: Positive) return Super_String
1831 Result
: Super_String
(Max_Length
);
1834 if Left
> Max_Length
then
1835 raise Ada
.Strings
.Length_Error
;
1838 Result
.Current_Length
:= Left
;
1840 for J
in 1 .. Left
loop
1841 Result
.Data
(J
) := Right
;
1850 Right
: Wide_Wide_String
;
1851 Max_Length
: Positive) return Super_String
1853 Result
: Super_String
(Max_Length
);
1854 Pos
: Positive := 1;
1855 Rlen
: constant Natural := Right
'Length;
1856 Nlen
: constant Natural := Left
* Rlen
;
1859 if Nlen
> Max_Length
then
1860 raise Ada
.Strings
.Index_Error
;
1863 Result
.Current_Length
:= Nlen
;
1866 for J
in 1 .. Left
loop
1867 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) := Right
;
1878 Right
: Super_String
) return Super_String
1880 Result
: Super_String
(Right
.Max_Length
);
1881 Pos
: Positive := 1;
1882 Rlen
: constant Natural := Right
.Current_Length
;
1883 Nlen
: constant Natural := Left
* Rlen
;
1886 if Nlen
> Right
.Max_Length
then
1887 raise Ada
.Strings
.Length_Error
;
1890 Result
.Current_Length
:= Nlen
;
1893 for J
in 1 .. Left
loop
1894 Result
.Data
(Pos
.. Pos
+ Rlen
- 1) :=
1895 Right
.Data
(1 .. Rlen
);
1904 ---------------------
1905 -- To_Super_String --
1906 ---------------------
1908 function To_Super_String
1909 (Source
: Wide_Wide_String
;
1910 Max_Length
: Natural;
1911 Drop
: Truncation
:= Error
) return Super_String
1913 Result
: Super_String
(Max_Length
);
1914 Slen
: constant Natural := Source
'Length;
1917 if Slen
<= Max_Length
then
1918 Result
.Current_Length
:= Slen
;
1919 Result
.Data
(1 .. Slen
) := Source
;
1923 when Strings
.Right
=>
1924 Result
.Current_Length
:= Max_Length
;
1925 Result
.Data
(1 .. Max_Length
) :=
1926 Source
(Source
'First .. Source
'First - 1 + Max_Length
);
1928 when Strings
.Left
=>
1929 Result
.Current_Length
:= Max_Length
;
1930 Result
.Data
(1 .. Max_Length
) :=
1931 Source
(Source
'Last - (Max_Length
- 1) .. Source
'Last);
1933 when Strings
.Error
=>
1934 raise Ada
.Strings
.Length_Error
;
1939 end To_Super_String
;
1941 end Ada
.Strings
.Wide_Wide_Superbounded
;