OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [ada/] [a-strbou.ads] - Blame information for rev 316

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 281 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT RUN-TIME COMPONENTS                         --
4
--                                                                          --
5
--                  A D A . S T R I N G S . B O U N D E D                   --
6
--                                                                          --
7
--                                 S p e c                                  --
8
--                                                                          --
9
--          Copyright (C) 1992-2009, Free Software Foundation, Inc.         --
10
--                                                                          --
11
-- This specification is derived from the Ada Reference Manual for use with --
12
-- GNAT. The copyright notice above, and the license provisions that follow --
13
-- apply solely to the  contents of the part following the private keyword. --
14
--                                                                          --
15
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
16
-- terms of the  GNU General Public License as published  by the Free Soft- --
17
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
18
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
19
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
20
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
21
--                                                                          --
22
-- As a special exception under Section 7 of GPL version 3, you are granted --
23
-- additional permissions described in the GCC Runtime Library Exception,   --
24
-- version 3.1, as published by the Free Software Foundation.               --
25
--                                                                          --
26
-- You should have received a copy of the GNU General Public License and    --
27
-- a copy of the GCC Runtime Library Exception along with this program;     --
28
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
29
-- <http://www.gnu.org/licenses/>.                                          --
30
--                                                                          --
31
-- GNAT was originally developed  by the GNAT team at  New York University. --
32
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
33
--                                                                          --
34
------------------------------------------------------------------------------
35
 
36
with Ada.Strings.Maps;
37
with Ada.Strings.Superbounded;
38
 
39
package Ada.Strings.Bounded is
40
   pragma Preelaborate;
41
 
42
   generic
43
      Max : Positive;
44
      --  Maximum length of a Bounded_String
45
 
46
   package Generic_Bounded_Length is
47
 
48
      Max_Length : constant Positive := Max;
49
 
50
      type Bounded_String is private;
51
      pragma Preelaborable_Initialization (Bounded_String);
52
 
53
      Null_Bounded_String : constant Bounded_String;
54
 
55
      subtype Length_Range is Natural range 0 .. Max_Length;
56
 
57
      function Length (Source : Bounded_String) return Length_Range;
58
 
59
      --------------------------------------------------------
60
      -- Conversion, Concatenation, and Selection Functions --
61
      --------------------------------------------------------
62
 
63
      function To_Bounded_String
64
        (Source : String;
65
         Drop   : Truncation := Error) return Bounded_String;
66
 
67
      function To_String (Source : Bounded_String) return String;
68
 
69
      procedure Set_Bounded_String
70
        (Target : out Bounded_String;
71
         Source : String;
72
         Drop   : Truncation := Error);
73
      pragma Ada_05 (Set_Bounded_String);
74
 
75
      function Append
76
        (Left  : Bounded_String;
77
         Right : Bounded_String;
78
         Drop  : Truncation  := Error) return Bounded_String;
79
 
80
      function Append
81
        (Left  : Bounded_String;
82
         Right : String;
83
         Drop  : Truncation := Error) return Bounded_String;
84
 
85
      function Append
86
        (Left  : String;
87
         Right : Bounded_String;
88
         Drop  : Truncation := Error) return Bounded_String;
89
 
90
      function Append
91
        (Left  : Bounded_String;
92
         Right : Character;
93
         Drop  : Truncation := Error) return Bounded_String;
94
 
95
      function Append
96
        (Left  : Character;
97
         Right : Bounded_String;
98
         Drop  : Truncation := Error) return Bounded_String;
99
 
100
      procedure Append
101
        (Source   : in out Bounded_String;
102
         New_Item : Bounded_String;
103
         Drop     : Truncation  := Error);
104
 
105
      procedure Append
106
        (Source   : in out Bounded_String;
107
         New_Item : String;
108
         Drop     : Truncation  := Error);
109
 
110
      procedure Append
111
        (Source   : in out Bounded_String;
112
         New_Item : Character;
113
         Drop     : Truncation  := Error);
114
 
115
      function "&"
116
        (Left  : Bounded_String;
117
         Right : Bounded_String) return Bounded_String;
118
 
119
      function "&"
120
        (Left  : Bounded_String;
121
         Right : String) return Bounded_String;
122
 
123
      function "&"
124
        (Left  : String;
125
         Right : Bounded_String) return Bounded_String;
126
 
127
      function "&"
128
        (Left  : Bounded_String;
129
         Right : Character) return Bounded_String;
130
 
131
      function "&"
132
        (Left  : Character;
133
         Right : Bounded_String) return Bounded_String;
134
 
135
      function Element
136
        (Source : Bounded_String;
137
         Index  : Positive) return Character;
138
 
139
      procedure Replace_Element
140
        (Source : in out Bounded_String;
141
         Index  : Positive;
142
         By     : Character);
143
 
144
      function Slice
145
        (Source : Bounded_String;
146
         Low    : Positive;
147
         High   : Natural) return String;
148
 
149
      function Bounded_Slice
150
        (Source : Bounded_String;
151
         Low    : Positive;
152
         High   : Natural) return Bounded_String;
153
      pragma Ada_05 (Bounded_Slice);
154
 
155
      procedure Bounded_Slice
156
        (Source : Bounded_String;
157
         Target : out Bounded_String;
158
         Low    : Positive;
159
         High   : Natural);
160
      pragma Ada_05 (Bounded_Slice);
161
 
162
      function "="
163
        (Left  : Bounded_String;
164
         Right : Bounded_String) return Boolean;
165
 
166
      function "="
167
        (Left  : Bounded_String;
168
         Right : String) return Boolean;
169
 
170
      function "="
171
        (Left  : String;
172
         Right : Bounded_String) return Boolean;
173
 
174
      function "<"
175
        (Left  : Bounded_String;
176
         Right : Bounded_String) return Boolean;
177
 
178
      function "<"
179
        (Left  : Bounded_String;
180
         Right : String) return Boolean;
181
 
182
      function "<"
183
        (Left  : String;
184
         Right : Bounded_String) return Boolean;
185
 
186
      function "<="
187
        (Left  : Bounded_String;
188
         Right : Bounded_String) return Boolean;
189
 
190
      function "<="
191
        (Left  : Bounded_String;
192
         Right : String) return Boolean;
193
 
194
      function "<="
195
        (Left  : String;
196
         Right : Bounded_String) return Boolean;
197
 
198
      function ">"
199
        (Left  : Bounded_String;
200
         Right : Bounded_String) return Boolean;
201
 
202
      function ">"
203
        (Left  : Bounded_String;
204
         Right : String) return Boolean;
205
 
206
      function ">"
207
        (Left  : String;
208
         Right : Bounded_String) return Boolean;
209
 
210
      function ">="
211
        (Left  : Bounded_String;
212
         Right : Bounded_String) return Boolean;
213
 
214
      function ">="
215
        (Left  : Bounded_String;
216
         Right : String) return Boolean;
217
 
218
      function ">="
219
        (Left  : String;
220
         Right : Bounded_String) return Boolean;
221
 
222
      ----------------------
223
      -- Search Functions --
224
      ----------------------
225
 
226
      function Index
227
        (Source  : Bounded_String;
228
         Pattern : String;
229
         Going   : Direction := Forward;
230
         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural;
231
 
232
      function Index
233
        (Source  : Bounded_String;
234
         Pattern : String;
235
         Going   : Direction := Forward;
236
         Mapping : Maps.Character_Mapping_Function) return Natural;
237
 
238
      function Index
239
        (Source : Bounded_String;
240
         Set    : Maps.Character_Set;
241
         Test   : Membership := Inside;
242
         Going  : Direction  := Forward) return Natural;
243
 
244
      function Index
245
        (Source  : Bounded_String;
246
         Pattern : String;
247
         From    : Positive;
248
         Going   : Direction := Forward;
249
         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural;
250
      pragma Ada_05 (Index);
251
 
252
      function Index
253
        (Source  : Bounded_String;
254
         Pattern : String;
255
         From    : Positive;
256
         Going   : Direction := Forward;
257
         Mapping : Maps.Character_Mapping_Function) return Natural;
258
      pragma Ada_05 (Index);
259
 
260
      function Index
261
        (Source  : Bounded_String;
262
         Set     : Maps.Character_Set;
263
         From    : Positive;
264
         Test    : Membership := Inside;
265
         Going   : Direction := Forward) return Natural;
266
      pragma Ada_05 (Index);
267
 
268
      function Index_Non_Blank
269
        (Source : Bounded_String;
270
         Going  : Direction := Forward) return Natural;
271
 
272
      function Index_Non_Blank
273
        (Source : Bounded_String;
274
         From   : Positive;
275
         Going  : Direction := Forward) return Natural;
276
      pragma Ada_05 (Index_Non_Blank);
277
 
278
      function Count
279
        (Source  : Bounded_String;
280
         Pattern : String;
281
         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural;
282
 
283
      function Count
284
        (Source  : Bounded_String;
285
         Pattern : String;
286
         Mapping : Maps.Character_Mapping_Function) return Natural;
287
 
288
      function Count
289
        (Source : Bounded_String;
290
         Set    : Maps.Character_Set) return Natural;
291
 
292
      procedure Find_Token
293
        (Source : Bounded_String;
294
         Set    : Maps.Character_Set;
295
         Test   : Membership;
296
         First  : out Positive;
297
         Last   : out Natural);
298
 
299
      ------------------------------------
300
      -- String Translation Subprograms --
301
      ------------------------------------
302
 
303
      function Translate
304
        (Source  : Bounded_String;
305
         Mapping : Maps.Character_Mapping) return Bounded_String;
306
 
307
      procedure Translate
308
        (Source   : in out Bounded_String;
309
         Mapping  : Maps.Character_Mapping);
310
 
311
      function Translate
312
        (Source  : Bounded_String;
313
         Mapping : Maps.Character_Mapping_Function) return Bounded_String;
314
 
315
      procedure Translate
316
        (Source  : in out Bounded_String;
317
         Mapping : Maps.Character_Mapping_Function);
318
 
319
      ---------------------------------------
320
      -- String Transformation Subprograms --
321
      ---------------------------------------
322
 
323
      function Replace_Slice
324
        (Source : Bounded_String;
325
         Low    : Positive;
326
         High   : Natural;
327
         By     : String;
328
         Drop   : Truncation := Error) return Bounded_String;
329
 
330
      procedure Replace_Slice
331
        (Source   : in out Bounded_String;
332
         Low      : Positive;
333
         High     : Natural;
334
         By       : String;
335
         Drop     : Truncation := Error);
336
 
337
      function Insert
338
        (Source   : Bounded_String;
339
         Before   : Positive;
340
         New_Item : String;
341
         Drop     : Truncation := Error) return Bounded_String;
342
 
343
      procedure Insert
344
        (Source   : in out Bounded_String;
345
         Before   : Positive;
346
         New_Item : String;
347
         Drop     : Truncation := Error);
348
 
349
      function Overwrite
350
        (Source   : Bounded_String;
351
         Position : Positive;
352
         New_Item : String;
353
         Drop     : Truncation := Error) return Bounded_String;
354
 
355
      procedure Overwrite
356
        (Source    : in out Bounded_String;
357
         Position  : Positive;
358
         New_Item  : String;
359
         Drop      : Truncation := Error);
360
 
361
      function Delete
362
        (Source  : Bounded_String;
363
         From    : Positive;
364
         Through : Natural) return Bounded_String;
365
 
366
      procedure Delete
367
        (Source  : in out Bounded_String;
368
         From    : Positive;
369
         Through : Natural);
370
 
371
      ---------------------------------
372
      -- String Selector Subprograms --
373
      ---------------------------------
374
 
375
      function Trim
376
        (Source : Bounded_String;
377
         Side   : Trim_End) return Bounded_String;
378
 
379
      procedure Trim
380
        (Source : in out Bounded_String;
381
         Side   : Trim_End);
382
 
383
      function Trim
384
        (Source : Bounded_String;
385
          Left  : Maps.Character_Set;
386
          Right : Maps.Character_Set) return Bounded_String;
387
 
388
      procedure Trim
389
        (Source : in out Bounded_String;
390
         Left   : Maps.Character_Set;
391
         Right  : Maps.Character_Set);
392
 
393
      function Head
394
        (Source : Bounded_String;
395
         Count  : Natural;
396
         Pad    : Character := Space;
397
         Drop   : Truncation := Error) return Bounded_String;
398
 
399
      procedure Head
400
        (Source : in out Bounded_String;
401
         Count  : Natural;
402
         Pad    : Character  := Space;
403
         Drop   : Truncation := Error);
404
 
405
      function Tail
406
        (Source : Bounded_String;
407
         Count  : Natural;
408
         Pad    : Character  := Space;
409
         Drop   : Truncation := Error) return Bounded_String;
410
 
411
      procedure Tail
412
        (Source : in out Bounded_String;
413
         Count  : Natural;
414
         Pad    : Character  := Space;
415
         Drop   : Truncation := Error);
416
 
417
      ------------------------------------
418
      -- String Constructor Subprograms --
419
      ------------------------------------
420
 
421
      function "*"
422
        (Left  : Natural;
423
         Right : Character) return Bounded_String;
424
 
425
      function "*"
426
        (Left  : Natural;
427
         Right : String) return Bounded_String;
428
 
429
      function "*"
430
        (Left  : Natural;
431
         Right : Bounded_String) return Bounded_String;
432
 
433
      function Replicate
434
        (Count : Natural;
435
         Item  : Character;
436
         Drop  : Truncation := Error) return Bounded_String;
437
 
438
      function Replicate
439
        (Count : Natural;
440
         Item  : String;
441
         Drop  : Truncation := Error) return Bounded_String;
442
 
443
      function Replicate
444
        (Count : Natural;
445
         Item  : Bounded_String;
446
         Drop  : Truncation := Error) return Bounded_String;
447
 
448
   private
449
      --  Most of the implementation is in the separate non generic package
450
      --  Ada.Strings.Superbounded. Type Bounded_String is derived from type
451
      --  Superbounded.Super_String with the maximum length constraint. In
452
      --  almost all cases, the routines in Superbounded can be called with
453
      --  no requirement to pass the maximum length explicitly, since there
454
      --  is at least one Bounded_String argument from which the maximum
455
      --  length can be obtained. For all such routines, the implementation
456
      --  in this private part is simply a renaming of the corresponding
457
      --  routine in the superbounded package.
458
 
459
      --  The five exceptions are the * and Replicate routines operating on
460
      --  character values. For these cases, we have a routine in the body
461
      --  that calls the superbounded routine passing the maximum length
462
      --  explicitly as an extra parameter.
463
 
464
      type Bounded_String is new Superbounded.Super_String (Max_Length);
465
      --  Deriving Bounded_String from Superbounded.Super_String is the
466
      --  real trick, it ensures that the type Bounded_String declared in
467
      --  the generic instantiation is compatible with the Super_String
468
      --  type declared in the Superbounded package.
469
 
470
      function From_String (Source : String) return Bounded_String;
471
      --  Private routine used only by Stream_Convert
472
 
473
      pragma Stream_Convert (Bounded_String, From_String, To_String);
474
      --  Provide stream routines without dragging in Ada.Streams
475
 
476
      Null_Bounded_String : constant Bounded_String :=
477
                              (Max_Length     => Max_Length,
478
                               Current_Length => 0,
479
                               Data           =>
480
                                 (1 .. Max_Length => ASCII.NUL));
481
 
482
      pragma Inline (To_Bounded_String);
483
 
484
      procedure Set_Bounded_String
485
        (Target : out Bounded_String;
486
         Source : String;
487
         Drop   : Truncation := Error)
488
         renames Set_Super_String;
489
 
490
      function Length
491
        (Source : Bounded_String) return Length_Range
492
         renames Super_Length;
493
 
494
      function To_String
495
        (Source : Bounded_String) return String
496
         renames Super_To_String;
497
 
498
      function Append
499
        (Left  : Bounded_String;
500
         Right : Bounded_String;
501
         Drop  : Truncation  := Error) return Bounded_String
502
         renames Super_Append;
503
 
504
      function Append
505
        (Left  : Bounded_String;
506
         Right : String;
507
         Drop  : Truncation := Error) return Bounded_String
508
         renames Super_Append;
509
 
510
      function Append
511
        (Left  : String;
512
         Right : Bounded_String;
513
         Drop  : Truncation := Error) return Bounded_String
514
         renames Super_Append;
515
 
516
      function Append
517
        (Left  : Bounded_String;
518
         Right : Character;
519
         Drop  : Truncation := Error) return Bounded_String
520
         renames Super_Append;
521
 
522
      function Append
523
        (Left  : Character;
524
         Right : Bounded_String;
525
         Drop  : Truncation := Error) return Bounded_String
526
         renames Super_Append;
527
 
528
      procedure Append
529
        (Source   : in out Bounded_String;
530
         New_Item : Bounded_String;
531
         Drop     : Truncation  := Error)
532
         renames Super_Append;
533
 
534
      procedure Append
535
        (Source   : in out Bounded_String;
536
         New_Item : String;
537
         Drop     : Truncation  := Error)
538
         renames Super_Append;
539
 
540
      procedure Append
541
        (Source   : in out Bounded_String;
542
         New_Item : Character;
543
         Drop     : Truncation  := Error)
544
         renames Super_Append;
545
 
546
      function "&"
547
        (Left  : Bounded_String;
548
         Right : Bounded_String) return Bounded_String
549
         renames Concat;
550
 
551
      function "&"
552
        (Left  : Bounded_String;
553
         Right : String) return Bounded_String
554
         renames Concat;
555
 
556
      function "&"
557
        (Left  : String;
558
         Right : Bounded_String) return Bounded_String
559
         renames Concat;
560
 
561
      function "&"
562
        (Left  : Bounded_String;
563
         Right : Character) return Bounded_String
564
         renames Concat;
565
 
566
      function "&"
567
        (Left  : Character;
568
         Right : Bounded_String) return Bounded_String
569
         renames Concat;
570
 
571
      function Element
572
        (Source : Bounded_String;
573
         Index  : Positive) return Character
574
         renames Super_Element;
575
 
576
      procedure Replace_Element
577
        (Source : in out Bounded_String;
578
         Index  : Positive;
579
         By     : Character)
580
         renames Super_Replace_Element;
581
 
582
      function Slice
583
        (Source : Bounded_String;
584
         Low    : Positive;
585
         High   : Natural) return String
586
         renames Super_Slice;
587
 
588
      function Bounded_Slice
589
        (Source : Bounded_String;
590
         Low    : Positive;
591
         High   : Natural) return Bounded_String
592
         renames Super_Slice;
593
 
594
      procedure Bounded_Slice
595
        (Source : Bounded_String;
596
         Target : out Bounded_String;
597
         Low    : Positive;
598
         High   : Natural)
599
         renames Super_Slice;
600
 
601
      function "="
602
        (Left  : Bounded_String;
603
         Right : Bounded_String) return Boolean
604
         renames Equal;
605
 
606
      function "="
607
        (Left  : Bounded_String;
608
         Right : String) return Boolean
609
         renames Equal;
610
 
611
      function "="
612
        (Left  : String;
613
         Right : Bounded_String) return Boolean
614
         renames Equal;
615
 
616
      function "<"
617
        (Left  : Bounded_String;
618
         Right : Bounded_String) return Boolean
619
         renames Less;
620
 
621
      function "<"
622
        (Left  : Bounded_String;
623
         Right : String) return Boolean
624
         renames Less;
625
 
626
      function "<"
627
        (Left  : String;
628
         Right : Bounded_String) return Boolean
629
         renames Less;
630
 
631
      function "<="
632
        (Left  : Bounded_String;
633
         Right : Bounded_String) return Boolean
634
         renames Less_Or_Equal;
635
 
636
      function "<="
637
        (Left  : Bounded_String;
638
         Right : String) return Boolean
639
         renames Less_Or_Equal;
640
 
641
      function "<="
642
        (Left  : String;
643
         Right : Bounded_String) return Boolean
644
         renames Less_Or_Equal;
645
 
646
      function ">"
647
        (Left  : Bounded_String;
648
         Right : Bounded_String) return Boolean
649
         renames Greater;
650
 
651
      function ">"
652
        (Left  : Bounded_String;
653
         Right : String) return Boolean
654
         renames Greater;
655
 
656
      function ">"
657
        (Left  : String;
658
         Right : Bounded_String) return Boolean
659
         renames Greater;
660
 
661
      function ">="
662
        (Left  : Bounded_String;
663
         Right : Bounded_String) return Boolean
664
         renames Greater_Or_Equal;
665
 
666
      function ">="
667
        (Left  : Bounded_String;
668
         Right : String) return Boolean
669
         renames Greater_Or_Equal;
670
 
671
      function ">="
672
        (Left  : String;
673
         Right : Bounded_String) return Boolean
674
         renames Greater_Or_Equal;
675
 
676
      function Index
677
        (Source  : Bounded_String;
678
         Pattern : String;
679
         Going   : Direction := Forward;
680
         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
681
         renames Super_Index;
682
 
683
      function Index
684
        (Source  : Bounded_String;
685
         Pattern : String;
686
         Going   : Direction := Forward;
687
         Mapping : Maps.Character_Mapping_Function) return Natural
688
         renames Super_Index;
689
 
690
      function Index
691
        (Source : Bounded_String;
692
         Set    : Maps.Character_Set;
693
         Test   : Membership := Inside;
694
         Going  : Direction  := Forward) return Natural
695
         renames Super_Index;
696
 
697
      function Index
698
        (Source  : Bounded_String;
699
         Pattern : String;
700
         From    : Positive;
701
         Going   : Direction := Forward;
702
         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
703
         renames Super_Index;
704
 
705
      function Index
706
        (Source  : Bounded_String;
707
         Pattern : String;
708
         From    : Positive;
709
         Going   : Direction := Forward;
710
         Mapping : Maps.Character_Mapping_Function) return Natural
711
      renames Super_Index;
712
 
713
      function Index
714
        (Source  : Bounded_String;
715
         Set     : Maps.Character_Set;
716
         From    : Positive;
717
         Test    : Membership := Inside;
718
         Going   : Direction := Forward) return Natural
719
      renames Super_Index;
720
 
721
      function Index_Non_Blank
722
        (Source : Bounded_String;
723
         Going  : Direction := Forward) return Natural
724
         renames Super_Index_Non_Blank;
725
 
726
      function Index_Non_Blank
727
        (Source : Bounded_String;
728
         From   : Positive;
729
         Going  : Direction := Forward) return Natural
730
         renames Super_Index_Non_Blank;
731
 
732
      function Count
733
        (Source  : Bounded_String;
734
         Pattern : String;
735
         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
736
         renames Super_Count;
737
 
738
      function Count
739
        (Source  : Bounded_String;
740
         Pattern : String;
741
         Mapping : Maps.Character_Mapping_Function) return Natural
742
         renames Super_Count;
743
 
744
      function Count
745
        (Source : Bounded_String;
746
         Set    : Maps.Character_Set) return Natural
747
         renames Super_Count;
748
 
749
      procedure Find_Token
750
        (Source : Bounded_String;
751
         Set    : Maps.Character_Set;
752
         Test   : Membership;
753
         First  : out Positive;
754
         Last   : out Natural)
755
         renames Super_Find_Token;
756
 
757
      function Translate
758
        (Source  : Bounded_String;
759
         Mapping : Maps.Character_Mapping) return Bounded_String
760
         renames Super_Translate;
761
 
762
      procedure Translate
763
        (Source   : in out Bounded_String;
764
         Mapping  : Maps.Character_Mapping)
765
         renames Super_Translate;
766
 
767
      function Translate
768
        (Source  : Bounded_String;
769
         Mapping : Maps.Character_Mapping_Function) return Bounded_String
770
         renames Super_Translate;
771
 
772
      procedure Translate
773
        (Source  : in out Bounded_String;
774
         Mapping : Maps.Character_Mapping_Function)
775
         renames Super_Translate;
776
 
777
      function Replace_Slice
778
        (Source : Bounded_String;
779
         Low    : Positive;
780
         High   : Natural;
781
         By     : String;
782
         Drop   : Truncation := Error) return Bounded_String
783
         renames Super_Replace_Slice;
784
 
785
      procedure Replace_Slice
786
        (Source   : in out Bounded_String;
787
         Low      : Positive;
788
         High     : Natural;
789
         By       : String;
790
         Drop     : Truncation := Error)
791
         renames Super_Replace_Slice;
792
 
793
      function Insert
794
        (Source   : Bounded_String;
795
         Before   : Positive;
796
         New_Item : String;
797
         Drop     : Truncation := Error) return Bounded_String
798
         renames Super_Insert;
799
 
800
      procedure Insert
801
        (Source   : in out Bounded_String;
802
         Before   : Positive;
803
         New_Item : String;
804
         Drop     : Truncation := Error)
805
         renames Super_Insert;
806
 
807
      function Overwrite
808
        (Source   : Bounded_String;
809
         Position : Positive;
810
         New_Item : String;
811
         Drop     : Truncation := Error) return Bounded_String
812
         renames Super_Overwrite;
813
 
814
      procedure Overwrite
815
        (Source    : in out Bounded_String;
816
         Position  : Positive;
817
         New_Item  : String;
818
         Drop      : Truncation := Error)
819
         renames Super_Overwrite;
820
 
821
      function Delete
822
        (Source  : Bounded_String;
823
         From    : Positive;
824
         Through : Natural) return Bounded_String
825
         renames Super_Delete;
826
 
827
      procedure Delete
828
        (Source  : in out Bounded_String;
829
         From    : Positive;
830
         Through : Natural)
831
         renames Super_Delete;
832
 
833
      function Trim
834
        (Source : Bounded_String;
835
         Side   : Trim_End) return Bounded_String
836
         renames Super_Trim;
837
 
838
      procedure Trim
839
        (Source : in out Bounded_String;
840
         Side   : Trim_End)
841
         renames Super_Trim;
842
 
843
      function Trim
844
        (Source : Bounded_String;
845
         Left   : Maps.Character_Set;
846
         Right  : Maps.Character_Set) return Bounded_String
847
         renames Super_Trim;
848
 
849
      procedure Trim
850
        (Source : in out Bounded_String;
851
         Left   : Maps.Character_Set;
852
         Right  : Maps.Character_Set)
853
         renames Super_Trim;
854
 
855
      function Head
856
        (Source : Bounded_String;
857
         Count  : Natural;
858
         Pad    : Character := Space;
859
         Drop   : Truncation := Error) return Bounded_String
860
         renames Super_Head;
861
 
862
      procedure Head
863
        (Source : in out Bounded_String;
864
         Count  : Natural;
865
         Pad    : Character  := Space;
866
         Drop   : Truncation := Error)
867
         renames Super_Head;
868
 
869
      function Tail
870
        (Source : Bounded_String;
871
         Count  : Natural;
872
         Pad    : Character  := Space;
873
         Drop   : Truncation := Error) return Bounded_String
874
         renames Super_Tail;
875
 
876
      procedure Tail
877
        (Source : in out Bounded_String;
878
         Count  : Natural;
879
         Pad    : Character  := Space;
880
         Drop   : Truncation := Error)
881
         renames Super_Tail;
882
 
883
      function "*"
884
        (Left  : Natural;
885
         Right : Bounded_String) return Bounded_String
886
         renames Times;
887
 
888
      function Replicate
889
        (Count : Natural;
890
         Item  : Bounded_String;
891
         Drop  : Truncation := Error) return Bounded_String
892
         renames Super_Replicate;
893
 
894
   end Generic_Bounded_Length;
895
 
896
end Ada.Strings.Bounded;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.