Mercurial > hg > CbC > CbC_gcc
comparison gcc/ada/libgnat/a-strsup.adb @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 ------------------------------------------------------------------------------ | |
2 -- -- | |
3 -- GNAT RUN-TIME COMPONENTS -- | |
4 -- -- | |
5 -- A D A . S T R I N G S . S U P E R B O U N D E D -- | |
6 -- -- | |
7 -- B o d y -- | |
8 -- -- | |
9 -- Copyright (C) 2003-2017, Free Software Foundation, Inc. -- | |
10 -- -- | |
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. -- | |
17 -- -- | |
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. -- | |
21 -- -- | |
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/>. -- | |
26 -- -- | |
27 -- GNAT was originally developed by the GNAT team at New York University. -- | |
28 -- Extensive contributions were provided by Ada Core Technologies Inc. -- | |
29 -- -- | |
30 ------------------------------------------------------------------------------ | |
31 | |
32 with Ada.Strings.Maps; use Ada.Strings.Maps; | |
33 with Ada.Strings.Search; | |
34 | |
35 package body Ada.Strings.Superbounded is | |
36 | |
37 ------------ | |
38 -- Concat -- | |
39 ------------ | |
40 | |
41 function Concat | |
42 (Left : Super_String; | |
43 Right : Super_String) return Super_String | |
44 is | |
45 begin | |
46 return Result : Super_String (Left.Max_Length) do | |
47 declare | |
48 Llen : constant Natural := Left.Current_Length; | |
49 Rlen : constant Natural := Right.Current_Length; | |
50 Nlen : constant Natural := Llen + Rlen; | |
51 begin | |
52 if Nlen > Left.Max_Length then | |
53 raise Ada.Strings.Length_Error; | |
54 end if; | |
55 | |
56 Result.Current_Length := Nlen; | |
57 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
58 Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen); | |
59 end; | |
60 end return; | |
61 end Concat; | |
62 | |
63 function Concat | |
64 (Left : Super_String; | |
65 Right : String) return Super_String | |
66 is | |
67 begin | |
68 return Result : Super_String (Left.Max_Length) do | |
69 declare | |
70 Llen : constant Natural := Left.Current_Length; | |
71 Nlen : constant Natural := Llen + Right'Length; | |
72 begin | |
73 if Nlen > Left.Max_Length then | |
74 raise Ada.Strings.Length_Error; | |
75 end if; | |
76 | |
77 Result.Current_Length := Nlen; | |
78 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
79 Result.Data (Llen + 1 .. Nlen) := Right; | |
80 end; | |
81 end return; | |
82 end Concat; | |
83 | |
84 function Concat | |
85 (Left : String; | |
86 Right : Super_String) return Super_String | |
87 is | |
88 | |
89 begin | |
90 return Result : Super_String (Right.Max_Length) do | |
91 declare | |
92 Llen : constant Natural := Left'Length; | |
93 Rlen : constant Natural := Right.Current_Length; | |
94 Nlen : constant Natural := Llen + Rlen; | |
95 begin | |
96 if Nlen > Right.Max_Length then | |
97 raise Ada.Strings.Length_Error; | |
98 end if; | |
99 | |
100 Result.Current_Length := Nlen; | |
101 Result.Data (1 .. Llen) := Left; | |
102 Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen); | |
103 end; | |
104 end return; | |
105 end Concat; | |
106 | |
107 function Concat | |
108 (Left : Super_String; | |
109 Right : Character) return Super_String | |
110 is | |
111 begin | |
112 return Result : Super_String (Left.Max_Length) do | |
113 declare | |
114 Llen : constant Natural := Left.Current_Length; | |
115 begin | |
116 if Llen = Left.Max_Length then | |
117 raise Ada.Strings.Length_Error; | |
118 end if; | |
119 | |
120 Result.Current_Length := Llen + 1; | |
121 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
122 Result.Data (Result.Current_Length) := Right; | |
123 end; | |
124 end return; | |
125 end Concat; | |
126 | |
127 function Concat | |
128 (Left : Character; | |
129 Right : Super_String) return Super_String | |
130 is | |
131 begin | |
132 return Result : Super_String (Right.Max_Length) do | |
133 declare | |
134 Rlen : constant Natural := Right.Current_Length; | |
135 begin | |
136 if Rlen = Right.Max_Length then | |
137 raise Ada.Strings.Length_Error; | |
138 end if; | |
139 | |
140 Result.Current_Length := Rlen + 1; | |
141 Result.Data (1) := Left; | |
142 Result.Data (2 .. Result.Current_Length) := | |
143 Right.Data (1 .. Rlen); | |
144 end; | |
145 end return; | |
146 end Concat; | |
147 | |
148 ----------- | |
149 -- Equal -- | |
150 ----------- | |
151 | |
152 function "=" | |
153 (Left : Super_String; | |
154 Right : Super_String) return Boolean | |
155 is | |
156 begin | |
157 return Left.Current_Length = Right.Current_Length | |
158 and then Left.Data (1 .. Left.Current_Length) = | |
159 Right.Data (1 .. Right.Current_Length); | |
160 end "="; | |
161 | |
162 function Equal | |
163 (Left : Super_String; | |
164 Right : String) return Boolean | |
165 is | |
166 begin | |
167 return Left.Current_Length = Right'Length | |
168 and then Left.Data (1 .. Left.Current_Length) = Right; | |
169 end Equal; | |
170 | |
171 function Equal | |
172 (Left : String; | |
173 Right : Super_String) return Boolean | |
174 is | |
175 begin | |
176 return Left'Length = Right.Current_Length | |
177 and then Left = Right.Data (1 .. Right.Current_Length); | |
178 end Equal; | |
179 | |
180 ------------- | |
181 -- Greater -- | |
182 ------------- | |
183 | |
184 function Greater | |
185 (Left : Super_String; | |
186 Right : Super_String) return Boolean | |
187 is | |
188 begin | |
189 return Left.Data (1 .. Left.Current_Length) > | |
190 Right.Data (1 .. Right.Current_Length); | |
191 end Greater; | |
192 | |
193 function Greater | |
194 (Left : Super_String; | |
195 Right : String) return Boolean | |
196 is | |
197 begin | |
198 return Left.Data (1 .. Left.Current_Length) > Right; | |
199 end Greater; | |
200 | |
201 function Greater | |
202 (Left : String; | |
203 Right : Super_String) return Boolean | |
204 is | |
205 begin | |
206 return Left > Right.Data (1 .. Right.Current_Length); | |
207 end Greater; | |
208 | |
209 ---------------------- | |
210 -- Greater_Or_Equal -- | |
211 ---------------------- | |
212 | |
213 function Greater_Or_Equal | |
214 (Left : Super_String; | |
215 Right : Super_String) return Boolean | |
216 is | |
217 begin | |
218 return Left.Data (1 .. Left.Current_Length) >= | |
219 Right.Data (1 .. Right.Current_Length); | |
220 end Greater_Or_Equal; | |
221 | |
222 function Greater_Or_Equal | |
223 (Left : Super_String; | |
224 Right : String) return Boolean | |
225 is | |
226 begin | |
227 return Left.Data (1 .. Left.Current_Length) >= Right; | |
228 end Greater_Or_Equal; | |
229 | |
230 function Greater_Or_Equal | |
231 (Left : String; | |
232 Right : Super_String) return Boolean | |
233 is | |
234 begin | |
235 return Left >= Right.Data (1 .. Right.Current_Length); | |
236 end Greater_Or_Equal; | |
237 | |
238 ---------- | |
239 -- Less -- | |
240 ---------- | |
241 | |
242 function Less | |
243 (Left : Super_String; | |
244 Right : Super_String) return Boolean | |
245 is | |
246 begin | |
247 return Left.Data (1 .. Left.Current_Length) < | |
248 Right.Data (1 .. Right.Current_Length); | |
249 end Less; | |
250 | |
251 function Less | |
252 (Left : Super_String; | |
253 Right : String) return Boolean | |
254 is | |
255 begin | |
256 return Left.Data (1 .. Left.Current_Length) < Right; | |
257 end Less; | |
258 | |
259 function Less | |
260 (Left : String; | |
261 Right : Super_String) return Boolean | |
262 is | |
263 begin | |
264 return Left < Right.Data (1 .. Right.Current_Length); | |
265 end Less; | |
266 | |
267 ------------------- | |
268 -- Less_Or_Equal -- | |
269 ------------------- | |
270 | |
271 function Less_Or_Equal | |
272 (Left : Super_String; | |
273 Right : Super_String) return Boolean | |
274 is | |
275 begin | |
276 return Left.Data (1 .. Left.Current_Length) <= | |
277 Right.Data (1 .. Right.Current_Length); | |
278 end Less_Or_Equal; | |
279 | |
280 function Less_Or_Equal | |
281 (Left : Super_String; | |
282 Right : String) return Boolean | |
283 is | |
284 begin | |
285 return Left.Data (1 .. Left.Current_Length) <= Right; | |
286 end Less_Or_Equal; | |
287 | |
288 function Less_Or_Equal | |
289 (Left : String; | |
290 Right : Super_String) return Boolean | |
291 is | |
292 begin | |
293 return Left <= Right.Data (1 .. Right.Current_Length); | |
294 end Less_Or_Equal; | |
295 | |
296 ---------------------- | |
297 -- Set_Super_String -- | |
298 ---------------------- | |
299 | |
300 procedure Set_Super_String | |
301 (Target : out Super_String; | |
302 Source : String; | |
303 Drop : Truncation := Error) | |
304 is | |
305 Slen : constant Natural := Source'Length; | |
306 Max_Length : constant Positive := Target.Max_Length; | |
307 | |
308 begin | |
309 if Slen <= Max_Length then | |
310 Target.Current_Length := Slen; | |
311 Target.Data (1 .. Slen) := Source; | |
312 | |
313 else | |
314 case Drop is | |
315 when Strings.Right => | |
316 Target.Current_Length := Max_Length; | |
317 Target.Data (1 .. Max_Length) := | |
318 Source (Source'First .. Source'First - 1 + Max_Length); | |
319 | |
320 when Strings.Left => | |
321 Target.Current_Length := Max_Length; | |
322 Target.Data (1 .. Max_Length) := | |
323 Source (Source'Last - (Max_Length - 1) .. Source'Last); | |
324 | |
325 when Strings.Error => | |
326 raise Ada.Strings.Length_Error; | |
327 end case; | |
328 end if; | |
329 end Set_Super_String; | |
330 | |
331 ------------------ | |
332 -- Super_Append -- | |
333 ------------------ | |
334 | |
335 -- Case of Super_String and Super_String | |
336 | |
337 function Super_Append | |
338 (Left : Super_String; | |
339 Right : Super_String; | |
340 Drop : Truncation := Error) return Super_String | |
341 is | |
342 Max_Length : constant Positive := Left.Max_Length; | |
343 Result : Super_String (Max_Length); | |
344 Llen : constant Natural := Left.Current_Length; | |
345 Rlen : constant Natural := Right.Current_Length; | |
346 Nlen : constant Natural := Llen + Rlen; | |
347 | |
348 begin | |
349 if Nlen <= Max_Length then | |
350 Result.Current_Length := Nlen; | |
351 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
352 Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen); | |
353 | |
354 else | |
355 Result.Current_Length := Max_Length; | |
356 | |
357 case Drop is | |
358 when Strings.Right => | |
359 if Llen >= Max_Length then -- only case is Llen = Max_Length | |
360 Result.Data := Left.Data; | |
361 | |
362 else | |
363 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
364 Result.Data (Llen + 1 .. Max_Length) := | |
365 Right.Data (1 .. Max_Length - Llen); | |
366 end if; | |
367 | |
368 when Strings.Left => | |
369 if Rlen >= Max_Length then -- only case is Rlen = Max_Length | |
370 Result.Data := Right.Data; | |
371 | |
372 else | |
373 Result.Data (1 .. Max_Length - Rlen) := | |
374 Left.Data (Llen - (Max_Length - Rlen - 1) .. Llen); | |
375 Result.Data (Max_Length - Rlen + 1 .. Max_Length) := | |
376 Right.Data (1 .. Rlen); | |
377 end if; | |
378 | |
379 when Strings.Error => | |
380 raise Ada.Strings.Length_Error; | |
381 end case; | |
382 end if; | |
383 | |
384 return Result; | |
385 end Super_Append; | |
386 | |
387 procedure Super_Append | |
388 (Source : in out Super_String; | |
389 New_Item : Super_String; | |
390 Drop : Truncation := Error) | |
391 is | |
392 Max_Length : constant Positive := Source.Max_Length; | |
393 Llen : constant Natural := Source.Current_Length; | |
394 Rlen : constant Natural := New_Item.Current_Length; | |
395 Nlen : constant Natural := Llen + Rlen; | |
396 | |
397 begin | |
398 if Nlen <= Max_Length then | |
399 Source.Current_Length := Nlen; | |
400 Source.Data (Llen + 1 .. Nlen) := New_Item.Data (1 .. Rlen); | |
401 | |
402 else | |
403 Source.Current_Length := Max_Length; | |
404 | |
405 case Drop is | |
406 when Strings.Right => | |
407 if Llen < Max_Length then | |
408 Source.Data (Llen + 1 .. Max_Length) := | |
409 New_Item.Data (1 .. Max_Length - Llen); | |
410 end if; | |
411 | |
412 when Strings.Left => | |
413 if Rlen >= Max_Length then -- only case is Rlen = Max_Length | |
414 Source.Data := New_Item.Data; | |
415 | |
416 else | |
417 Source.Data (1 .. Max_Length - Rlen) := | |
418 Source.Data (Llen - (Max_Length - Rlen - 1) .. Llen); | |
419 Source.Data (Max_Length - Rlen + 1 .. Max_Length) := | |
420 New_Item.Data (1 .. Rlen); | |
421 end if; | |
422 | |
423 when Strings.Error => | |
424 raise Ada.Strings.Length_Error; | |
425 end case; | |
426 end if; | |
427 | |
428 end Super_Append; | |
429 | |
430 -- Case of Super_String and String | |
431 | |
432 function Super_Append | |
433 (Left : Super_String; | |
434 Right : String; | |
435 Drop : Strings.Truncation := Strings.Error) return Super_String | |
436 is | |
437 Max_Length : constant Positive := Left.Max_Length; | |
438 Result : Super_String (Max_Length); | |
439 Llen : constant Natural := Left.Current_Length; | |
440 Rlen : constant Natural := Right'Length; | |
441 Nlen : constant Natural := Llen + Rlen; | |
442 | |
443 begin | |
444 if Nlen <= Max_Length then | |
445 Result.Current_Length := Nlen; | |
446 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
447 Result.Data (Llen + 1 .. Nlen) := Right; | |
448 | |
449 else | |
450 Result.Current_Length := Max_Length; | |
451 | |
452 case Drop is | |
453 when Strings.Right => | |
454 if Llen >= Max_Length then -- only case is Llen = Max_Length | |
455 Result.Data := Left.Data; | |
456 | |
457 else | |
458 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
459 Result.Data (Llen + 1 .. Max_Length) := | |
460 Right (Right'First .. Right'First - 1 + | |
461 Max_Length - Llen); | |
462 | |
463 end if; | |
464 | |
465 when Strings.Left => | |
466 if Rlen >= Max_Length then | |
467 Result.Data (1 .. Max_Length) := | |
468 Right (Right'Last - (Max_Length - 1) .. Right'Last); | |
469 | |
470 else | |
471 Result.Data (1 .. Max_Length - Rlen) := | |
472 Left.Data (Llen - (Max_Length - Rlen - 1) .. Llen); | |
473 Result.Data (Max_Length - Rlen + 1 .. Max_Length) := | |
474 Right; | |
475 end if; | |
476 | |
477 when Strings.Error => | |
478 raise Ada.Strings.Length_Error; | |
479 end case; | |
480 end if; | |
481 | |
482 return Result; | |
483 end Super_Append; | |
484 | |
485 procedure Super_Append | |
486 (Source : in out Super_String; | |
487 New_Item : String; | |
488 Drop : Truncation := Error) | |
489 is | |
490 Max_Length : constant Positive := Source.Max_Length; | |
491 Llen : constant Natural := Source.Current_Length; | |
492 Rlen : constant Natural := New_Item'Length; | |
493 Nlen : constant Natural := Llen + Rlen; | |
494 | |
495 begin | |
496 if Nlen <= Max_Length then | |
497 Source.Current_Length := Nlen; | |
498 Source.Data (Llen + 1 .. Nlen) := New_Item; | |
499 | |
500 else | |
501 Source.Current_Length := Max_Length; | |
502 | |
503 case Drop is | |
504 when Strings.Right => | |
505 if Llen < Max_Length then | |
506 Source.Data (Llen + 1 .. Max_Length) := | |
507 New_Item (New_Item'First .. | |
508 New_Item'First - 1 + Max_Length - Llen); | |
509 end if; | |
510 | |
511 when Strings.Left => | |
512 if Rlen >= Max_Length then | |
513 Source.Data (1 .. Max_Length) := | |
514 New_Item (New_Item'Last - (Max_Length - 1) .. | |
515 New_Item'Last); | |
516 | |
517 else | |
518 Source.Data (1 .. Max_Length - Rlen) := | |
519 Source.Data (Llen - (Max_Length - Rlen - 1) .. Llen); | |
520 Source.Data (Max_Length - Rlen + 1 .. Max_Length) := | |
521 New_Item; | |
522 end if; | |
523 | |
524 when Strings.Error => | |
525 raise Ada.Strings.Length_Error; | |
526 end case; | |
527 end if; | |
528 | |
529 end Super_Append; | |
530 | |
531 -- Case of String and Super_String | |
532 | |
533 function Super_Append | |
534 (Left : String; | |
535 Right : Super_String; | |
536 Drop : Strings.Truncation := Strings.Error) return Super_String | |
537 is | |
538 Max_Length : constant Positive := Right.Max_Length; | |
539 Result : Super_String (Max_Length); | |
540 Llen : constant Natural := Left'Length; | |
541 Rlen : constant Natural := Right.Current_Length; | |
542 Nlen : constant Natural := Llen + Rlen; | |
543 | |
544 begin | |
545 if Nlen <= Max_Length then | |
546 Result.Current_Length := Nlen; | |
547 Result.Data (1 .. Llen) := Left; | |
548 Result.Data (Llen + 1 .. Llen + Rlen) := Right.Data (1 .. Rlen); | |
549 | |
550 else | |
551 Result.Current_Length := Max_Length; | |
552 | |
553 case Drop is | |
554 when Strings.Right => | |
555 if Llen >= Max_Length then | |
556 Result.Data (1 .. Max_Length) := | |
557 Left (Left'First .. Left'First + (Max_Length - 1)); | |
558 | |
559 else | |
560 Result.Data (1 .. Llen) := Left; | |
561 Result.Data (Llen + 1 .. Max_Length) := | |
562 Right.Data (1 .. Max_Length - Llen); | |
563 end if; | |
564 | |
565 when Strings.Left => | |
566 if Rlen >= Max_Length then | |
567 Result.Data (1 .. Max_Length) := | |
568 Right.Data (Rlen - (Max_Length - 1) .. Rlen); | |
569 | |
570 else | |
571 Result.Data (1 .. Max_Length - Rlen) := | |
572 Left (Left'Last - (Max_Length - Rlen - 1) .. Left'Last); | |
573 Result.Data (Max_Length - Rlen + 1 .. Max_Length) := | |
574 Right.Data (1 .. Rlen); | |
575 end if; | |
576 | |
577 when Strings.Error => | |
578 raise Ada.Strings.Length_Error; | |
579 end case; | |
580 end if; | |
581 | |
582 return Result; | |
583 end Super_Append; | |
584 | |
585 -- Case of Super_String and Character | |
586 | |
587 function Super_Append | |
588 (Left : Super_String; | |
589 Right : Character; | |
590 Drop : Strings.Truncation := Strings.Error) return Super_String | |
591 is | |
592 Max_Length : constant Positive := Left.Max_Length; | |
593 Result : Super_String (Max_Length); | |
594 Llen : constant Natural := Left.Current_Length; | |
595 | |
596 begin | |
597 if Llen < Max_Length then | |
598 Result.Current_Length := Llen + 1; | |
599 Result.Data (1 .. Llen) := Left.Data (1 .. Llen); | |
600 Result.Data (Llen + 1) := Right; | |
601 return Result; | |
602 | |
603 else | |
604 case Drop is | |
605 when Strings.Right => | |
606 return Left; | |
607 | |
608 when Strings.Left => | |
609 Result.Current_Length := Max_Length; | |
610 Result.Data (1 .. Max_Length - 1) := | |
611 Left.Data (2 .. Max_Length); | |
612 Result.Data (Max_Length) := Right; | |
613 return Result; | |
614 | |
615 when Strings.Error => | |
616 raise Ada.Strings.Length_Error; | |
617 end case; | |
618 end if; | |
619 end Super_Append; | |
620 | |
621 procedure Super_Append | |
622 (Source : in out Super_String; | |
623 New_Item : Character; | |
624 Drop : Truncation := Error) | |
625 is | |
626 Max_Length : constant Positive := Source.Max_Length; | |
627 Llen : constant Natural := Source.Current_Length; | |
628 | |
629 begin | |
630 if Llen < Max_Length then | |
631 Source.Current_Length := Llen + 1; | |
632 Source.Data (Llen + 1) := New_Item; | |
633 | |
634 else | |
635 Source.Current_Length := Max_Length; | |
636 | |
637 case Drop is | |
638 when Strings.Right => | |
639 null; | |
640 | |
641 when Strings.Left => | |
642 Source.Data (1 .. Max_Length - 1) := | |
643 Source.Data (2 .. Max_Length); | |
644 Source.Data (Max_Length) := New_Item; | |
645 | |
646 when Strings.Error => | |
647 raise Ada.Strings.Length_Error; | |
648 end case; | |
649 end if; | |
650 | |
651 end Super_Append; | |
652 | |
653 -- Case of Character and Super_String | |
654 | |
655 function Super_Append | |
656 (Left : Character; | |
657 Right : Super_String; | |
658 Drop : Strings.Truncation := Strings.Error) return Super_String | |
659 is | |
660 Max_Length : constant Positive := Right.Max_Length; | |
661 Result : Super_String (Max_Length); | |
662 Rlen : constant Natural := Right.Current_Length; | |
663 | |
664 begin | |
665 if Rlen < Max_Length then | |
666 Result.Current_Length := Rlen + 1; | |
667 Result.Data (1) := Left; | |
668 Result.Data (2 .. Rlen + 1) := Right.Data (1 .. Rlen); | |
669 return Result; | |
670 | |
671 else | |
672 case Drop is | |
673 when Strings.Right => | |
674 Result.Current_Length := Max_Length; | |
675 Result.Data (1) := Left; | |
676 Result.Data (2 .. Max_Length) := | |
677 Right.Data (1 .. Max_Length - 1); | |
678 return Result; | |
679 | |
680 when Strings.Left => | |
681 return Right; | |
682 | |
683 when Strings.Error => | |
684 raise Ada.Strings.Length_Error; | |
685 end case; | |
686 end if; | |
687 end Super_Append; | |
688 | |
689 ----------------- | |
690 -- Super_Count -- | |
691 ----------------- | |
692 | |
693 function Super_Count | |
694 (Source : Super_String; | |
695 Pattern : String; | |
696 Mapping : Maps.Character_Mapping := Maps.Identity) return Natural | |
697 is | |
698 begin | |
699 return | |
700 Search.Count | |
701 (Source.Data (1 .. Source.Current_Length), Pattern, Mapping); | |
702 end Super_Count; | |
703 | |
704 function Super_Count | |
705 (Source : Super_String; | |
706 Pattern : String; | |
707 Mapping : Maps.Character_Mapping_Function) return Natural | |
708 is | |
709 begin | |
710 return | |
711 Search.Count | |
712 (Source.Data (1 .. Source.Current_Length), Pattern, Mapping); | |
713 end Super_Count; | |
714 | |
715 function Super_Count | |
716 (Source : Super_String; | |
717 Set : Maps.Character_Set) return Natural | |
718 is | |
719 begin | |
720 return Search.Count (Source.Data (1 .. Source.Current_Length), Set); | |
721 end Super_Count; | |
722 | |
723 ------------------ | |
724 -- Super_Delete -- | |
725 ------------------ | |
726 | |
727 function Super_Delete | |
728 (Source : Super_String; | |
729 From : Positive; | |
730 Through : Natural) return Super_String | |
731 is | |
732 Result : Super_String (Source.Max_Length); | |
733 Slen : constant Natural := Source.Current_Length; | |
734 Num_Delete : constant Integer := Through - From + 1; | |
735 | |
736 begin | |
737 if Num_Delete <= 0 then | |
738 return Source; | |
739 | |
740 elsif From > Slen + 1 then | |
741 raise Ada.Strings.Index_Error; | |
742 | |
743 elsif Through >= Slen then | |
744 Result.Current_Length := From - 1; | |
745 Result.Data (1 .. From - 1) := Source.Data (1 .. From - 1); | |
746 return Result; | |
747 | |
748 else | |
749 Result.Current_Length := Slen - Num_Delete; | |
750 Result.Data (1 .. From - 1) := Source.Data (1 .. From - 1); | |
751 Result.Data (From .. Result.Current_Length) := | |
752 Source.Data (Through + 1 .. Slen); | |
753 return Result; | |
754 end if; | |
755 end Super_Delete; | |
756 | |
757 procedure Super_Delete | |
758 (Source : in out Super_String; | |
759 From : Positive; | |
760 Through : Natural) | |
761 is | |
762 Slen : constant Natural := Source.Current_Length; | |
763 Num_Delete : constant Integer := Through - From + 1; | |
764 | |
765 begin | |
766 if Num_Delete <= 0 then | |
767 return; | |
768 | |
769 elsif From > Slen + 1 then | |
770 raise Ada.Strings.Index_Error; | |
771 | |
772 elsif Through >= Slen then | |
773 Source.Current_Length := From - 1; | |
774 | |
775 else | |
776 Source.Current_Length := Slen - Num_Delete; | |
777 Source.Data (From .. Source.Current_Length) := | |
778 Source.Data (Through + 1 .. Slen); | |
779 end if; | |
780 end Super_Delete; | |
781 | |
782 ------------------- | |
783 -- Super_Element -- | |
784 ------------------- | |
785 | |
786 function Super_Element | |
787 (Source : Super_String; | |
788 Index : Positive) return Character | |
789 is | |
790 begin | |
791 if Index <= Source.Current_Length then | |
792 return Source.Data (Index); | |
793 else | |
794 raise Strings.Index_Error; | |
795 end if; | |
796 end Super_Element; | |
797 | |
798 ---------------------- | |
799 -- Super_Find_Token -- | |
800 ---------------------- | |
801 | |
802 procedure Super_Find_Token | |
803 (Source : Super_String; | |
804 Set : Maps.Character_Set; | |
805 From : Positive; | |
806 Test : Strings.Membership; | |
807 First : out Positive; | |
808 Last : out Natural) | |
809 is | |
810 begin | |
811 Search.Find_Token | |
812 (Source.Data (From .. Source.Current_Length), Set, Test, First, Last); | |
813 end Super_Find_Token; | |
814 | |
815 procedure Super_Find_Token | |
816 (Source : Super_String; | |
817 Set : Maps.Character_Set; | |
818 Test : Strings.Membership; | |
819 First : out Positive; | |
820 Last : out Natural) | |
821 is | |
822 begin | |
823 Search.Find_Token | |
824 (Source.Data (1 .. Source.Current_Length), Set, Test, First, Last); | |
825 end Super_Find_Token; | |
826 | |
827 ---------------- | |
828 -- Super_Head -- | |
829 ---------------- | |
830 | |
831 function Super_Head | |
832 (Source : Super_String; | |
833 Count : Natural; | |
834 Pad : Character := Space; | |
835 Drop : Strings.Truncation := Strings.Error) return Super_String | |
836 is | |
837 Max_Length : constant Positive := Source.Max_Length; | |
838 Result : Super_String (Max_Length); | |
839 Slen : constant Natural := Source.Current_Length; | |
840 Npad : constant Integer := Count - Slen; | |
841 | |
842 begin | |
843 if Npad <= 0 then | |
844 Result.Current_Length := Count; | |
845 Result.Data (1 .. Count) := Source.Data (1 .. Count); | |
846 | |
847 elsif Count <= Max_Length then | |
848 Result.Current_Length := Count; | |
849 Result.Data (1 .. Slen) := Source.Data (1 .. Slen); | |
850 Result.Data (Slen + 1 .. Count) := (others => Pad); | |
851 | |
852 else | |
853 Result.Current_Length := Max_Length; | |
854 | |
855 case Drop is | |
856 when Strings.Right => | |
857 Result.Data (1 .. Slen) := Source.Data (1 .. Slen); | |
858 Result.Data (Slen + 1 .. Max_Length) := (others => Pad); | |
859 | |
860 when Strings.Left => | |
861 if Npad >= Max_Length then | |
862 Result.Data := (others => Pad); | |
863 | |
864 else | |
865 Result.Data (1 .. Max_Length - Npad) := | |
866 Source.Data (Count - Max_Length + 1 .. Slen); | |
867 Result.Data (Max_Length - Npad + 1 .. Max_Length) := | |
868 (others => Pad); | |
869 end if; | |
870 | |
871 when Strings.Error => | |
872 raise Ada.Strings.Length_Error; | |
873 end case; | |
874 end if; | |
875 | |
876 return Result; | |
877 end Super_Head; | |
878 | |
879 procedure Super_Head | |
880 (Source : in out Super_String; | |
881 Count : Natural; | |
882 Pad : Character := Space; | |
883 Drop : Truncation := Error) | |
884 is | |
885 Max_Length : constant Positive := Source.Max_Length; | |
886 Slen : constant Natural := Source.Current_Length; | |
887 Npad : constant Integer := Count - Slen; | |
888 Temp : String (1 .. Max_Length); | |
889 | |
890 begin | |
891 if Npad <= 0 then | |
892 Source.Current_Length := Count; | |
893 | |
894 elsif Count <= Max_Length then | |
895 Source.Current_Length := Count; | |
896 Source.Data (Slen + 1 .. Count) := (others => Pad); | |
897 | |
898 else | |
899 Source.Current_Length := Max_Length; | |
900 | |
901 case Drop is | |
902 when Strings.Right => | |
903 Source.Data (Slen + 1 .. Max_Length) := (others => Pad); | |
904 | |
905 when Strings.Left => | |
906 if Npad > Max_Length then | |
907 Source.Data := (others => Pad); | |
908 | |
909 else | |
910 Temp := Source.Data; | |
911 Source.Data (1 .. Max_Length - Npad) := | |
912 Temp (Count - Max_Length + 1 .. Slen); | |
913 | |
914 for J in Max_Length - Npad + 1 .. Max_Length loop | |
915 Source.Data (J) := Pad; | |
916 end loop; | |
917 end if; | |
918 | |
919 when Strings.Error => | |
920 raise Ada.Strings.Length_Error; | |
921 end case; | |
922 end if; | |
923 end Super_Head; | |
924 | |
925 ----------------- | |
926 -- Super_Index -- | |
927 ----------------- | |
928 | |
929 function Super_Index | |
930 (Source : Super_String; | |
931 Pattern : String; | |
932 Going : Strings.Direction := Strings.Forward; | |
933 Mapping : Maps.Character_Mapping := Maps.Identity) return Natural | |
934 is | |
935 begin | |
936 return Search.Index | |
937 (Source.Data (1 .. Source.Current_Length), Pattern, Going, Mapping); | |
938 end Super_Index; | |
939 | |
940 function Super_Index | |
941 (Source : Super_String; | |
942 Pattern : String; | |
943 Going : Direction := Forward; | |
944 Mapping : Maps.Character_Mapping_Function) return Natural | |
945 is | |
946 begin | |
947 return Search.Index | |
948 (Source.Data (1 .. Source.Current_Length), Pattern, Going, Mapping); | |
949 end Super_Index; | |
950 | |
951 function Super_Index | |
952 (Source : Super_String; | |
953 Set : Maps.Character_Set; | |
954 Test : Strings.Membership := Strings.Inside; | |
955 Going : Strings.Direction := Strings.Forward) return Natural | |
956 is | |
957 begin | |
958 return Search.Index | |
959 (Source.Data (1 .. Source.Current_Length), Set, Test, Going); | |
960 end Super_Index; | |
961 | |
962 function Super_Index | |
963 (Source : Super_String; | |
964 Pattern : String; | |
965 From : Positive; | |
966 Going : Direction := Forward; | |
967 Mapping : Maps.Character_Mapping := Maps.Identity) return Natural | |
968 is | |
969 begin | |
970 return Search.Index | |
971 (Source.Data (1 .. Source.Current_Length), | |
972 Pattern, From, Going, Mapping); | |
973 end Super_Index; | |
974 | |
975 function Super_Index | |
976 (Source : Super_String; | |
977 Pattern : String; | |
978 From : Positive; | |
979 Going : Direction := Forward; | |
980 Mapping : Maps.Character_Mapping_Function) return Natural | |
981 is | |
982 begin | |
983 return Search.Index | |
984 (Source.Data (1 .. Source.Current_Length), | |
985 Pattern, From, Going, Mapping); | |
986 end Super_Index; | |
987 | |
988 function Super_Index | |
989 (Source : Super_String; | |
990 Set : Maps.Character_Set; | |
991 From : Positive; | |
992 Test : Membership := Inside; | |
993 Going : Direction := Forward) return Natural | |
994 is | |
995 begin | |
996 return Search.Index | |
997 (Source.Data (1 .. Source.Current_Length), Set, From, Test, Going); | |
998 end Super_Index; | |
999 | |
1000 --------------------------- | |
1001 -- Super_Index_Non_Blank -- | |
1002 --------------------------- | |
1003 | |
1004 function Super_Index_Non_Blank | |
1005 (Source : Super_String; | |
1006 Going : Strings.Direction := Strings.Forward) return Natural | |
1007 is | |
1008 begin | |
1009 return | |
1010 Search.Index_Non_Blank | |
1011 (Source.Data (1 .. Source.Current_Length), Going); | |
1012 end Super_Index_Non_Blank; | |
1013 | |
1014 function Super_Index_Non_Blank | |
1015 (Source : Super_String; | |
1016 From : Positive; | |
1017 Going : Direction := Forward) return Natural | |
1018 is | |
1019 begin | |
1020 return | |
1021 Search.Index_Non_Blank | |
1022 (Source.Data (1 .. Source.Current_Length), From, Going); | |
1023 end Super_Index_Non_Blank; | |
1024 | |
1025 ------------------ | |
1026 -- Super_Insert -- | |
1027 ------------------ | |
1028 | |
1029 function Super_Insert | |
1030 (Source : Super_String; | |
1031 Before : Positive; | |
1032 New_Item : String; | |
1033 Drop : Strings.Truncation := Strings.Error) return Super_String | |
1034 is | |
1035 Max_Length : constant Positive := Source.Max_Length; | |
1036 Result : Super_String (Max_Length); | |
1037 Slen : constant Natural := Source.Current_Length; | |
1038 Nlen : constant Natural := New_Item'Length; | |
1039 Tlen : constant Natural := Slen + Nlen; | |
1040 Blen : constant Natural := Before - 1; | |
1041 Alen : constant Integer := Slen - Blen; | |
1042 Droplen : constant Integer := Tlen - Max_Length; | |
1043 | |
1044 -- Tlen is the length of the total string before possible truncation. | |
1045 -- Blen, Alen are the lengths of the before and after pieces of the | |
1046 -- source string. | |
1047 | |
1048 begin | |
1049 if Alen < 0 then | |
1050 raise Ada.Strings.Index_Error; | |
1051 | |
1052 elsif Droplen <= 0 then | |
1053 Result.Current_Length := Tlen; | |
1054 Result.Data (1 .. Blen) := Source.Data (1 .. Blen); | |
1055 Result.Data (Before .. Before + Nlen - 1) := New_Item; | |
1056 Result.Data (Before + Nlen .. Tlen) := | |
1057 Source.Data (Before .. Slen); | |
1058 | |
1059 else | |
1060 Result.Current_Length := Max_Length; | |
1061 | |
1062 case Drop is | |
1063 when Strings.Right => | |
1064 Result.Data (1 .. Blen) := Source.Data (1 .. Blen); | |
1065 | |
1066 if Droplen > Alen then | |
1067 Result.Data (Before .. Max_Length) := | |
1068 New_Item (New_Item'First | |
1069 .. New_Item'First + Max_Length - Before); | |
1070 else | |
1071 Result.Data (Before .. Before + Nlen - 1) := New_Item; | |
1072 Result.Data (Before + Nlen .. Max_Length) := | |
1073 Source.Data (Before .. Slen - Droplen); | |
1074 end if; | |
1075 | |
1076 when Strings.Left => | |
1077 Result.Data (Max_Length - (Alen - 1) .. Max_Length) := | |
1078 Source.Data (Before .. Slen); | |
1079 | |
1080 if Droplen >= Blen then | |
1081 Result.Data (1 .. Max_Length - Alen) := | |
1082 New_Item (New_Item'Last - (Max_Length - Alen) + 1 | |
1083 .. New_Item'Last); | |
1084 else | |
1085 Result.Data | |
1086 (Blen - Droplen + 1 .. Max_Length - Alen) := | |
1087 New_Item; | |
1088 Result.Data (1 .. Blen - Droplen) := | |
1089 Source.Data (Droplen + 1 .. Blen); | |
1090 end if; | |
1091 | |
1092 when Strings.Error => | |
1093 raise Ada.Strings.Length_Error; | |
1094 end case; | |
1095 end if; | |
1096 | |
1097 return Result; | |
1098 end Super_Insert; | |
1099 | |
1100 procedure Super_Insert | |
1101 (Source : in out Super_String; | |
1102 Before : Positive; | |
1103 New_Item : String; | |
1104 Drop : Strings.Truncation := Strings.Error) | |
1105 is | |
1106 begin | |
1107 -- We do a double copy here because this is one of the situations | |
1108 -- in which we move data to the right, and at least at the moment, | |
1109 -- GNAT is not handling such cases correctly ??? | |
1110 | |
1111 Source := Super_Insert (Source, Before, New_Item, Drop); | |
1112 end Super_Insert; | |
1113 | |
1114 ------------------ | |
1115 -- Super_Length -- | |
1116 ------------------ | |
1117 | |
1118 function Super_Length (Source : Super_String) return Natural is | |
1119 begin | |
1120 return Source.Current_Length; | |
1121 end Super_Length; | |
1122 | |
1123 --------------------- | |
1124 -- Super_Overwrite -- | |
1125 --------------------- | |
1126 | |
1127 function Super_Overwrite | |
1128 (Source : Super_String; | |
1129 Position : Positive; | |
1130 New_Item : String; | |
1131 Drop : Strings.Truncation := Strings.Error) return Super_String | |
1132 is | |
1133 Max_Length : constant Positive := Source.Max_Length; | |
1134 Result : Super_String (Max_Length); | |
1135 Endpos : constant Natural := Position + New_Item'Length - 1; | |
1136 Slen : constant Natural := Source.Current_Length; | |
1137 Droplen : Natural; | |
1138 | |
1139 begin | |
1140 if Position > Slen + 1 then | |
1141 raise Ada.Strings.Index_Error; | |
1142 | |
1143 elsif New_Item'Length = 0 then | |
1144 return Source; | |
1145 | |
1146 elsif Endpos <= Slen then | |
1147 Result.Current_Length := Source.Current_Length; | |
1148 Result.Data (1 .. Slen) := Source.Data (1 .. Slen); | |
1149 Result.Data (Position .. Endpos) := New_Item; | |
1150 return Result; | |
1151 | |
1152 elsif Endpos <= Max_Length then | |
1153 Result.Current_Length := Endpos; | |
1154 Result.Data (1 .. Position - 1) := Source.Data (1 .. Position - 1); | |
1155 Result.Data (Position .. Endpos) := New_Item; | |
1156 return Result; | |
1157 | |
1158 else | |
1159 Result.Current_Length := Max_Length; | |
1160 Droplen := Endpos - Max_Length; | |
1161 | |
1162 case Drop is | |
1163 when Strings.Right => | |
1164 Result.Data (1 .. Position - 1) := | |
1165 Source.Data (1 .. Position - 1); | |
1166 | |
1167 Result.Data (Position .. Max_Length) := | |
1168 New_Item (New_Item'First .. New_Item'Last - Droplen); | |
1169 return Result; | |
1170 | |
1171 when Strings.Left => | |
1172 if New_Item'Length >= Max_Length then | |
1173 Result.Data (1 .. Max_Length) := | |
1174 New_Item (New_Item'Last - Max_Length + 1 .. | |
1175 New_Item'Last); | |
1176 return Result; | |
1177 | |
1178 else | |
1179 Result.Data (1 .. Max_Length - New_Item'Length) := | |
1180 Source.Data (Droplen + 1 .. Position - 1); | |
1181 Result.Data | |
1182 (Max_Length - New_Item'Length + 1 .. Max_Length) := | |
1183 New_Item; | |
1184 return Result; | |
1185 end if; | |
1186 | |
1187 when Strings.Error => | |
1188 raise Ada.Strings.Length_Error; | |
1189 end case; | |
1190 end if; | |
1191 end Super_Overwrite; | |
1192 | |
1193 procedure Super_Overwrite | |
1194 (Source : in out Super_String; | |
1195 Position : Positive; | |
1196 New_Item : String; | |
1197 Drop : Strings.Truncation := Strings.Error) | |
1198 is | |
1199 Max_Length : constant Positive := Source.Max_Length; | |
1200 Endpos : constant Positive := Position + New_Item'Length - 1; | |
1201 Slen : constant Natural := Source.Current_Length; | |
1202 Droplen : Natural; | |
1203 | |
1204 begin | |
1205 if Position > Slen + 1 then | |
1206 raise Ada.Strings.Index_Error; | |
1207 | |
1208 elsif Endpos <= Slen then | |
1209 Source.Data (Position .. Endpos) := New_Item; | |
1210 | |
1211 elsif Endpos <= Max_Length then | |
1212 Source.Data (Position .. Endpos) := New_Item; | |
1213 Source.Current_Length := Endpos; | |
1214 | |
1215 else | |
1216 Source.Current_Length := Max_Length; | |
1217 Droplen := Endpos - Max_Length; | |
1218 | |
1219 case Drop is | |
1220 when Strings.Right => | |
1221 Source.Data (Position .. Max_Length) := | |
1222 New_Item (New_Item'First .. New_Item'Last - Droplen); | |
1223 | |
1224 when Strings.Left => | |
1225 if New_Item'Length > Max_Length then | |
1226 Source.Data (1 .. Max_Length) := | |
1227 New_Item (New_Item'Last - Max_Length + 1 .. | |
1228 New_Item'Last); | |
1229 | |
1230 else | |
1231 Source.Data (1 .. Max_Length - New_Item'Length) := | |
1232 Source.Data (Droplen + 1 .. Position - 1); | |
1233 | |
1234 Source.Data | |
1235 (Max_Length - New_Item'Length + 1 .. Max_Length) := | |
1236 New_Item; | |
1237 end if; | |
1238 | |
1239 when Strings.Error => | |
1240 raise Ada.Strings.Length_Error; | |
1241 end case; | |
1242 end if; | |
1243 end Super_Overwrite; | |
1244 | |
1245 --------------------------- | |
1246 -- Super_Replace_Element -- | |
1247 --------------------------- | |
1248 | |
1249 procedure Super_Replace_Element | |
1250 (Source : in out Super_String; | |
1251 Index : Positive; | |
1252 By : Character) | |
1253 is | |
1254 begin | |
1255 if Index <= Source.Current_Length then | |
1256 Source.Data (Index) := By; | |
1257 else | |
1258 raise Ada.Strings.Index_Error; | |
1259 end if; | |
1260 end Super_Replace_Element; | |
1261 | |
1262 ------------------------- | |
1263 -- Super_Replace_Slice -- | |
1264 ------------------------- | |
1265 | |
1266 function Super_Replace_Slice | |
1267 (Source : Super_String; | |
1268 Low : Positive; | |
1269 High : Natural; | |
1270 By : String; | |
1271 Drop : Strings.Truncation := Strings.Error) return Super_String | |
1272 is | |
1273 Max_Length : constant Positive := Source.Max_Length; | |
1274 Slen : constant Natural := Source.Current_Length; | |
1275 | |
1276 begin | |
1277 if Low > Slen + 1 then | |
1278 raise Strings.Index_Error; | |
1279 | |
1280 elsif High < Low then | |
1281 return Super_Insert (Source, Low, By, Drop); | |
1282 | |
1283 else | |
1284 declare | |
1285 Blen : constant Natural := Natural'Max (0, Low - 1); | |
1286 Alen : constant Natural := Natural'Max (0, Slen - High); | |
1287 Tlen : constant Natural := Blen + By'Length + Alen; | |
1288 Droplen : constant Integer := Tlen - Max_Length; | |
1289 Result : Super_String (Max_Length); | |
1290 | |
1291 -- Tlen is the total length of the result string before any | |
1292 -- truncation. Blen and Alen are the lengths of the pieces | |
1293 -- of the original string that end up in the result string | |
1294 -- before and after the replaced slice. | |
1295 | |
1296 begin | |
1297 if Droplen <= 0 then | |
1298 Result.Current_Length := Tlen; | |
1299 Result.Data (1 .. Blen) := Source.Data (1 .. Blen); | |
1300 Result.Data (Low .. Low + By'Length - 1) := By; | |
1301 Result.Data (Low + By'Length .. Tlen) := | |
1302 Source.Data (High + 1 .. Slen); | |
1303 | |
1304 else | |
1305 Result.Current_Length := Max_Length; | |
1306 | |
1307 case Drop is | |
1308 when Strings.Right => | |
1309 Result.Data (1 .. Blen) := Source.Data (1 .. Blen); | |
1310 | |
1311 if Droplen > Alen then | |
1312 Result.Data (Low .. Max_Length) := | |
1313 By (By'First .. By'First + Max_Length - Low); | |
1314 else | |
1315 Result.Data (Low .. Low + By'Length - 1) := By; | |
1316 Result.Data (Low + By'Length .. Max_Length) := | |
1317 Source.Data (High + 1 .. Slen - Droplen); | |
1318 end if; | |
1319 | |
1320 when Strings.Left => | |
1321 Result.Data (Max_Length - (Alen - 1) .. Max_Length) := | |
1322 Source.Data (High + 1 .. Slen); | |
1323 | |
1324 if Droplen >= Blen then | |
1325 Result.Data (1 .. Max_Length - Alen) := | |
1326 By (By'Last - (Max_Length - Alen) + 1 .. By'Last); | |
1327 else | |
1328 Result.Data | |
1329 (Blen - Droplen + 1 .. Max_Length - Alen) := By; | |
1330 Result.Data (1 .. Blen - Droplen) := | |
1331 Source.Data (Droplen + 1 .. Blen); | |
1332 end if; | |
1333 | |
1334 when Strings.Error => | |
1335 raise Ada.Strings.Length_Error; | |
1336 end case; | |
1337 end if; | |
1338 | |
1339 return Result; | |
1340 end; | |
1341 end if; | |
1342 end Super_Replace_Slice; | |
1343 | |
1344 procedure Super_Replace_Slice | |
1345 (Source : in out Super_String; | |
1346 Low : Positive; | |
1347 High : Natural; | |
1348 By : String; | |
1349 Drop : Strings.Truncation := Strings.Error) | |
1350 is | |
1351 begin | |
1352 -- We do a double copy here because this is one of the situations | |
1353 -- in which we move data to the right, and at least at the moment, | |
1354 -- GNAT is not handling such cases correctly ??? | |
1355 | |
1356 Source := Super_Replace_Slice (Source, Low, High, By, Drop); | |
1357 end Super_Replace_Slice; | |
1358 | |
1359 --------------------- | |
1360 -- Super_Replicate -- | |
1361 --------------------- | |
1362 | |
1363 function Super_Replicate | |
1364 (Count : Natural; | |
1365 Item : Character; | |
1366 Drop : Truncation := Error; | |
1367 Max_Length : Positive) return Super_String | |
1368 is | |
1369 Result : Super_String (Max_Length); | |
1370 | |
1371 begin | |
1372 if Count <= Max_Length then | |
1373 Result.Current_Length := Count; | |
1374 | |
1375 elsif Drop = Strings.Error then | |
1376 raise Ada.Strings.Length_Error; | |
1377 | |
1378 else | |
1379 Result.Current_Length := Max_Length; | |
1380 end if; | |
1381 | |
1382 Result.Data (1 .. Result.Current_Length) := (others => Item); | |
1383 return Result; | |
1384 end Super_Replicate; | |
1385 | |
1386 function Super_Replicate | |
1387 (Count : Natural; | |
1388 Item : String; | |
1389 Drop : Truncation := Error; | |
1390 Max_Length : Positive) return Super_String | |
1391 is | |
1392 Length : constant Integer := Count * Item'Length; | |
1393 Result : Super_String (Max_Length); | |
1394 Indx : Positive; | |
1395 | |
1396 begin | |
1397 if Length <= Max_Length then | |
1398 Result.Current_Length := Length; | |
1399 | |
1400 if Length > 0 then | |
1401 Indx := 1; | |
1402 | |
1403 for J in 1 .. Count loop | |
1404 Result.Data (Indx .. Indx + Item'Length - 1) := Item; | |
1405 Indx := Indx + Item'Length; | |
1406 end loop; | |
1407 end if; | |
1408 | |
1409 else | |
1410 Result.Current_Length := Max_Length; | |
1411 | |
1412 case Drop is | |
1413 when Strings.Right => | |
1414 Indx := 1; | |
1415 | |
1416 while Indx + Item'Length <= Max_Length + 1 loop | |
1417 Result.Data (Indx .. Indx + Item'Length - 1) := Item; | |
1418 Indx := Indx + Item'Length; | |
1419 end loop; | |
1420 | |
1421 Result.Data (Indx .. Max_Length) := | |
1422 Item (Item'First .. Item'First + Max_Length - Indx); | |
1423 | |
1424 when Strings.Left => | |
1425 Indx := Max_Length; | |
1426 | |
1427 while Indx - Item'Length >= 1 loop | |
1428 Result.Data (Indx - (Item'Length - 1) .. Indx) := Item; | |
1429 Indx := Indx - Item'Length; | |
1430 end loop; | |
1431 | |
1432 Result.Data (1 .. Indx) := | |
1433 Item (Item'Last - Indx + 1 .. Item'Last); | |
1434 | |
1435 when Strings.Error => | |
1436 raise Ada.Strings.Length_Error; | |
1437 end case; | |
1438 end if; | |
1439 | |
1440 return Result; | |
1441 end Super_Replicate; | |
1442 | |
1443 function Super_Replicate | |
1444 (Count : Natural; | |
1445 Item : Super_String; | |
1446 Drop : Strings.Truncation := Strings.Error) return Super_String | |
1447 is | |
1448 begin | |
1449 return | |
1450 Super_Replicate | |
1451 (Count, | |
1452 Item.Data (1 .. Item.Current_Length), | |
1453 Drop, | |
1454 Item.Max_Length); | |
1455 end Super_Replicate; | |
1456 | |
1457 ----------------- | |
1458 -- Super_Slice -- | |
1459 ----------------- | |
1460 | |
1461 function Super_Slice | |
1462 (Source : Super_String; | |
1463 Low : Positive; | |
1464 High : Natural) return String | |
1465 is | |
1466 begin | |
1467 -- Note: test of High > Length is in accordance with AI95-00128 | |
1468 | |
1469 return R : String (Low .. High) do | |
1470 if Low > Source.Current_Length + 1 | |
1471 or else High > Source.Current_Length | |
1472 then | |
1473 raise Index_Error; | |
1474 end if; | |
1475 | |
1476 -- Note: in this case, superflat bounds are not a problem, we just | |
1477 -- get the null string in accordance with normal Ada slice rules. | |
1478 | |
1479 R := Source.Data (Low .. High); | |
1480 end return; | |
1481 end Super_Slice; | |
1482 | |
1483 function Super_Slice | |
1484 (Source : Super_String; | |
1485 Low : Positive; | |
1486 High : Natural) return Super_String | |
1487 is | |
1488 begin | |
1489 return Result : Super_String (Source.Max_Length) do | |
1490 if Low > Source.Current_Length + 1 | |
1491 or else High > Source.Current_Length | |
1492 then | |
1493 raise Index_Error; | |
1494 end if; | |
1495 | |
1496 -- Note: the Max operation here deals with the superflat case | |
1497 | |
1498 Result.Current_Length := Integer'Max (0, High - Low + 1); | |
1499 Result.Data (1 .. Result.Current_Length) := Source.Data (Low .. High); | |
1500 end return; | |
1501 end Super_Slice; | |
1502 | |
1503 procedure Super_Slice | |
1504 (Source : Super_String; | |
1505 Target : out Super_String; | |
1506 Low : Positive; | |
1507 High : Natural) | |
1508 is | |
1509 begin | |
1510 if Low > Source.Current_Length + 1 | |
1511 or else High > Source.Current_Length | |
1512 then | |
1513 raise Index_Error; | |
1514 end if; | |
1515 | |
1516 -- Note: the Max operation here deals with the superflat case | |
1517 | |
1518 Target.Current_Length := Integer'Max (0, High - Low + 1); | |
1519 Target.Data (1 .. Target.Current_Length) := Source.Data (Low .. High); | |
1520 end Super_Slice; | |
1521 | |
1522 ---------------- | |
1523 -- Super_Tail -- | |
1524 ---------------- | |
1525 | |
1526 function Super_Tail | |
1527 (Source : Super_String; | |
1528 Count : Natural; | |
1529 Pad : Character := Space; | |
1530 Drop : Strings.Truncation := Strings.Error) return Super_String | |
1531 is | |
1532 Max_Length : constant Positive := Source.Max_Length; | |
1533 Result : Super_String (Max_Length); | |
1534 Slen : constant Natural := Source.Current_Length; | |
1535 Npad : constant Integer := Count - Slen; | |
1536 | |
1537 begin | |
1538 if Npad <= 0 then | |
1539 Result.Current_Length := Count; | |
1540 Result.Data (1 .. Count) := | |
1541 Source.Data (Slen - (Count - 1) .. Slen); | |
1542 | |
1543 elsif Count <= Max_Length then | |
1544 Result.Current_Length := Count; | |
1545 Result.Data (1 .. Npad) := (others => Pad); | |
1546 Result.Data (Npad + 1 .. Count) := Source.Data (1 .. Slen); | |
1547 | |
1548 else | |
1549 Result.Current_Length := Max_Length; | |
1550 | |
1551 case Drop is | |
1552 when Strings.Right => | |
1553 if Npad >= Max_Length then | |
1554 Result.Data := (others => Pad); | |
1555 | |
1556 else | |
1557 Result.Data (1 .. Npad) := (others => Pad); | |
1558 Result.Data (Npad + 1 .. Max_Length) := | |
1559 Source.Data (1 .. Max_Length - Npad); | |
1560 end if; | |
1561 | |
1562 when Strings.Left => | |
1563 Result.Data (1 .. Max_Length - Slen) := (others => Pad); | |
1564 Result.Data (Max_Length - Slen + 1 .. Max_Length) := | |
1565 Source.Data (1 .. Slen); | |
1566 | |
1567 when Strings.Error => | |
1568 raise Ada.Strings.Length_Error; | |
1569 end case; | |
1570 end if; | |
1571 | |
1572 return Result; | |
1573 end Super_Tail; | |
1574 | |
1575 procedure Super_Tail | |
1576 (Source : in out Super_String; | |
1577 Count : Natural; | |
1578 Pad : Character := Space; | |
1579 Drop : Truncation := Error) | |
1580 is | |
1581 Max_Length : constant Positive := Source.Max_Length; | |
1582 Slen : constant Natural := Source.Current_Length; | |
1583 Npad : constant Integer := Count - Slen; | |
1584 | |
1585 Temp : constant String (1 .. Max_Length) := Source.Data; | |
1586 | |
1587 begin | |
1588 if Npad <= 0 then | |
1589 Source.Current_Length := Count; | |
1590 Source.Data (1 .. Count) := | |
1591 Temp (Slen - (Count - 1) .. Slen); | |
1592 | |
1593 elsif Count <= Max_Length then | |
1594 Source.Current_Length := Count; | |
1595 Source.Data (1 .. Npad) := (others => Pad); | |
1596 Source.Data (Npad + 1 .. Count) := Temp (1 .. Slen); | |
1597 | |
1598 else | |
1599 Source.Current_Length := Max_Length; | |
1600 | |
1601 case Drop is | |
1602 when Strings.Right => | |
1603 if Npad >= Max_Length then | |
1604 Source.Data := (others => Pad); | |
1605 | |
1606 else | |
1607 Source.Data (1 .. Npad) := (others => Pad); | |
1608 Source.Data (Npad + 1 .. Max_Length) := | |
1609 Temp (1 .. Max_Length - Npad); | |
1610 end if; | |
1611 | |
1612 when Strings.Left => | |
1613 for J in 1 .. Max_Length - Slen loop | |
1614 Source.Data (J) := Pad; | |
1615 end loop; | |
1616 | |
1617 Source.Data (Max_Length - Slen + 1 .. Max_Length) := | |
1618 Temp (1 .. Slen); | |
1619 | |
1620 when Strings.Error => | |
1621 raise Ada.Strings.Length_Error; | |
1622 end case; | |
1623 end if; | |
1624 end Super_Tail; | |
1625 | |
1626 --------------------- | |
1627 -- Super_To_String -- | |
1628 --------------------- | |
1629 | |
1630 function Super_To_String (Source : Super_String) return String is | |
1631 begin | |
1632 return R : String (1 .. Source.Current_Length) do | |
1633 R := Source.Data (1 .. Source.Current_Length); | |
1634 end return; | |
1635 end Super_To_String; | |
1636 | |
1637 --------------------- | |
1638 -- Super_Translate -- | |
1639 --------------------- | |
1640 | |
1641 function Super_Translate | |
1642 (Source : Super_String; | |
1643 Mapping : Maps.Character_Mapping) return Super_String | |
1644 is | |
1645 Result : Super_String (Source.Max_Length); | |
1646 | |
1647 begin | |
1648 Result.Current_Length := Source.Current_Length; | |
1649 | |
1650 for J in 1 .. Source.Current_Length loop | |
1651 Result.Data (J) := Value (Mapping, Source.Data (J)); | |
1652 end loop; | |
1653 | |
1654 return Result; | |
1655 end Super_Translate; | |
1656 | |
1657 procedure Super_Translate | |
1658 (Source : in out Super_String; | |
1659 Mapping : Maps.Character_Mapping) | |
1660 is | |
1661 begin | |
1662 for J in 1 .. Source.Current_Length loop | |
1663 Source.Data (J) := Value (Mapping, Source.Data (J)); | |
1664 end loop; | |
1665 end Super_Translate; | |
1666 | |
1667 function Super_Translate | |
1668 (Source : Super_String; | |
1669 Mapping : Maps.Character_Mapping_Function) return Super_String | |
1670 is | |
1671 Result : Super_String (Source.Max_Length); | |
1672 | |
1673 begin | |
1674 Result.Current_Length := Source.Current_Length; | |
1675 | |
1676 for J in 1 .. Source.Current_Length loop | |
1677 Result.Data (J) := Mapping.all (Source.Data (J)); | |
1678 end loop; | |
1679 | |
1680 return Result; | |
1681 end Super_Translate; | |
1682 | |
1683 procedure Super_Translate | |
1684 (Source : in out Super_String; | |
1685 Mapping : Maps.Character_Mapping_Function) | |
1686 is | |
1687 begin | |
1688 for J in 1 .. Source.Current_Length loop | |
1689 Source.Data (J) := Mapping.all (Source.Data (J)); | |
1690 end loop; | |
1691 end Super_Translate; | |
1692 | |
1693 ---------------- | |
1694 -- Super_Trim -- | |
1695 ---------------- | |
1696 | |
1697 function Super_Trim | |
1698 (Source : Super_String; | |
1699 Side : Trim_End) return Super_String | |
1700 is | |
1701 Result : Super_String (Source.Max_Length); | |
1702 Last : Natural := Source.Current_Length; | |
1703 First : Positive := 1; | |
1704 | |
1705 begin | |
1706 if Side = Left or else Side = Both then | |
1707 while First <= Last and then Source.Data (First) = ' ' loop | |
1708 First := First + 1; | |
1709 end loop; | |
1710 end if; | |
1711 | |
1712 if Side = Right or else Side = Both then | |
1713 while Last >= First and then Source.Data (Last) = ' ' loop | |
1714 Last := Last - 1; | |
1715 end loop; | |
1716 end if; | |
1717 | |
1718 Result.Current_Length := Last - First + 1; | |
1719 Result.Data (1 .. Result.Current_Length) := Source.Data (First .. Last); | |
1720 return Result; | |
1721 end Super_Trim; | |
1722 | |
1723 procedure Super_Trim | |
1724 (Source : in out Super_String; | |
1725 Side : Trim_End) | |
1726 is | |
1727 Max_Length : constant Positive := Source.Max_Length; | |
1728 Last : Natural := Source.Current_Length; | |
1729 First : Positive := 1; | |
1730 Temp : String (1 .. Max_Length); | |
1731 | |
1732 begin | |
1733 Temp (1 .. Last) := Source.Data (1 .. Last); | |
1734 | |
1735 if Side = Left or else Side = Both then | |
1736 while First <= Last and then Temp (First) = ' ' loop | |
1737 First := First + 1; | |
1738 end loop; | |
1739 end if; | |
1740 | |
1741 if Side = Right or else Side = Both then | |
1742 while Last >= First and then Temp (Last) = ' ' loop | |
1743 Last := Last - 1; | |
1744 end loop; | |
1745 end if; | |
1746 | |
1747 Source.Current_Length := Last - First + 1; | |
1748 Source.Data (1 .. Source.Current_Length) := Temp (First .. Last); | |
1749 end Super_Trim; | |
1750 | |
1751 function Super_Trim | |
1752 (Source : Super_String; | |
1753 Left : Maps.Character_Set; | |
1754 Right : Maps.Character_Set) return Super_String | |
1755 is | |
1756 Result : Super_String (Source.Max_Length); | |
1757 | |
1758 begin | |
1759 for First in 1 .. Source.Current_Length loop | |
1760 if not Is_In (Source.Data (First), Left) then | |
1761 for Last in reverse First .. Source.Current_Length loop | |
1762 if not Is_In (Source.Data (Last), Right) then | |
1763 Result.Current_Length := Last - First + 1; | |
1764 Result.Data (1 .. Result.Current_Length) := | |
1765 Source.Data (First .. Last); | |
1766 return Result; | |
1767 end if; | |
1768 end loop; | |
1769 end if; | |
1770 end loop; | |
1771 | |
1772 Result.Current_Length := 0; | |
1773 return Result; | |
1774 end Super_Trim; | |
1775 | |
1776 procedure Super_Trim | |
1777 (Source : in out Super_String; | |
1778 Left : Maps.Character_Set; | |
1779 Right : Maps.Character_Set) | |
1780 is | |
1781 begin | |
1782 for First in 1 .. Source.Current_Length loop | |
1783 if not Is_In (Source.Data (First), Left) then | |
1784 for Last in reverse First .. Source.Current_Length loop | |
1785 if not Is_In (Source.Data (Last), Right) then | |
1786 if First = 1 then | |
1787 Source.Current_Length := Last; | |
1788 return; | |
1789 else | |
1790 Source.Current_Length := Last - First + 1; | |
1791 Source.Data (1 .. Source.Current_Length) := | |
1792 Source.Data (First .. Last); | |
1793 return; | |
1794 end if; | |
1795 end if; | |
1796 end loop; | |
1797 | |
1798 Source.Current_Length := 0; | |
1799 return; | |
1800 end if; | |
1801 end loop; | |
1802 | |
1803 Source.Current_Length := 0; | |
1804 end Super_Trim; | |
1805 | |
1806 ----------- | |
1807 -- Times -- | |
1808 ----------- | |
1809 | |
1810 function Times | |
1811 (Left : Natural; | |
1812 Right : Character; | |
1813 Max_Length : Positive) return Super_String | |
1814 is | |
1815 Result : Super_String (Max_Length); | |
1816 | |
1817 begin | |
1818 if Left > Max_Length then | |
1819 raise Ada.Strings.Length_Error; | |
1820 | |
1821 else | |
1822 Result.Current_Length := Left; | |
1823 | |
1824 for J in 1 .. Left loop | |
1825 Result.Data (J) := Right; | |
1826 end loop; | |
1827 end if; | |
1828 | |
1829 return Result; | |
1830 end Times; | |
1831 | |
1832 function Times | |
1833 (Left : Natural; | |
1834 Right : String; | |
1835 Max_Length : Positive) return Super_String | |
1836 is | |
1837 Result : Super_String (Max_Length); | |
1838 Pos : Positive := 1; | |
1839 Rlen : constant Natural := Right'Length; | |
1840 Nlen : constant Natural := Left * Rlen; | |
1841 | |
1842 begin | |
1843 if Nlen > Max_Length then | |
1844 raise Ada.Strings.Length_Error; | |
1845 | |
1846 else | |
1847 Result.Current_Length := Nlen; | |
1848 | |
1849 if Nlen > 0 then | |
1850 for J in 1 .. Left loop | |
1851 Result.Data (Pos .. Pos + Rlen - 1) := Right; | |
1852 Pos := Pos + Rlen; | |
1853 end loop; | |
1854 end if; | |
1855 end if; | |
1856 | |
1857 return Result; | |
1858 end Times; | |
1859 | |
1860 function Times | |
1861 (Left : Natural; | |
1862 Right : Super_String) return Super_String | |
1863 is | |
1864 Result : Super_String (Right.Max_Length); | |
1865 Pos : Positive := 1; | |
1866 Rlen : constant Natural := Right.Current_Length; | |
1867 Nlen : constant Natural := Left * Rlen; | |
1868 | |
1869 begin | |
1870 if Nlen > Right.Max_Length then | |
1871 raise Ada.Strings.Length_Error; | |
1872 | |
1873 else | |
1874 Result.Current_Length := Nlen; | |
1875 | |
1876 if Nlen > 0 then | |
1877 for J in 1 .. Left loop | |
1878 Result.Data (Pos .. Pos + Rlen - 1) := | |
1879 Right.Data (1 .. Rlen); | |
1880 Pos := Pos + Rlen; | |
1881 end loop; | |
1882 end if; | |
1883 end if; | |
1884 | |
1885 return Result; | |
1886 end Times; | |
1887 | |
1888 --------------------- | |
1889 -- To_Super_String -- | |
1890 --------------------- | |
1891 | |
1892 function To_Super_String | |
1893 (Source : String; | |
1894 Max_Length : Natural; | |
1895 Drop : Truncation := Error) return Super_String | |
1896 is | |
1897 Result : Super_String (Max_Length); | |
1898 Slen : constant Natural := Source'Length; | |
1899 | |
1900 begin | |
1901 if Slen <= Max_Length then | |
1902 Result.Current_Length := Slen; | |
1903 Result.Data (1 .. Slen) := Source; | |
1904 | |
1905 else | |
1906 case Drop is | |
1907 when Strings.Right => | |
1908 Result.Current_Length := Max_Length; | |
1909 Result.Data (1 .. Max_Length) := | |
1910 Source (Source'First .. Source'First - 1 + Max_Length); | |
1911 | |
1912 when Strings.Left => | |
1913 Result.Current_Length := Max_Length; | |
1914 Result.Data (1 .. Max_Length) := | |
1915 Source (Source'Last - (Max_Length - 1) .. Source'Last); | |
1916 | |
1917 when Strings.Error => | |
1918 raise Ada.Strings.Length_Error; | |
1919 end case; | |
1920 end if; | |
1921 | |
1922 return Result; | |
1923 end To_Super_String; | |
1924 | |
1925 end Ada.Strings.Superbounded; |