gcc/ada/a-strsup.ads

   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 --                                 S p e c                                  --
   8 --                                                                          --
   9 --          Copyright (C) 2003 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 2,  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.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  19 -- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
  20 -- MA 02111-1307, USA.                                                      --
  21 --                                                                          --
  22 -- As a special exception,  if other files  instantiate  generics from this --
  23 -- unit, or you link  this unit with other files  to produce an executable, --
  24 -- this  unit  does not  by itself cause  the resulting  executable  to  be --
  25 -- covered  by the  GNU  General  Public  License.  This exception does not --
  26 -- however invalidate  any other reasons why  the executable file  might be --
  27 -- covered by the  GNU Public License.                                      --
  28 --                                                                          --
  29 -- GNAT was originally developed  by the GNAT team at  New York University. --
  30 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  31 --                                                                          --
  32 ------------------------------------------------------------------------------
  33
  34 --  This non generic package contains most of the implementation of the
  35 --  generic package Ada.Strings.Bounded.Generic_Bounded_Length.
  36
  37 --  It defines type Super_String as a discriminated record with the maximum
  38 --  length as the discriminant. Individual instantiations of Strings.Bounded
  39 --  use this type with an appropriate discriminant value set.
  40
  41 with Ada.Strings.Maps;
  42
  43 package Ada.Strings.Superbounded is
  44 pragma Preelaborate (Superbounded);
  45
  46    type Super_String (Max_Length : Positive) is record
  47       Current_Length : Natural := 0;
  48       Data           : String (1 .. Max_Length) := (others => ASCII.NUL);
  49    end record;
  50    --  Type Bounded_String in Ada.Strings.Bounded.Generic_Bounded_Length is
  51    --  derived from this type, with the constraint of the maximum length.
  52
  53    --  The subprograms defined for Super_String are similar to those
  54    --  defined for Bounded_String, except that they have different names, so
  55    --  that they can be renamed in Ada.Strings.Bounded.Generic_Bounded_Length.
  56
  57    function Super_Length (Source : Super_String) return Natural;
  58
  59    --------------------------------------------------------
  60    -- Conversion, Concatenation, and Selection Functions --
  61    --------------------------------------------------------
  62
  63    function To_Super_String
  64      (Source     : String;
  65       Max_Length : Natural;
  66       Drop       : Truncation := Error)
  67       return       Super_String;
  68    --  Note the additional parameter Max_Length, which specifies the maximum
  69    --  length setting of the resulting Super_String value.
  70
  71    --  The following procedures have declarations (and semantics) that are
  72    --  exactly analogous to those declared in Ada.Strings.Bounded.
  73
  74    function Super_To_String (Source : Super_String) return String;
  75
  76    function Super_Append
  77      (Left, Right : Super_String;
  78       Drop        : Truncation  := Error)
  79       return        Super_String;
  80
  81    function Super_Append
  82      (Left  : Super_String;
  83       Right : String;
  84       Drop  : Truncation := Error)
  85       return  Super_String;
  86
  87    function Super_Append
  88      (Left  : String;
  89       Right : Super_String;
  90       Drop  : Truncation := Error)
  91       return  Super_String;
  92
  93    function Super_Append
  94      (Left  : Super_String;
  95       Right : Character;
  96       Drop  : Truncation := Error)
  97       return  Super_String;
  98
  99    function Super_Append
 100      (Left  : Character;
 101       Right : Super_String;
 102       Drop  : Truncation := Error)
 103       return  Super_String;
 104
 105    procedure Super_Append
 106      (Source   : in out Super_String;
 107       New_Item : Super_String;
 108       Drop     : Truncation  := Error);
 109
 110    procedure Super_Append
 111      (Source   : in out Super_String;
 112       New_Item : String;
 113       Drop     : Truncation  := Error);
 114
 115    procedure Super_Append
 116      (Source   : in out Super_String;
 117       New_Item : Character;
 118       Drop     : Truncation  := Error);
 119
 120    function Concat
 121      (Left, Right : Super_String)
 122       return        Super_String;
 123
 124    function Concat
 125      (Left  : Super_String;
 126       Right : String)
 127       return  Super_String;
 128
 129    function Concat
 130      (Left  : String;
 131       Right : Super_String)
 132       return  Super_String;
 133
 134    function Concat
 135      (Left  : Super_String;
 136       Right : Character)
 137       return  Super_String;
 138
 139    function Concat
 140      (Left  : Character;
 141       Right : Super_String)
 142       return  Super_String;
 143
 144    function Super_Element
 145      (Source : Super_String;
 146       Index  : Positive)
 147       return   Character;
 148
 149    procedure Super_Replace_Element
 150      (Source : in out Super_String;
 151       Index  : Positive;
 152       By     : Character);
 153
 154    function Super_Slice
 155      (Source : Super_String;
 156       Low    : Positive;
 157       High   : Natural)
 158       return   String;
 159
 160    function "="  (Left, Right : Super_String) return Boolean;
 161
 162    function Equal (Left, Right : Super_String) return Boolean renames "=";
 163
 164    function Equal
 165      (Left  : Super_String;
 166       Right : String)
 167       return  Boolean;
 168
 169    function Equal
 170      (Left  : String;
 171       Right : Super_String)
 172       return  Boolean;
 173
 174    function Less (Left, Right : Super_String) return Boolean;
 175
 176    function Less
 177      (Left  : Super_String;
 178       Right : String)
 179       return  Boolean;
 180
 181    function Less
 182      (Left  : String;
 183       Right : Super_String)
 184       return  Boolean;
 185
 186    function Less_Or_Equal (Left, Right : Super_String) return Boolean;
 187
 188    function Less_Or_Equal
 189      (Left  : Super_String;
 190       Right : String)
 191       return  Boolean;
 192
 193    function Less_Or_Equal
 194      (Left  : String;
 195       Right : Super_String)
 196       return  Boolean;
 197
 198    function Greater  (Left, Right : Super_String) return Boolean;
 199
 200    function Greater
 201      (Left  : Super_String;
 202       Right : String)
 203       return  Boolean;
 204
 205    function Greater
 206      (Left  : String;
 207       Right : Super_String)
 208       return  Boolean;
 209
 210    function Greater_Or_Equal (Left, Right : Super_String) return Boolean;
 211
 212    function Greater_Or_Equal
 213      (Left  : Super_String;
 214       Right : String)
 215       return  Boolean;
 216
 217    function Greater_Or_Equal
 218      (Left  : String;
 219       Right : Super_String)
 220       return  Boolean;
 221
 222    ----------------------
 223    -- Search Functions --
 224    ----------------------
 225
 226    function Super_Index
 227      (Source  : Super_String;
 228       Pattern : String;
 229       Going   : Direction := Forward;
 230       Mapping : Maps.Character_Mapping := Maps.Identity)
 231       return    Natural;
 232
 233    function Super_Index
 234      (Source  : Super_String;
 235       Pattern : String;
 236       Going   : Direction := Forward;
 237       Mapping : Maps.Character_Mapping_Function)
 238       return    Natural;
 239
 240    function Super_Index
 241      (Source : Super_String;
 242       Set    : Maps.Character_Set;
 243       Test   : Membership := Inside;
 244       Going  : Direction  := Forward)
 245       return   Natural;
 246
 247    function Super_Index_Non_Blank
 248      (Source : Super_String;
 249       Going  : Direction := Forward)
 250       return   Natural;
 251
 252    function Super_Count
 253      (Source  : Super_String;
 254       Pattern : String;
 255       Mapping : Maps.Character_Mapping := Maps.Identity)
 256       return    Natural;
 257
 258    function Super_Count
 259      (Source  : Super_String;
 260       Pattern : String;
 261       Mapping : Maps.Character_Mapping_Function)
 262       return    Natural;
 263
 264    function Super_Count
 265      (Source : Super_String;
 266       Set    : Maps.Character_Set)
 267       return   Natural;
 268
 269    procedure Super_Find_Token
 270      (Source : Super_String;
 271       Set    : Maps.Character_Set;
 272       Test   : Membership;
 273       First  : out Positive;
 274       Last   : out Natural);
 275
 276    ------------------------------------
 277    -- String Translation Subprograms --
 278    ------------------------------------
 279
 280    function Super_Translate
 281      (Source   : Super_String;
 282       Mapping  : Maps.Character_Mapping)
 283       return     Super_String;
 284
 285    procedure Super_Translate
 286      (Source   : in out Super_String;
 287       Mapping  : Maps.Character_Mapping);
 288
 289    function Super_Translate
 290      (Source  : Super_String;
 291       Mapping : Maps.Character_Mapping_Function)
 292       return    Super_String;
 293
 294    procedure Super_Translate
 295      (Source  : in out Super_String;
 296       Mapping : Maps.Character_Mapping_Function);
 297
 298    ---------------------------------------
 299    -- String Transformation Subprograms --
 300    ---------------------------------------
 301
 302    function Super_Replace_Slice
 303      (Source   : Super_String;
 304       Low      : Positive;
 305       High     : Natural;
 306       By       : String;
 307       Drop     : Truncation := Error)
 308       return     Super_String;
 309
 310    procedure Super_Replace_Slice
 311      (Source   : in out Super_String;
 312       Low      : Positive;
 313       High     : Natural;
 314       By       : String;
 315       Drop     : Truncation := Error);
 316
 317    function Super_Insert
 318      (Source   : Super_String;
 319       Before   : Positive;
 320       New_Item : String;
 321       Drop     : Truncation := Error)
 322       return     Super_String;
 323
 324    procedure Super_Insert
 325      (Source   : in out Super_String;
 326       Before   : Positive;
 327       New_Item : String;
 328       Drop     : Truncation := Error);
 329
 330    function Super_Overwrite
 331      (Source    : Super_String;
 332       Position  : Positive;
 333       New_Item  : String;
 334       Drop      : Truncation := Error)
 335       return      Super_String;
 336
 337    procedure Super_Overwrite
 338      (Source    : in out Super_String;
 339       Position  : Positive;
 340       New_Item  : String;
 341       Drop      : Truncation := Error);
 342
 343    function Super_Delete
 344      (Source  : Super_String;
 345       From    : Positive;
 346       Through : Natural)
 347       return    Super_String;
 348
 349    procedure Super_Delete
 350      (Source  : in out Super_String;
 351       From    : Positive;
 352       Through : Natural);
 353
 354    ---------------------------------
 355    -- String Selector Subprograms --
 356    ---------------------------------
 357
 358    function Super_Trim
 359      (Source : Super_String;
 360       Side   : Trim_End)
 361       return   Super_String;
 362
 363    procedure Super_Trim
 364      (Source : in out Super_String;
 365       Side   : Trim_End);
 366
 367    function Super_Trim
 368      (Source  : Super_String;
 369       Left   : Maps.Character_Set;
 370       Right  : Maps.Character_Set)
 371       return   Super_String;
 372
 373    procedure Super_Trim
 374      (Source : in out Super_String;
 375       Left   : Maps.Character_Set;
 376       Right  : Maps.Character_Set);
 377
 378    function Super_Head
 379      (Source : Super_String;
 380       Count  : Natural;
 381       Pad    : Character := Space;
 382       Drop   : Truncation := Error)
 383       return   Super_String;
 384
 385    procedure Super_Head
 386      (Source : in out Super_String;
 387       Count  : Natural;
 388       Pad    : Character  := Space;
 389       Drop   : Truncation := Error);
 390
 391    function Super_Tail
 392      (Source : Super_String;
 393       Count  : Natural;
 394       Pad    : Character  := Space;
 395       Drop   : Truncation := Error)
 396       return Super_String;
 397
 398    procedure Super_Tail
 399      (Source : in out Super_String;
 400       Count  : Natural;
 401       Pad    : Character  := Space;
 402       Drop   : Truncation := Error);
 403
 404    ------------------------------------
 405    -- String Constructor Subprograms --
 406    ------------------------------------
 407
 408    --  Note: in some of the following routines, there is an extra parameter
 409    --  Max_Length which specifies the value of the maximum length for the
 410    --  resulting Super_String value.
 411
 412    function Times
 413      (Left       : Natural;
 414       Right      : Character;
 415       Max_Length : Positive)
 416       return       Super_String;
 417    --  Note the additional parameter Max_Length
 418
 419    function Times
 420      (Left       : Natural;
 421       Right      : String;
 422       Max_Length : Positive)
 423       return       Super_String;
 424    --  Note the additional parameter Max_Length
 425
 426    function Times
 427      (Left  : Natural;
 428       Right : Super_String)
 429       return  Super_String;
 430
 431    function Super_Replicate
 432      (Count      : Natural;
 433       Item       : Character;
 434       Drop       : Truncation := Error;
 435       Max_Length : Positive)
 436       return       Super_String;
 437    --  Note the additional parameter Max_Length
 438
 439    function Super_Replicate
 440      (Count      : Natural;
 441       Item       : String;
 442       Drop       : Truncation := Error;
 443       Max_Length : Positive)
 444       return       Super_String;
 445    --  Note the additional parameter Max_Length
 446
 447    function Super_Replicate
 448      (Count : Natural;
 449       Item  : Super_String;
 450       Drop  : Truncation := Error)
 451       return  Super_String;
 452
 453 private
 454
 455       --  Pragma Inline declarations
 456
 457       pragma Inline ("=");
 458       pragma Inline (Less);
 459       pragma Inline (Less_Or_Equal);
 460       pragma Inline (Greater);
 461       pragma Inline (Greater_Or_Equal);
 462       pragma Inline (Concat);
 463       pragma Inline (Super_Count);
 464       pragma Inline (Super_Element);
 465       pragma Inline (Super_Find_Token);
 466       pragma Inline (Super_Index);
 467       pragma Inline (Super_Index_Non_Blank);
 468       pragma Inline (Super_Length);
 469       pragma Inline (Super_Replace_Element);
 470       pragma Inline (Super_Slice);
 471       pragma Inline (Super_To_String);
 472
 473 end Ada.Strings.Superbounded;