|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT RUN-TIME COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- A D A . S T R I N G S . U N B O U N D E D --
|
|
|
6 -- --
|
|
|
7 -- B o d y --
|
|
|
8 -- --
|
|
131
|
9 -- Copyright (C) 1992-2018, Free Software Foundation, Inc. --
|
|
111
|
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.Fixed;
|
|
|
33 with Ada.Strings.Search;
|
|
|
34 with Ada.Unchecked_Deallocation;
|
|
|
35
|
|
|
36 package body Ada.Strings.Unbounded is
|
|
|
37
|
|
|
38 ---------
|
|
|
39 -- "&" --
|
|
|
40 ---------
|
|
|
41
|
|
|
42 function "&"
|
|
|
43 (Left : Unbounded_String;
|
|
|
44 Right : Unbounded_String) return Unbounded_String
|
|
|
45 is
|
|
|
46 L_Length : constant Natural := Left.Last;
|
|
|
47 R_Length : constant Natural := Right.Last;
|
|
|
48 Result : Unbounded_String;
|
|
|
49
|
|
|
50 begin
|
|
|
51 Result.Last := L_Length + R_Length;
|
|
|
52
|
|
|
53 Result.Reference := new String (1 .. Result.Last);
|
|
|
54
|
|
|
55 Result.Reference (1 .. L_Length) :=
|
|
|
56 Left.Reference (1 .. Left.Last);
|
|
|
57 Result.Reference (L_Length + 1 .. Result.Last) :=
|
|
|
58 Right.Reference (1 .. Right.Last);
|
|
|
59
|
|
|
60 return Result;
|
|
|
61 end "&";
|
|
|
62
|
|
|
63 function "&"
|
|
|
64 (Left : Unbounded_String;
|
|
|
65 Right : String) return Unbounded_String
|
|
|
66 is
|
|
|
67 L_Length : constant Natural := Left.Last;
|
|
|
68 Result : Unbounded_String;
|
|
|
69
|
|
|
70 begin
|
|
|
71 Result.Last := L_Length + Right'Length;
|
|
|
72
|
|
|
73 Result.Reference := new String (1 .. Result.Last);
|
|
|
74
|
|
|
75 Result.Reference (1 .. L_Length) := Left.Reference (1 .. Left.Last);
|
|
|
76 Result.Reference (L_Length + 1 .. Result.Last) := Right;
|
|
|
77
|
|
|
78 return Result;
|
|
|
79 end "&";
|
|
|
80
|
|
|
81 function "&"
|
|
|
82 (Left : String;
|
|
|
83 Right : Unbounded_String) return Unbounded_String
|
|
|
84 is
|
|
|
85 R_Length : constant Natural := Right.Last;
|
|
|
86 Result : Unbounded_String;
|
|
|
87
|
|
|
88 begin
|
|
|
89 Result.Last := Left'Length + R_Length;
|
|
|
90
|
|
|
91 Result.Reference := new String (1 .. Result.Last);
|
|
|
92
|
|
|
93 Result.Reference (1 .. Left'Length) := Left;
|
|
|
94 Result.Reference (Left'Length + 1 .. Result.Last) :=
|
|
|
95 Right.Reference (1 .. Right.Last);
|
|
|
96
|
|
|
97 return Result;
|
|
|
98 end "&";
|
|
|
99
|
|
|
100 function "&"
|
|
|
101 (Left : Unbounded_String;
|
|
|
102 Right : Character) return Unbounded_String
|
|
|
103 is
|
|
|
104 Result : Unbounded_String;
|
|
|
105
|
|
|
106 begin
|
|
|
107 Result.Last := Left.Last + 1;
|
|
|
108
|
|
|
109 Result.Reference := new String (1 .. Result.Last);
|
|
|
110
|
|
|
111 Result.Reference (1 .. Result.Last - 1) :=
|
|
|
112 Left.Reference (1 .. Left.Last);
|
|
|
113 Result.Reference (Result.Last) := Right;
|
|
|
114
|
|
|
115 return Result;
|
|
|
116 end "&";
|
|
|
117
|
|
|
118 function "&"
|
|
|
119 (Left : Character;
|
|
|
120 Right : Unbounded_String) return Unbounded_String
|
|
|
121 is
|
|
|
122 Result : Unbounded_String;
|
|
|
123
|
|
|
124 begin
|
|
|
125 Result.Last := Right.Last + 1;
|
|
|
126
|
|
|
127 Result.Reference := new String (1 .. Result.Last);
|
|
|
128 Result.Reference (1) := Left;
|
|
|
129 Result.Reference (2 .. Result.Last) :=
|
|
|
130 Right.Reference (1 .. Right.Last);
|
|
|
131 return Result;
|
|
|
132 end "&";
|
|
|
133
|
|
|
134 ---------
|
|
|
135 -- "*" --
|
|
|
136 ---------
|
|
|
137
|
|
|
138 function "*"
|
|
|
139 (Left : Natural;
|
|
|
140 Right : Character) return Unbounded_String
|
|
|
141 is
|
|
|
142 Result : Unbounded_String;
|
|
|
143
|
|
|
144 begin
|
|
|
145 Result.Last := Left;
|
|
|
146
|
|
|
147 Result.Reference := new String (1 .. Left);
|
|
|
148 for J in Result.Reference'Range loop
|
|
|
149 Result.Reference (J) := Right;
|
|
|
150 end loop;
|
|
|
151
|
|
|
152 return Result;
|
|
|
153 end "*";
|
|
|
154
|
|
|
155 function "*"
|
|
|
156 (Left : Natural;
|
|
|
157 Right : String) return Unbounded_String
|
|
|
158 is
|
|
|
159 Len : constant Natural := Right'Length;
|
|
|
160 K : Positive;
|
|
|
161 Result : Unbounded_String;
|
|
|
162
|
|
|
163 begin
|
|
|
164 Result.Last := Left * Len;
|
|
|
165
|
|
|
166 Result.Reference := new String (1 .. Result.Last);
|
|
|
167
|
|
|
168 K := 1;
|
|
|
169 for J in 1 .. Left loop
|
|
|
170 Result.Reference (K .. K + Len - 1) := Right;
|
|
|
171 K := K + Len;
|
|
|
172 end loop;
|
|
|
173
|
|
|
174 return Result;
|
|
|
175 end "*";
|
|
|
176
|
|
|
177 function "*"
|
|
|
178 (Left : Natural;
|
|
|
179 Right : Unbounded_String) return Unbounded_String
|
|
|
180 is
|
|
|
181 Len : constant Natural := Right.Last;
|
|
|
182 K : Positive;
|
|
|
183 Result : Unbounded_String;
|
|
|
184
|
|
|
185 begin
|
|
|
186 Result.Last := Left * Len;
|
|
|
187
|
|
|
188 Result.Reference := new String (1 .. Result.Last);
|
|
|
189
|
|
|
190 K := 1;
|
|
|
191 for J in 1 .. Left loop
|
|
|
192 Result.Reference (K .. K + Len - 1) :=
|
|
|
193 Right.Reference (1 .. Right.Last);
|
|
|
194 K := K + Len;
|
|
|
195 end loop;
|
|
|
196
|
|
|
197 return Result;
|
|
|
198 end "*";
|
|
|
199
|
|
|
200 ---------
|
|
|
201 -- "<" --
|
|
|
202 ---------
|
|
|
203
|
|
|
204 function "<"
|
|
|
205 (Left : Unbounded_String;
|
|
|
206 Right : Unbounded_String) return Boolean
|
|
|
207 is
|
|
|
208 begin
|
|
|
209 return
|
|
|
210 Left.Reference (1 .. Left.Last) < Right.Reference (1 .. Right.Last);
|
|
|
211 end "<";
|
|
|
212
|
|
|
213 function "<"
|
|
|
214 (Left : Unbounded_String;
|
|
|
215 Right : String) return Boolean
|
|
|
216 is
|
|
|
217 begin
|
|
|
218 return Left.Reference (1 .. Left.Last) < Right;
|
|
|
219 end "<";
|
|
|
220
|
|
|
221 function "<"
|
|
|
222 (Left : String;
|
|
|
223 Right : Unbounded_String) return Boolean
|
|
|
224 is
|
|
|
225 begin
|
|
|
226 return Left < Right.Reference (1 .. Right.Last);
|
|
|
227 end "<";
|
|
|
228
|
|
|
229 ----------
|
|
|
230 -- "<=" --
|
|
|
231 ----------
|
|
|
232
|
|
|
233 function "<="
|
|
|
234 (Left : Unbounded_String;
|
|
|
235 Right : Unbounded_String) return Boolean
|
|
|
236 is
|
|
|
237 begin
|
|
|
238 return
|
|
|
239 Left.Reference (1 .. Left.Last) <= Right.Reference (1 .. Right.Last);
|
|
|
240 end "<=";
|
|
|
241
|
|
|
242 function "<="
|
|
|
243 (Left : Unbounded_String;
|
|
|
244 Right : String) return Boolean
|
|
|
245 is
|
|
|
246 begin
|
|
|
247 return Left.Reference (1 .. Left.Last) <= Right;
|
|
|
248 end "<=";
|
|
|
249
|
|
|
250 function "<="
|
|
|
251 (Left : String;
|
|
|
252 Right : Unbounded_String) return Boolean
|
|
|
253 is
|
|
|
254 begin
|
|
|
255 return Left <= Right.Reference (1 .. Right.Last);
|
|
|
256 end "<=";
|
|
|
257
|
|
|
258 ---------
|
|
|
259 -- "=" --
|
|
|
260 ---------
|
|
|
261
|
|
|
262 function "="
|
|
|
263 (Left : Unbounded_String;
|
|
|
264 Right : Unbounded_String) return Boolean
|
|
|
265 is
|
|
|
266 begin
|
|
|
267 return
|
|
|
268 Left.Reference (1 .. Left.Last) = Right.Reference (1 .. Right.Last);
|
|
|
269 end "=";
|
|
|
270
|
|
|
271 function "="
|
|
|
272 (Left : Unbounded_String;
|
|
|
273 Right : String) return Boolean
|
|
|
274 is
|
|
|
275 begin
|
|
|
276 return Left.Reference (1 .. Left.Last) = Right;
|
|
|
277 end "=";
|
|
|
278
|
|
|
279 function "="
|
|
|
280 (Left : String;
|
|
|
281 Right : Unbounded_String) return Boolean
|
|
|
282 is
|
|
|
283 begin
|
|
|
284 return Left = Right.Reference (1 .. Right.Last);
|
|
|
285 end "=";
|
|
|
286
|
|
|
287 ---------
|
|
|
288 -- ">" --
|
|
|
289 ---------
|
|
|
290
|
|
|
291 function ">"
|
|
|
292 (Left : Unbounded_String;
|
|
|
293 Right : Unbounded_String) return Boolean
|
|
|
294 is
|
|
|
295 begin
|
|
|
296 return
|
|
|
297 Left.Reference (1 .. Left.Last) > Right.Reference (1 .. Right.Last);
|
|
|
298 end ">";
|
|
|
299
|
|
|
300 function ">"
|
|
|
301 (Left : Unbounded_String;
|
|
|
302 Right : String) return Boolean
|
|
|
303 is
|
|
|
304 begin
|
|
|
305 return Left.Reference (1 .. Left.Last) > Right;
|
|
|
306 end ">";
|
|
|
307
|
|
|
308 function ">"
|
|
|
309 (Left : String;
|
|
|
310 Right : Unbounded_String) return Boolean
|
|
|
311 is
|
|
|
312 begin
|
|
|
313 return Left > Right.Reference (1 .. Right.Last);
|
|
|
314 end ">";
|
|
|
315
|
|
|
316 ----------
|
|
|
317 -- ">=" --
|
|
|
318 ----------
|
|
|
319
|
|
|
320 function ">="
|
|
|
321 (Left : Unbounded_String;
|
|
|
322 Right : Unbounded_String) return Boolean
|
|
|
323 is
|
|
|
324 begin
|
|
|
325 return
|
|
|
326 Left.Reference (1 .. Left.Last) >= Right.Reference (1 .. Right.Last);
|
|
|
327 end ">=";
|
|
|
328
|
|
|
329 function ">="
|
|
|
330 (Left : Unbounded_String;
|
|
|
331 Right : String) return Boolean
|
|
|
332 is
|
|
|
333 begin
|
|
|
334 return Left.Reference (1 .. Left.Last) >= Right;
|
|
|
335 end ">=";
|
|
|
336
|
|
|
337 function ">="
|
|
|
338 (Left : String;
|
|
|
339 Right : Unbounded_String) return Boolean
|
|
|
340 is
|
|
|
341 begin
|
|
|
342 return Left >= Right.Reference (1 .. Right.Last);
|
|
|
343 end ">=";
|
|
|
344
|
|
|
345 ------------
|
|
|
346 -- Adjust --
|
|
|
347 ------------
|
|
|
348
|
|
|
349 procedure Adjust (Object : in out Unbounded_String) is
|
|
|
350 begin
|
|
|
351 -- Copy string, except we do not copy the statically allocated null
|
|
|
352 -- string since it can never be deallocated. Note that we do not copy
|
|
|
353 -- extra string room here to avoid dragging unused allocated memory.
|
|
|
354
|
|
|
355 if Object.Reference /= Null_String'Access then
|
|
|
356 Object.Reference := new String'(Object.Reference (1 .. Object.Last));
|
|
|
357 end if;
|
|
|
358 end Adjust;
|
|
|
359
|
|
|
360 ------------
|
|
|
361 -- Append --
|
|
|
362 ------------
|
|
|
363
|
|
|
364 procedure Append
|
|
|
365 (Source : in out Unbounded_String;
|
|
|
366 New_Item : Unbounded_String)
|
|
|
367 is
|
|
|
368 begin
|
|
|
369 Realloc_For_Chunk (Source, New_Item.Last);
|
|
|
370 Source.Reference (Source.Last + 1 .. Source.Last + New_Item.Last) :=
|
|
|
371 New_Item.Reference (1 .. New_Item.Last);
|
|
|
372 Source.Last := Source.Last + New_Item.Last;
|
|
|
373 end Append;
|
|
|
374
|
|
|
375 procedure Append
|
|
|
376 (Source : in out Unbounded_String;
|
|
|
377 New_Item : String)
|
|
|
378 is
|
|
|
379 begin
|
|
|
380 Realloc_For_Chunk (Source, New_Item'Length);
|
|
|
381 Source.Reference (Source.Last + 1 .. Source.Last + New_Item'Length) :=
|
|
|
382 New_Item;
|
|
|
383 Source.Last := Source.Last + New_Item'Length;
|
|
|
384 end Append;
|
|
|
385
|
|
|
386 procedure Append
|
|
|
387 (Source : in out Unbounded_String;
|
|
|
388 New_Item : Character)
|
|
|
389 is
|
|
|
390 begin
|
|
|
391 Realloc_For_Chunk (Source, 1);
|
|
|
392 Source.Reference (Source.Last + 1) := New_Item;
|
|
|
393 Source.Last := Source.Last + 1;
|
|
|
394 end Append;
|
|
|
395
|
|
|
396 -----------
|
|
|
397 -- Count --
|
|
|
398 -----------
|
|
|
399
|
|
|
400 function Count
|
|
|
401 (Source : Unbounded_String;
|
|
|
402 Pattern : String;
|
|
|
403 Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
|
|
|
404 is
|
|
|
405 begin
|
|
|
406 return
|
|
|
407 Search.Count (Source.Reference (1 .. Source.Last), Pattern, Mapping);
|
|
|
408 end Count;
|
|
|
409
|
|
|
410 function Count
|
|
|
411 (Source : Unbounded_String;
|
|
|
412 Pattern : String;
|
|
|
413 Mapping : Maps.Character_Mapping_Function) return Natural
|
|
|
414 is
|
|
|
415 begin
|
|
|
416 return
|
|
|
417 Search.Count (Source.Reference (1 .. Source.Last), Pattern, Mapping);
|
|
|
418 end Count;
|
|
|
419
|
|
|
420 function Count
|
|
|
421 (Source : Unbounded_String;
|
|
|
422 Set : Maps.Character_Set) return Natural
|
|
|
423 is
|
|
|
424 begin
|
|
|
425 return Search.Count (Source.Reference (1 .. Source.Last), Set);
|
|
|
426 end Count;
|
|
|
427
|
|
|
428 ------------
|
|
|
429 -- Delete --
|
|
|
430 ------------
|
|
|
431
|
|
|
432 function Delete
|
|
|
433 (Source : Unbounded_String;
|
|
|
434 From : Positive;
|
|
|
435 Through : Natural) return Unbounded_String
|
|
|
436 is
|
|
|
437 begin
|
|
|
438 return
|
|
|
439 To_Unbounded_String
|
|
|
440 (Fixed.Delete (Source.Reference (1 .. Source.Last), From, Through));
|
|
|
441 end Delete;
|
|
|
442
|
|
|
443 procedure Delete
|
|
|
444 (Source : in out Unbounded_String;
|
|
|
445 From : Positive;
|
|
|
446 Through : Natural)
|
|
|
447 is
|
|
|
448 begin
|
|
|
449 if From > Through then
|
|
|
450 null;
|
|
|
451
|
|
|
452 elsif From < Source.Reference'First or else Through > Source.Last then
|
|
|
453 raise Index_Error;
|
|
|
454
|
|
|
455 else
|
|
|
456 declare
|
|
|
457 Len : constant Natural := Through - From + 1;
|
|
|
458
|
|
|
459 begin
|
|
|
460 Source.Reference (From .. Source.Last - Len) :=
|
|
|
461 Source.Reference (Through + 1 .. Source.Last);
|
|
|
462 Source.Last := Source.Last - Len;
|
|
|
463 end;
|
|
|
464 end if;
|
|
|
465 end Delete;
|
|
|
466
|
|
|
467 -------------
|
|
|
468 -- Element --
|
|
|
469 -------------
|
|
|
470
|
|
|
471 function Element
|
|
|
472 (Source : Unbounded_String;
|
|
|
473 Index : Positive) return Character
|
|
|
474 is
|
|
|
475 begin
|
|
|
476 if Index <= Source.Last then
|
|
|
477 return Source.Reference (Index);
|
|
|
478 else
|
|
|
479 raise Strings.Index_Error;
|
|
|
480 end if;
|
|
|
481 end Element;
|
|
|
482
|
|
|
483 --------------
|
|
|
484 -- Finalize --
|
|
|
485 --------------
|
|
|
486
|
|
|
487 procedure Finalize (Object : in out Unbounded_String) is
|
|
|
488 procedure Deallocate is
|
|
|
489 new Ada.Unchecked_Deallocation (String, String_Access);
|
|
|
490
|
|
|
491 begin
|
|
|
492 -- Note: Don't try to free statically allocated null string
|
|
|
493
|
|
|
494 if Object.Reference /= Null_String'Access then
|
|
|
495 Deallocate (Object.Reference);
|
|
|
496 Object.Reference := Null_Unbounded_String.Reference;
|
|
|
497 Object.Last := 0;
|
|
|
498 end if;
|
|
|
499 end Finalize;
|
|
|
500
|
|
|
501 ----------------
|
|
|
502 -- Find_Token --
|
|
|
503 ----------------
|
|
|
504
|
|
|
505 procedure Find_Token
|
|
|
506 (Source : Unbounded_String;
|
|
|
507 Set : Maps.Character_Set;
|
|
|
508 From : Positive;
|
|
|
509 Test : Strings.Membership;
|
|
|
510 First : out Positive;
|
|
|
511 Last : out Natural)
|
|
|
512 is
|
|
|
513 begin
|
|
|
514 Search.Find_Token
|
|
|
515 (Source.Reference (From .. Source.Last), Set, Test, First, Last);
|
|
|
516 end Find_Token;
|
|
|
517
|
|
|
518 procedure Find_Token
|
|
|
519 (Source : Unbounded_String;
|
|
|
520 Set : Maps.Character_Set;
|
|
|
521 Test : Strings.Membership;
|
|
|
522 First : out Positive;
|
|
|
523 Last : out Natural)
|
|
|
524 is
|
|
|
525 begin
|
|
|
526 Search.Find_Token
|
|
|
527 (Source.Reference (1 .. Source.Last), Set, Test, First, Last);
|
|
|
528 end Find_Token;
|
|
|
529
|
|
|
530 ----------
|
|
|
531 -- Free --
|
|
|
532 ----------
|
|
|
533
|
|
|
534 procedure Free (X : in out String_Access) is
|
|
|
535 procedure Deallocate is
|
|
|
536 new Ada.Unchecked_Deallocation (String, String_Access);
|
|
|
537
|
|
|
538 begin
|
|
|
539 -- Note: Do not try to free statically allocated null string
|
|
|
540
|
|
|
541 if X /= Null_Unbounded_String.Reference then
|
|
|
542 Deallocate (X);
|
|
|
543 end if;
|
|
|
544 end Free;
|
|
|
545
|
|
|
546 ----------
|
|
|
547 -- Head --
|
|
|
548 ----------
|
|
|
549
|
|
|
550 function Head
|
|
|
551 (Source : Unbounded_String;
|
|
|
552 Count : Natural;
|
|
|
553 Pad : Character := Space) return Unbounded_String
|
|
|
554 is
|
|
|
555 begin
|
|
|
556 return To_Unbounded_String
|
|
|
557 (Fixed.Head (Source.Reference (1 .. Source.Last), Count, Pad));
|
|
|
558 end Head;
|
|
|
559
|
|
|
560 procedure Head
|
|
|
561 (Source : in out Unbounded_String;
|
|
|
562 Count : Natural;
|
|
|
563 Pad : Character := Space)
|
|
|
564 is
|
|
|
565 Old : String_Access := Source.Reference;
|
|
|
566 begin
|
|
|
567 Source.Reference :=
|
|
|
568 new String'(Fixed.Head (Source.Reference (1 .. Source.Last),
|
|
|
569 Count, Pad));
|
|
|
570 Source.Last := Source.Reference'Length;
|
|
|
571 Free (Old);
|
|
|
572 end Head;
|
|
|
573
|
|
|
574 -----------
|
|
|
575 -- Index --
|
|
|
576 -----------
|
|
|
577
|
|
|
578 function Index
|
|
|
579 (Source : Unbounded_String;
|
|
|
580 Pattern : String;
|
|
|
581 Going : Strings.Direction := Strings.Forward;
|
|
|
582 Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
|
|
|
583 is
|
|
|
584 begin
|
|
|
585 return Search.Index
|
|
|
586 (Source.Reference (1 .. Source.Last), Pattern, Going, Mapping);
|
|
|
587 end Index;
|
|
|
588
|
|
|
589 function Index
|
|
|
590 (Source : Unbounded_String;
|
|
|
591 Pattern : String;
|
|
|
592 Going : Direction := Forward;
|
|
|
593 Mapping : Maps.Character_Mapping_Function) return Natural
|
|
|
594 is
|
|
|
595 begin
|
|
|
596 return Search.Index
|
|
|
597 (Source.Reference (1 .. Source.Last), Pattern, Going, Mapping);
|
|
|
598 end Index;
|
|
|
599
|
|
|
600 function Index
|
|
|
601 (Source : Unbounded_String;
|
|
|
602 Set : Maps.Character_Set;
|
|
|
603 Test : Strings.Membership := Strings.Inside;
|
|
|
604 Going : Strings.Direction := Strings.Forward) return Natural
|
|
|
605 is
|
|
|
606 begin
|
|
|
607 return Search.Index
|
|
|
608 (Source.Reference (1 .. Source.Last), Set, Test, Going);
|
|
|
609 end Index;
|
|
|
610
|
|
|
611 function Index
|
|
|
612 (Source : Unbounded_String;
|
|
|
613 Pattern : String;
|
|
|
614 From : Positive;
|
|
|
615 Going : Direction := Forward;
|
|
|
616 Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
|
|
|
617 is
|
|
|
618 begin
|
|
|
619 return Search.Index
|
|
|
620 (Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping);
|
|
|
621 end Index;
|
|
|
622
|
|
|
623 function Index
|
|
|
624 (Source : Unbounded_String;
|
|
|
625 Pattern : String;
|
|
|
626 From : Positive;
|
|
|
627 Going : Direction := Forward;
|
|
|
628 Mapping : Maps.Character_Mapping_Function) return Natural
|
|
|
629 is
|
|
|
630 begin
|
|
|
631 return Search.Index
|
|
|
632 (Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping);
|
|
|
633 end Index;
|
|
|
634
|
|
|
635 function Index
|
|
|
636 (Source : Unbounded_String;
|
|
|
637 Set : Maps.Character_Set;
|
|
|
638 From : Positive;
|
|
|
639 Test : Membership := Inside;
|
|
|
640 Going : Direction := Forward) return Natural
|
|
|
641 is
|
|
|
642 begin
|
|
|
643 return Search.Index
|
|
|
644 (Source.Reference (1 .. Source.Last), Set, From, Test, Going);
|
|
|
645 end Index;
|
|
|
646
|
|
|
647 function Index_Non_Blank
|
|
|
648 (Source : Unbounded_String;
|
|
|
649 Going : Strings.Direction := Strings.Forward) return Natural
|
|
|
650 is
|
|
|
651 begin
|
|
|
652 return
|
|
|
653 Search.Index_Non_Blank
|
|
|
654 (Source.Reference (1 .. Source.Last), Going);
|
|
|
655 end Index_Non_Blank;
|
|
|
656
|
|
|
657 function Index_Non_Blank
|
|
|
658 (Source : Unbounded_String;
|
|
|
659 From : Positive;
|
|
|
660 Going : Direction := Forward) return Natural
|
|
|
661 is
|
|
|
662 begin
|
|
|
663 return
|
|
|
664 Search.Index_Non_Blank
|
|
|
665 (Source.Reference (1 .. Source.Last), From, Going);
|
|
|
666 end Index_Non_Blank;
|
|
|
667
|
|
|
668 ----------------
|
|
|
669 -- Initialize --
|
|
|
670 ----------------
|
|
|
671
|
|
|
672 procedure Initialize (Object : in out Unbounded_String) is
|
|
|
673 begin
|
|
|
674 Object.Reference := Null_Unbounded_String.Reference;
|
|
|
675 Object.Last := 0;
|
|
|
676 end Initialize;
|
|
|
677
|
|
|
678 ------------
|
|
|
679 -- Insert --
|
|
|
680 ------------
|
|
|
681
|
|
|
682 function Insert
|
|
|
683 (Source : Unbounded_String;
|
|
|
684 Before : Positive;
|
|
|
685 New_Item : String) return Unbounded_String
|
|
|
686 is
|
|
|
687 begin
|
|
|
688 return To_Unbounded_String
|
|
|
689 (Fixed.Insert (Source.Reference (1 .. Source.Last), Before, New_Item));
|
|
|
690 end Insert;
|
|
|
691
|
|
|
692 procedure Insert
|
|
|
693 (Source : in out Unbounded_String;
|
|
|
694 Before : Positive;
|
|
|
695 New_Item : String)
|
|
|
696 is
|
|
|
697 begin
|
|
|
698 if Before not in Source.Reference'First .. Source.Last + 1 then
|
|
|
699 raise Index_Error;
|
|
|
700 end if;
|
|
|
701
|
|
|
702 Realloc_For_Chunk (Source, New_Item'Length);
|
|
|
703
|
|
|
704 Source.Reference
|
|
|
705 (Before + New_Item'Length .. Source.Last + New_Item'Length) :=
|
|
|
706 Source.Reference (Before .. Source.Last);
|
|
|
707
|
|
|
708 Source.Reference (Before .. Before + New_Item'Length - 1) := New_Item;
|
|
|
709 Source.Last := Source.Last + New_Item'Length;
|
|
|
710 end Insert;
|
|
|
711
|
|
|
712 ------------
|
|
|
713 -- Length --
|
|
|
714 ------------
|
|
|
715
|
|
|
716 function Length (Source : Unbounded_String) return Natural is
|
|
|
717 begin
|
|
|
718 return Source.Last;
|
|
|
719 end Length;
|
|
|
720
|
|
|
721 ---------------
|
|
|
722 -- Overwrite --
|
|
|
723 ---------------
|
|
|
724
|
|
|
725 function Overwrite
|
|
|
726 (Source : Unbounded_String;
|
|
|
727 Position : Positive;
|
|
|
728 New_Item : String) return Unbounded_String
|
|
|
729 is
|
|
|
730 begin
|
|
|
731 return To_Unbounded_String
|
|
|
732 (Fixed.Overwrite
|
|
|
733 (Source.Reference (1 .. Source.Last), Position, New_Item));
|
|
|
734 end Overwrite;
|
|
|
735
|
|
|
736 procedure Overwrite
|
|
|
737 (Source : in out Unbounded_String;
|
|
|
738 Position : Positive;
|
|
|
739 New_Item : String)
|
|
|
740 is
|
|
|
741 NL : constant Natural := New_Item'Length;
|
|
|
742 begin
|
|
|
743 if Position <= Source.Last - NL + 1 then
|
|
|
744 Source.Reference (Position .. Position + NL - 1) := New_Item;
|
|
|
745 else
|
|
|
746 declare
|
|
|
747 Old : String_Access := Source.Reference;
|
|
|
748 begin
|
|
|
749 Source.Reference := new String'
|
|
|
750 (Fixed.Overwrite
|
|
|
751 (Source.Reference (1 .. Source.Last), Position, New_Item));
|
|
|
752 Source.Last := Source.Reference'Length;
|
|
|
753 Free (Old);
|
|
|
754 end;
|
|
|
755 end if;
|
|
|
756 end Overwrite;
|
|
|
757
|
|
|
758 -----------------------
|
|
|
759 -- Realloc_For_Chunk --
|
|
|
760 -----------------------
|
|
|
761
|
|
|
762 procedure Realloc_For_Chunk
|
|
|
763 (Source : in out Unbounded_String;
|
|
|
764 Chunk_Size : Natural)
|
|
|
765 is
|
|
131
|
766 Growth_Factor : constant := 2;
|
|
111
|
767 -- The growth factor controls how much extra space is allocated when
|
|
|
768 -- we have to increase the size of an allocated unbounded string. By
|
|
|
769 -- allocating extra space, we avoid the need to reallocate on every
|
|
|
770 -- append, particularly important when a string is built up by repeated
|
|
|
771 -- append operations of small pieces. This is expressed as a factor so
|
|
131
|
772 -- 2 means add 1/2 of the length of the string as growth space.
|
|
111
|
773
|
|
|
774 Min_Mul_Alloc : constant := Standard'Maximum_Alignment;
|
|
|
775 -- Allocation will be done by a multiple of Min_Mul_Alloc This causes
|
|
|
776 -- no memory loss as most (all?) malloc implementations are obliged to
|
|
|
777 -- align the returned memory on the maximum alignment as malloc does not
|
|
|
778 -- know the target alignment.
|
|
|
779
|
|
|
780 S_Length : constant Natural := Source.Reference'Length;
|
|
|
781
|
|
|
782 begin
|
|
|
783 if Chunk_Size > S_Length - Source.Last then
|
|
|
784 declare
|
|
|
785 New_Size : constant Positive :=
|
|
|
786 S_Length + Chunk_Size + (S_Length / Growth_Factor);
|
|
|
787
|
|
|
788 New_Rounded_Up_Size : constant Positive :=
|
|
|
789 ((New_Size - 1) / Min_Mul_Alloc + 1) * Min_Mul_Alloc;
|
|
|
790
|
|
|
791 Tmp : constant String_Access :=
|
|
|
792 new String (1 .. New_Rounded_Up_Size);
|
|
|
793
|
|
|
794 begin
|
|
|
795 Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
|
|
|
796 Free (Source.Reference);
|
|
|
797 Source.Reference := Tmp;
|
|
|
798 end;
|
|
|
799 end if;
|
|
|
800 end Realloc_For_Chunk;
|
|
|
801
|
|
|
802 ---------------------
|
|
|
803 -- Replace_Element --
|
|
|
804 ---------------------
|
|
|
805
|
|
|
806 procedure Replace_Element
|
|
|
807 (Source : in out Unbounded_String;
|
|
|
808 Index : Positive;
|
|
|
809 By : Character)
|
|
|
810 is
|
|
|
811 begin
|
|
|
812 if Index <= Source.Last then
|
|
|
813 Source.Reference (Index) := By;
|
|
|
814 else
|
|
|
815 raise Strings.Index_Error;
|
|
|
816 end if;
|
|
|
817 end Replace_Element;
|
|
|
818
|
|
|
819 -------------------
|
|
|
820 -- Replace_Slice --
|
|
|
821 -------------------
|
|
|
822
|
|
|
823 function Replace_Slice
|
|
|
824 (Source : Unbounded_String;
|
|
|
825 Low : Positive;
|
|
|
826 High : Natural;
|
|
|
827 By : String) return Unbounded_String
|
|
|
828 is
|
|
|
829 begin
|
|
|
830 return To_Unbounded_String
|
|
|
831 (Fixed.Replace_Slice
|
|
|
832 (Source.Reference (1 .. Source.Last), Low, High, By));
|
|
|
833 end Replace_Slice;
|
|
|
834
|
|
|
835 procedure Replace_Slice
|
|
|
836 (Source : in out Unbounded_String;
|
|
|
837 Low : Positive;
|
|
|
838 High : Natural;
|
|
|
839 By : String)
|
|
|
840 is
|
|
|
841 Old : String_Access := Source.Reference;
|
|
|
842 begin
|
|
|
843 Source.Reference := new String'
|
|
|
844 (Fixed.Replace_Slice
|
|
|
845 (Source.Reference (1 .. Source.Last), Low, High, By));
|
|
|
846 Source.Last := Source.Reference'Length;
|
|
|
847 Free (Old);
|
|
|
848 end Replace_Slice;
|
|
|
849
|
|
|
850 --------------------------
|
|
|
851 -- Set_Unbounded_String --
|
|
|
852 --------------------------
|
|
|
853
|
|
|
854 procedure Set_Unbounded_String
|
|
|
855 (Target : out Unbounded_String;
|
|
|
856 Source : String)
|
|
|
857 is
|
|
|
858 Old : String_Access := Target.Reference;
|
|
|
859 begin
|
|
|
860 Target.Last := Source'Length;
|
|
|
861 Target.Reference := new String (1 .. Source'Length);
|
|
|
862 Target.Reference.all := Source;
|
|
|
863 Free (Old);
|
|
|
864 end Set_Unbounded_String;
|
|
|
865
|
|
|
866 -----------
|
|
|
867 -- Slice --
|
|
|
868 -----------
|
|
|
869
|
|
|
870 function Slice
|
|
|
871 (Source : Unbounded_String;
|
|
|
872 Low : Positive;
|
|
|
873 High : Natural) return String
|
|
|
874 is
|
|
|
875 begin
|
|
|
876 -- Note: test of High > Length is in accordance with AI95-00128
|
|
|
877
|
|
|
878 if Low > Source.Last + 1 or else High > Source.Last then
|
|
|
879 raise Index_Error;
|
|
|
880 else
|
|
|
881 return Source.Reference (Low .. High);
|
|
|
882 end if;
|
|
|
883 end Slice;
|
|
|
884
|
|
|
885 ----------
|
|
|
886 -- Tail --
|
|
|
887 ----------
|
|
|
888
|
|
|
889 function Tail
|
|
|
890 (Source : Unbounded_String;
|
|
|
891 Count : Natural;
|
|
|
892 Pad : Character := Space) return Unbounded_String is
|
|
|
893 begin
|
|
|
894 return To_Unbounded_String
|
|
|
895 (Fixed.Tail (Source.Reference (1 .. Source.Last), Count, Pad));
|
|
|
896 end Tail;
|
|
|
897
|
|
|
898 procedure Tail
|
|
|
899 (Source : in out Unbounded_String;
|
|
|
900 Count : Natural;
|
|
|
901 Pad : Character := Space)
|
|
|
902 is
|
|
|
903 Old : String_Access := Source.Reference;
|
|
|
904 begin
|
|
|
905 Source.Reference := new String'
|
|
|
906 (Fixed.Tail (Source.Reference (1 .. Source.Last), Count, Pad));
|
|
|
907 Source.Last := Source.Reference'Length;
|
|
|
908 Free (Old);
|
|
|
909 end Tail;
|
|
|
910
|
|
|
911 ---------------
|
|
|
912 -- To_String --
|
|
|
913 ---------------
|
|
|
914
|
|
|
915 function To_String (Source : Unbounded_String) return String is
|
|
|
916 begin
|
|
|
917 return Source.Reference (1 .. Source.Last);
|
|
|
918 end To_String;
|
|
|
919
|
|
|
920 -------------------------
|
|
|
921 -- To_Unbounded_String --
|
|
|
922 -------------------------
|
|
|
923
|
|
|
924 function To_Unbounded_String (Source : String) return Unbounded_String is
|
|
|
925 Result : Unbounded_String;
|
|
|
926 begin
|
|
|
927 -- Do not allocate an empty string: keep the default
|
|
|
928
|
|
|
929 if Source'Length > 0 then
|
|
|
930 Result.Last := Source'Length;
|
|
|
931 Result.Reference := new String (1 .. Source'Length);
|
|
|
932 Result.Reference.all := Source;
|
|
|
933 end if;
|
|
|
934
|
|
|
935 return Result;
|
|
|
936 end To_Unbounded_String;
|
|
|
937
|
|
|
938 function To_Unbounded_String
|
|
|
939 (Length : Natural) return Unbounded_String
|
|
|
940 is
|
|
|
941 Result : Unbounded_String;
|
|
|
942
|
|
|
943 begin
|
|
|
944 -- Do not allocate an empty string: keep the default
|
|
|
945
|
|
|
946 if Length > 0 then
|
|
|
947 Result.Last := Length;
|
|
|
948 Result.Reference := new String (1 .. Length);
|
|
|
949 end if;
|
|
|
950
|
|
|
951 return Result;
|
|
|
952 end To_Unbounded_String;
|
|
|
953
|
|
|
954 ---------------
|
|
|
955 -- Translate --
|
|
|
956 ---------------
|
|
|
957
|
|
|
958 function Translate
|
|
|
959 (Source : Unbounded_String;
|
|
|
960 Mapping : Maps.Character_Mapping) return Unbounded_String
|
|
|
961 is
|
|
|
962 begin
|
|
|
963 return To_Unbounded_String
|
|
|
964 (Fixed.Translate (Source.Reference (1 .. Source.Last), Mapping));
|
|
|
965 end Translate;
|
|
|
966
|
|
|
967 procedure Translate
|
|
|
968 (Source : in out Unbounded_String;
|
|
|
969 Mapping : Maps.Character_Mapping)
|
|
|
970 is
|
|
|
971 begin
|
|
|
972 Fixed.Translate (Source.Reference (1 .. Source.Last), Mapping);
|
|
|
973 end Translate;
|
|
|
974
|
|
|
975 function Translate
|
|
|
976 (Source : Unbounded_String;
|
|
|
977 Mapping : Maps.Character_Mapping_Function) return Unbounded_String
|
|
|
978 is
|
|
|
979 begin
|
|
|
980 return To_Unbounded_String
|
|
|
981 (Fixed.Translate (Source.Reference (1 .. Source.Last), Mapping));
|
|
|
982 end Translate;
|
|
|
983
|
|
|
984 procedure Translate
|
|
|
985 (Source : in out Unbounded_String;
|
|
|
986 Mapping : Maps.Character_Mapping_Function)
|
|
|
987 is
|
|
|
988 begin
|
|
|
989 Fixed.Translate (Source.Reference (1 .. Source.Last), Mapping);
|
|
|
990 end Translate;
|
|
|
991
|
|
|
992 ----------
|
|
|
993 -- Trim --
|
|
|
994 ----------
|
|
|
995
|
|
|
996 function Trim
|
|
|
997 (Source : Unbounded_String;
|
|
|
998 Side : Trim_End) return Unbounded_String
|
|
|
999 is
|
|
|
1000 begin
|
|
|
1001 return To_Unbounded_String
|
|
|
1002 (Fixed.Trim (Source.Reference (1 .. Source.Last), Side));
|
|
|
1003 end Trim;
|
|
|
1004
|
|
|
1005 procedure Trim
|
|
|
1006 (Source : in out Unbounded_String;
|
|
|
1007 Side : Trim_End)
|
|
|
1008 is
|
|
|
1009 Old : String_Access := Source.Reference;
|
|
|
1010 begin
|
|
|
1011 Source.Reference := new String'
|
|
|
1012 (Fixed.Trim (Source.Reference (1 .. Source.Last), Side));
|
|
|
1013 Source.Last := Source.Reference'Length;
|
|
|
1014 Free (Old);
|
|
|
1015 end Trim;
|
|
|
1016
|
|
|
1017 function Trim
|
|
|
1018 (Source : Unbounded_String;
|
|
|
1019 Left : Maps.Character_Set;
|
|
|
1020 Right : Maps.Character_Set) return Unbounded_String
|
|
|
1021 is
|
|
|
1022 begin
|
|
|
1023 return To_Unbounded_String
|
|
|
1024 (Fixed.Trim (Source.Reference (1 .. Source.Last), Left, Right));
|
|
|
1025 end Trim;
|
|
|
1026
|
|
|
1027 procedure Trim
|
|
|
1028 (Source : in out Unbounded_String;
|
|
|
1029 Left : Maps.Character_Set;
|
|
|
1030 Right : Maps.Character_Set)
|
|
|
1031 is
|
|
|
1032 Old : String_Access := Source.Reference;
|
|
|
1033 begin
|
|
|
1034 Source.Reference := new String'
|
|
|
1035 (Fixed.Trim (Source.Reference (1 .. Source.Last), Left, Right));
|
|
|
1036 Source.Last := Source.Reference'Length;
|
|
|
1037 Free (Old);
|
|
|
1038 end Trim;
|
|
|
1039
|
|
|
1040 ---------------------
|
|
|
1041 -- Unbounded_Slice --
|
|
|
1042 ---------------------
|
|
|
1043
|
|
|
1044 function Unbounded_Slice
|
|
|
1045 (Source : Unbounded_String;
|
|
|
1046 Low : Positive;
|
|
|
1047 High : Natural) return Unbounded_String
|
|
|
1048 is
|
|
|
1049 begin
|
|
|
1050 if Low > Source.Last + 1 or else High > Source.Last then
|
|
|
1051 raise Index_Error;
|
|
|
1052 else
|
|
|
1053 return To_Unbounded_String (Source.Reference.all (Low .. High));
|
|
|
1054 end if;
|
|
|
1055 end Unbounded_Slice;
|
|
|
1056
|
|
|
1057 procedure Unbounded_Slice
|
|
|
1058 (Source : Unbounded_String;
|
|
|
1059 Target : out Unbounded_String;
|
|
|
1060 Low : Positive;
|
|
|
1061 High : Natural)
|
|
|
1062 is
|
|
|
1063 begin
|
|
|
1064 if Low > Source.Last + 1 or else High > Source.Last then
|
|
|
1065 raise Index_Error;
|
|
|
1066 else
|
|
|
1067 Target := To_Unbounded_String (Source.Reference.all (Low .. High));
|
|
|
1068 end if;
|
|
|
1069 end Unbounded_Slice;
|
|
|
1070
|
|
|
1071 end Ada.Strings.Unbounded;
|
