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