]>
Commit | Line | Data |
---|---|---|
4c2d6a70 AC |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3084fecd | 3 | -- GNAT RUN-TIME COMPONENTS -- |
4c2d6a70 AC |
4 | -- -- |
5 | -- A D A . S T R I N G S . W I D E _ F I X E D -- | |
6 | -- -- | |
7 | -- B o d y -- | |
8 | -- -- | |
4b490c1e | 9 | -- Copyright (C) 1992-2020, Free Software Foundation, Inc. -- |
4c2d6a70 AC |
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- -- | |
748086b7 | 13 | -- ware Foundation; either version 3, or (at your option) any later ver- -- |
4c2d6a70 AC |
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 -- | |
748086b7 JJ |
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/>. -- | |
4c2d6a70 AC |
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.Wide_Wide_Maps; use Ada.Strings.Wide_Wide_Maps; | |
33 | with Ada.Strings.Wide_Wide_Search; | |
34 | ||
35 | package body Ada.Strings.Wide_Wide_Fixed is | |
36 | ||
37 | ------------------------ | |
38 | -- Search Subprograms -- | |
39 | ------------------------ | |
40 | ||
41 | function Index | |
42 | (Source : Wide_Wide_String; | |
43 | Pattern : Wide_Wide_String; | |
44 | Going : Direction := Forward; | |
45 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping := | |
15f0f591 | 46 | Wide_Wide_Maps.Identity) |
4c2d6a70 AC |
47 | return Natural |
48 | renames Ada.Strings.Wide_Wide_Search.Index; | |
49 | ||
50 | function Index | |
51 | (Source : Wide_Wide_String; | |
52 | Pattern : Wide_Wide_String; | |
53 | Going : Direction := Forward; | |
54 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function) | |
55 | return Natural | |
56 | renames Ada.Strings.Wide_Wide_Search.Index; | |
57 | ||
58 | function Index | |
59 | (Source : Wide_Wide_String; | |
60 | Set : Wide_Wide_Maps.Wide_Wide_Character_Set; | |
61 | Test : Membership := Inside; | |
62 | Going : Direction := Forward) return Natural | |
63 | renames Ada.Strings.Wide_Wide_Search.Index; | |
64 | ||
65 | function Index | |
66 | (Source : Wide_Wide_String; | |
67 | Pattern : Wide_Wide_String; | |
68 | From : Positive; | |
69 | Going : Direction := Forward; | |
70 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping := | |
15f0f591 | 71 | Wide_Wide_Maps.Identity) |
4c2d6a70 AC |
72 | return Natural |
73 | renames Ada.Strings.Wide_Wide_Search.Index; | |
74 | ||
75 | function Index | |
76 | (Source : Wide_Wide_String; | |
77 | Pattern : Wide_Wide_String; | |
78 | From : Positive; | |
79 | Going : Direction := Forward; | |
80 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function) | |
81 | return Natural | |
82 | renames Ada.Strings.Wide_Wide_Search.Index; | |
83 | ||
84 | function Index | |
85 | (Source : Wide_Wide_String; | |
86 | Set : Wide_Wide_Maps.Wide_Wide_Character_Set; | |
87 | From : Positive; | |
88 | Test : Membership := Inside; | |
89 | Going : Direction := Forward) return Natural | |
90 | renames Ada.Strings.Wide_Wide_Search.Index; | |
91 | ||
92 | function Index_Non_Blank | |
93 | (Source : Wide_Wide_String; | |
94 | Going : Direction := Forward) return Natural | |
95 | renames Ada.Strings.Wide_Wide_Search.Index_Non_Blank; | |
96 | ||
97 | function Index_Non_Blank | |
98 | (Source : Wide_Wide_String; | |
99 | From : Positive; | |
100 | Going : Direction := Forward) return Natural | |
101 | renames Ada.Strings.Wide_Wide_Search.Index_Non_Blank; | |
102 | ||
103 | function Count | |
104 | (Source : Wide_Wide_String; | |
105 | Pattern : Wide_Wide_String; | |
106 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping := | |
15f0f591 | 107 | Wide_Wide_Maps.Identity) |
4c2d6a70 AC |
108 | return Natural |
109 | renames Ada.Strings.Wide_Wide_Search.Count; | |
110 | ||
111 | function Count | |
112 | (Source : Wide_Wide_String; | |
113 | Pattern : Wide_Wide_String; | |
114 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function) | |
115 | return Natural | |
116 | renames Ada.Strings.Wide_Wide_Search.Count; | |
117 | ||
118 | function Count | |
119 | (Source : Wide_Wide_String; | |
120 | Set : Wide_Wide_Maps.Wide_Wide_Character_Set) return Natural | |
121 | renames Ada.Strings.Wide_Wide_Search.Count; | |
122 | ||
af31bffb AC |
123 | procedure Find_Token |
124 | (Source : Wide_Wide_String; | |
125 | Set : Wide_Wide_Maps.Wide_Wide_Character_Set; | |
126 | From : Positive; | |
127 | Test : Membership; | |
128 | First : out Positive; | |
129 | Last : out Natural) | |
130 | renames Ada.Strings.Wide_Wide_Search.Find_Token; | |
131 | ||
4c2d6a70 AC |
132 | procedure Find_Token |
133 | (Source : Wide_Wide_String; | |
134 | Set : Wide_Wide_Maps.Wide_Wide_Character_Set; | |
135 | Test : Membership; | |
136 | First : out Positive; | |
137 | Last : out Natural) | |
138 | renames Ada.Strings.Wide_Wide_Search.Find_Token; | |
139 | ||
140 | --------- | |
141 | -- "*" -- | |
142 | --------- | |
143 | ||
144 | function "*" | |
145 | (Left : Natural; | |
146 | Right : Wide_Wide_Character) return Wide_Wide_String | |
147 | is | |
148 | Result : Wide_Wide_String (1 .. Left); | |
149 | ||
150 | begin | |
151 | for J in Result'Range loop | |
152 | Result (J) := Right; | |
153 | end loop; | |
154 | ||
155 | return Result; | |
156 | end "*"; | |
157 | ||
158 | function "*" | |
159 | (Left : Natural; | |
160 | Right : Wide_Wide_String) return Wide_Wide_String | |
161 | is | |
162 | Result : Wide_Wide_String (1 .. Left * Right'Length); | |
163 | Ptr : Integer := 1; | |
164 | ||
165 | begin | |
166 | for J in 1 .. Left loop | |
167 | Result (Ptr .. Ptr + Right'Length - 1) := Right; | |
168 | Ptr := Ptr + Right'Length; | |
169 | end loop; | |
170 | ||
171 | return Result; | |
172 | end "*"; | |
173 | ||
174 | ------------ | |
175 | -- Delete -- | |
176 | ------------ | |
177 | ||
178 | function Delete | |
179 | (Source : Wide_Wide_String; | |
180 | From : Positive; | |
181 | Through : Natural) return Wide_Wide_String | |
182 | is | |
183 | begin | |
184 | if From not in Source'Range | |
185 | or else Through > Source'Last | |
186 | then | |
187 | raise Index_Error; | |
188 | ||
189 | elsif From > Through then | |
190 | return Source; | |
191 | ||
192 | else | |
193 | declare | |
194 | Len : constant Integer := Source'Length - (Through - From + 1); | |
195 | Result : constant Wide_Wide_String | |
196 | (Source'First .. Source'First + Len - 1) := | |
197 | Source (Source'First .. From - 1) & | |
198 | Source (Through + 1 .. Source'Last); | |
199 | begin | |
200 | return Result; | |
201 | end; | |
202 | end if; | |
203 | end Delete; | |
204 | ||
205 | procedure Delete | |
206 | (Source : in out Wide_Wide_String; | |
207 | From : Positive; | |
208 | Through : Natural; | |
209 | Justify : Alignment := Left; | |
210 | Pad : Wide_Wide_Character := Wide_Wide_Space) | |
211 | is | |
212 | begin | |
213 | Move (Source => Delete (Source, From, Through), | |
214 | Target => Source, | |
215 | Justify => Justify, | |
216 | Pad => Pad); | |
217 | end Delete; | |
218 | ||
219 | ---------- | |
220 | -- Head -- | |
221 | ---------- | |
222 | ||
223 | function Head | |
224 | (Source : Wide_Wide_String; | |
225 | Count : Natural; | |
226 | Pad : Wide_Wide_Character := Wide_Wide_Space) return Wide_Wide_String | |
227 | is | |
228 | Result : Wide_Wide_String (1 .. Count); | |
229 | ||
230 | begin | |
231 | if Count <= Source'Length then | |
232 | Result := Source (Source'First .. Source'First + Count - 1); | |
233 | ||
234 | else | |
235 | Result (1 .. Source'Length) := Source; | |
236 | ||
237 | for J in Source'Length + 1 .. Count loop | |
238 | Result (J) := Pad; | |
239 | end loop; | |
240 | end if; | |
241 | ||
242 | return Result; | |
243 | end Head; | |
244 | ||
245 | procedure Head | |
246 | (Source : in out Wide_Wide_String; | |
247 | Count : Natural; | |
248 | Justify : Alignment := Left; | |
249 | Pad : Wide_Wide_Character := Ada.Strings.Wide_Wide_Space) | |
250 | is | |
251 | begin | |
252 | Move (Source => Head (Source, Count, Pad), | |
253 | Target => Source, | |
254 | Drop => Error, | |
255 | Justify => Justify, | |
256 | Pad => Pad); | |
257 | end Head; | |
258 | ||
259 | ------------ | |
260 | -- Insert -- | |
261 | ------------ | |
262 | ||
263 | function Insert | |
264 | (Source : Wide_Wide_String; | |
265 | Before : Positive; | |
266 | New_Item : Wide_Wide_String) return Wide_Wide_String | |
267 | is | |
268 | Result : Wide_Wide_String (1 .. Source'Length + New_Item'Length); | |
269 | ||
270 | begin | |
271 | if Before < Source'First or else Before > Source'Last + 1 then | |
272 | raise Index_Error; | |
273 | end if; | |
274 | ||
275 | Result := Source (Source'First .. Before - 1) & New_Item & | |
276 | Source (Before .. Source'Last); | |
277 | return Result; | |
278 | end Insert; | |
279 | ||
280 | procedure Insert | |
281 | (Source : in out Wide_Wide_String; | |
282 | Before : Positive; | |
283 | New_Item : Wide_Wide_String; | |
284 | Drop : Truncation := Error) | |
285 | is | |
286 | begin | |
287 | Move (Source => Insert (Source, Before, New_Item), | |
288 | Target => Source, | |
289 | Drop => Drop); | |
290 | end Insert; | |
291 | ||
292 | ---------- | |
293 | -- Move -- | |
294 | ---------- | |
295 | ||
296 | procedure Move | |
297 | (Source : Wide_Wide_String; | |
298 | Target : out Wide_Wide_String; | |
299 | Drop : Truncation := Error; | |
300 | Justify : Alignment := Left; | |
301 | Pad : Wide_Wide_Character := Wide_Wide_Space) | |
302 | is | |
303 | Sfirst : constant Integer := Source'First; | |
304 | Slast : constant Integer := Source'Last; | |
305 | Slength : constant Integer := Source'Length; | |
306 | ||
307 | Tfirst : constant Integer := Target'First; | |
308 | Tlast : constant Integer := Target'Last; | |
309 | Tlength : constant Integer := Target'Length; | |
310 | ||
311 | function Is_Padding (Item : Wide_Wide_String) return Boolean; | |
312 | -- Determinbe if all characters in Item are pad characters | |
313 | ||
314 | function Is_Padding (Item : Wide_Wide_String) return Boolean is | |
315 | begin | |
316 | for J in Item'Range loop | |
317 | if Item (J) /= Pad then | |
318 | return False; | |
319 | end if; | |
320 | end loop; | |
321 | ||
322 | return True; | |
323 | end Is_Padding; | |
324 | ||
325 | -- Start of processing for Move | |
326 | ||
327 | begin | |
328 | if Slength = Tlength then | |
329 | Target := Source; | |
330 | ||
331 | elsif Slength > Tlength then | |
4c2d6a70 AC |
332 | case Drop is |
333 | when Left => | |
334 | Target := Source (Slast - Tlength + 1 .. Slast); | |
335 | ||
336 | when Right => | |
337 | Target := Source (Sfirst .. Sfirst + Tlength - 1); | |
338 | ||
339 | when Error => | |
340 | case Justify is | |
341 | when Left => | |
342 | if Is_Padding (Source (Sfirst + Tlength .. Slast)) then | |
343 | Target := | |
344 | Source (Sfirst .. Sfirst + Target'Length - 1); | |
345 | else | |
346 | raise Length_Error; | |
347 | end if; | |
348 | ||
349 | when Right => | |
350 | if Is_Padding (Source (Sfirst .. Slast - Tlength)) then | |
351 | Target := Source (Slast - Tlength + 1 .. Slast); | |
352 | else | |
353 | raise Length_Error; | |
354 | end if; | |
355 | ||
356 | when Center => | |
357 | raise Length_Error; | |
358 | end case; | |
359 | ||
360 | end case; | |
361 | ||
362 | -- Source'Length < Target'Length | |
363 | ||
364 | else | |
365 | case Justify is | |
366 | when Left => | |
367 | Target (Tfirst .. Tfirst + Slength - 1) := Source; | |
368 | ||
369 | for J in Tfirst + Slength .. Tlast loop | |
370 | Target (J) := Pad; | |
371 | end loop; | |
372 | ||
373 | when Right => | |
374 | for J in Tfirst .. Tlast - Slength loop | |
375 | Target (J) := Pad; | |
376 | end loop; | |
377 | ||
378 | Target (Tlast - Slength + 1 .. Tlast) := Source; | |
379 | ||
380 | when Center => | |
381 | declare | |
382 | Front_Pad : constant Integer := (Tlength - Slength) / 2; | |
383 | Tfirst_Fpad : constant Integer := Tfirst + Front_Pad; | |
384 | ||
385 | begin | |
386 | for J in Tfirst .. Tfirst_Fpad - 1 loop | |
387 | Target (J) := Pad; | |
388 | end loop; | |
389 | ||
390 | Target (Tfirst_Fpad .. Tfirst_Fpad + Slength - 1) := Source; | |
391 | ||
392 | for J in Tfirst_Fpad + Slength .. Tlast loop | |
393 | Target (J) := Pad; | |
394 | end loop; | |
395 | end; | |
396 | end case; | |
397 | end if; | |
398 | end Move; | |
399 | ||
400 | --------------- | |
401 | -- Overwrite -- | |
402 | --------------- | |
403 | ||
404 | function Overwrite | |
405 | (Source : Wide_Wide_String; | |
406 | Position : Positive; | |
407 | New_Item : Wide_Wide_String) return Wide_Wide_String | |
408 | is | |
409 | begin | |
410 | if Position not in Source'First .. Source'Last + 1 then | |
411 | raise Index_Error; | |
412 | else | |
413 | declare | |
414 | Result_Length : constant Natural := | |
15f0f591 AC |
415 | Natural'Max |
416 | (Source'Length, | |
417 | Position - Source'First + New_Item'Length); | |
4c2d6a70 AC |
418 | |
419 | Result : Wide_Wide_String (1 .. Result_Length); | |
420 | ||
421 | begin | |
422 | Result := Source (Source'First .. Position - 1) & New_Item & | |
423 | Source (Position + New_Item'Length .. Source'Last); | |
424 | return Result; | |
425 | end; | |
426 | end if; | |
427 | end Overwrite; | |
428 | ||
429 | procedure Overwrite | |
430 | (Source : in out Wide_Wide_String; | |
431 | Position : Positive; | |
432 | New_Item : Wide_Wide_String; | |
433 | Drop : Truncation := Right) | |
434 | is | |
435 | begin | |
436 | Move (Source => Overwrite (Source, Position, New_Item), | |
437 | Target => Source, | |
438 | Drop => Drop); | |
439 | end Overwrite; | |
440 | ||
441 | ------------------- | |
442 | -- Replace_Slice -- | |
443 | ------------------- | |
444 | ||
445 | function Replace_Slice | |
446 | (Source : Wide_Wide_String; | |
447 | Low : Positive; | |
448 | High : Natural; | |
449 | By : Wide_Wide_String) return Wide_Wide_String | |
450 | is | |
4c2d6a70 AC |
451 | begin |
452 | if Low > Source'Last + 1 or else High < Source'First - 1 then | |
453 | raise Index_Error; | |
a3a16b21 | 454 | end if; |
4c2d6a70 | 455 | |
a3a16b21 | 456 | if High >= Low then |
4c2d6a70 | 457 | declare |
a3a16b21 | 458 | Front_Len : constant Integer := |
15f0f591 | 459 | Integer'Max (0, Low - Source'First); |
a3a16b21 VC |
460 | -- Length of prefix of Source copied to result |
461 | ||
47e11d08 | 462 | Back_Len : constant Integer := |
15f0f591 | 463 | Integer'Max (0, Source'Last - High); |
a3a16b21 VC |
464 | -- Length of suffix of Source copied to result |
465 | ||
466 | Result_Length : constant Integer := | |
15f0f591 | 467 | Front_Len + By'Length + Back_Len; |
a3a16b21 VC |
468 | -- Length of result |
469 | ||
4c2d6a70 AC |
470 | Result : Wide_Wide_String (1 .. Result_Length); |
471 | ||
472 | begin | |
47e11d08 AC |
473 | Result (1 .. Front_Len) := Source (Source'First .. Low - 1); |
474 | Result (Front_Len + 1 .. Front_Len + By'Length) := By; | |
a3a16b21 VC |
475 | Result (Front_Len + By'Length + 1 .. Result'Length) := |
476 | Source (High + 1 .. Source'Last); | |
4c2d6a70 AC |
477 | return Result; |
478 | end; | |
a3a16b21 VC |
479 | |
480 | else | |
481 | return Insert (Source, Before => Low, New_Item => By); | |
4c2d6a70 AC |
482 | end if; |
483 | end Replace_Slice; | |
484 | ||
485 | procedure Replace_Slice | |
486 | (Source : in out Wide_Wide_String; | |
487 | Low : Positive; | |
488 | High : Natural; | |
489 | By : Wide_Wide_String; | |
490 | Drop : Truncation := Error; | |
491 | Justify : Alignment := Left; | |
492 | Pad : Wide_Wide_Character := Wide_Wide_Space) | |
493 | is | |
494 | begin | |
495 | Move (Replace_Slice (Source, Low, High, By), Source, Drop, Justify, Pad); | |
496 | end Replace_Slice; | |
497 | ||
498 | ---------- | |
499 | -- Tail -- | |
500 | ---------- | |
501 | ||
502 | function Tail | |
503 | (Source : Wide_Wide_String; | |
504 | Count : Natural; | |
505 | Pad : Wide_Wide_Character := Wide_Wide_Space) return Wide_Wide_String | |
506 | is | |
507 | Result : Wide_Wide_String (1 .. Count); | |
508 | ||
509 | begin | |
510 | if Count < Source'Length then | |
511 | Result := Source (Source'Last - Count + 1 .. Source'Last); | |
512 | ||
513 | -- Pad on left | |
514 | ||
515 | else | |
516 | for J in 1 .. Count - Source'Length loop | |
517 | Result (J) := Pad; | |
518 | end loop; | |
519 | ||
520 | Result (Count - Source'Length + 1 .. Count) := Source; | |
521 | end if; | |
522 | ||
523 | return Result; | |
524 | end Tail; | |
525 | ||
526 | procedure Tail | |
527 | (Source : in out Wide_Wide_String; | |
528 | Count : Natural; | |
529 | Justify : Alignment := Left; | |
530 | Pad : Wide_Wide_Character := Ada.Strings.Wide_Wide_Space) | |
531 | is | |
532 | begin | |
533 | Move (Source => Tail (Source, Count, Pad), | |
534 | Target => Source, | |
535 | Drop => Error, | |
536 | Justify => Justify, | |
537 | Pad => Pad); | |
538 | end Tail; | |
539 | ||
540 | --------------- | |
541 | -- Translate -- | |
542 | --------------- | |
543 | ||
544 | function Translate | |
545 | (Source : Wide_Wide_String; | |
546 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping) | |
547 | return Wide_Wide_String | |
548 | is | |
549 | Result : Wide_Wide_String (1 .. Source'Length); | |
550 | ||
551 | begin | |
552 | for J in Source'Range loop | |
553 | Result (J - (Source'First - 1)) := Value (Mapping, Source (J)); | |
554 | end loop; | |
555 | ||
556 | return Result; | |
557 | end Translate; | |
558 | ||
559 | procedure Translate | |
560 | (Source : in out Wide_Wide_String; | |
561 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping) | |
562 | is | |
563 | begin | |
564 | for J in Source'Range loop | |
565 | Source (J) := Value (Mapping, Source (J)); | |
566 | end loop; | |
567 | end Translate; | |
568 | ||
569 | function Translate | |
570 | (Source : Wide_Wide_String; | |
571 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function) | |
572 | return Wide_Wide_String | |
573 | is | |
574 | Result : Wide_Wide_String (1 .. Source'Length); | |
575 | ||
576 | begin | |
577 | for J in Source'Range loop | |
578 | Result (J - (Source'First - 1)) := Mapping (Source (J)); | |
579 | end loop; | |
580 | ||
581 | return Result; | |
582 | end Translate; | |
583 | ||
584 | procedure Translate | |
585 | (Source : in out Wide_Wide_String; | |
586 | Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function) | |
587 | is | |
588 | begin | |
589 | for J in Source'Range loop | |
590 | Source (J) := Mapping (Source (J)); | |
591 | end loop; | |
592 | end Translate; | |
593 | ||
594 | ---------- | |
595 | -- Trim -- | |
596 | ---------- | |
597 | ||
598 | function Trim | |
599 | (Source : Wide_Wide_String; | |
600 | Side : Trim_End) return Wide_Wide_String | |
601 | is | |
602 | Low : Natural := Source'First; | |
603 | High : Natural := Source'Last; | |
604 | ||
605 | begin | |
606 | if Side = Left or else Side = Both then | |
607 | while Low <= High and then Source (Low) = Wide_Wide_Space loop | |
608 | Low := Low + 1; | |
609 | end loop; | |
610 | end if; | |
611 | ||
612 | if Side = Right or else Side = Both then | |
613 | while High >= Low and then Source (High) = Wide_Wide_Space loop | |
614 | High := High - 1; | |
615 | end loop; | |
616 | end if; | |
617 | ||
618 | -- All blanks case | |
619 | ||
620 | if Low > High then | |
621 | return ""; | |
622 | ||
623 | -- At least one non-blank | |
624 | ||
625 | else | |
626 | declare | |
627 | Result : constant Wide_Wide_String (1 .. High - Low + 1) := | |
15f0f591 | 628 | Source (Low .. High); |
4c2d6a70 AC |
629 | |
630 | begin | |
631 | return Result; | |
632 | end; | |
633 | end if; | |
634 | end Trim; | |
635 | ||
636 | procedure Trim | |
637 | (Source : in out Wide_Wide_String; | |
638 | Side : Trim_End; | |
639 | Justify : Alignment := Left; | |
640 | Pad : Wide_Wide_Character := Wide_Wide_Space) | |
641 | is | |
642 | begin | |
643 | Move (Source => Trim (Source, Side), | |
644 | Target => Source, | |
645 | Justify => Justify, | |
646 | Pad => Pad); | |
647 | end Trim; | |
648 | ||
649 | function Trim | |
650 | (Source : Wide_Wide_String; | |
651 | Left : Wide_Wide_Maps.Wide_Wide_Character_Set; | |
652 | Right : Wide_Wide_Maps.Wide_Wide_Character_Set) return Wide_Wide_String | |
653 | is | |
654 | Low : Natural := Source'First; | |
655 | High : Natural := Source'Last; | |
656 | ||
657 | begin | |
658 | while Low <= High and then Is_In (Source (Low), Left) loop | |
659 | Low := Low + 1; | |
660 | end loop; | |
661 | ||
662 | while High >= Low and then Is_In (Source (High), Right) loop | |
663 | High := High - 1; | |
664 | end loop; | |
665 | ||
666 | -- Case where source comprises only characters in the sets | |
667 | ||
668 | if Low > High then | |
669 | return ""; | |
670 | else | |
671 | declare | |
672 | subtype WS is Wide_Wide_String (1 .. High - Low + 1); | |
673 | ||
674 | begin | |
675 | return WS (Source (Low .. High)); | |
676 | end; | |
677 | end if; | |
678 | end Trim; | |
679 | ||
680 | procedure Trim | |
681 | (Source : in out Wide_Wide_String; | |
682 | Left : Wide_Wide_Maps.Wide_Wide_Character_Set; | |
683 | Right : Wide_Wide_Maps.Wide_Wide_Character_Set; | |
684 | Justify : Alignment := Strings.Left; | |
685 | Pad : Wide_Wide_Character := Wide_Wide_Space) | |
686 | is | |
687 | begin | |
688 | Move (Source => Trim (Source, Left, Right), | |
689 | Target => Source, | |
690 | Justify => Justify, | |
691 | Pad => Pad); | |
692 | end Trim; | |
693 | ||
694 | end Ada.Strings.Wide_Wide_Fixed; |