blob: 8ae039336d9e158f4b036b24a445b0ac279a6c08 [file] [log] [blame]
------------------------------------------------------------------------------
-- --
-- GNAT RUNTIME COMPONENTS --
-- --
-- A D A . S T R I N G S . S U P E R B O U N D E D --
-- --
-- B o d y --
-- --
-- Copyright (C) 2003 Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 2, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING. If not, write --
-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
-- MA 02111-1307, USA. --
-- --
-- As a special exception, if other files instantiate generics from this --
-- unit, or you link this unit with other files to produce an executable, --
-- this unit does not by itself cause the resulting executable to be --
-- covered by the GNU General Public License. This exception does not --
-- however invalidate any other reasons why the executable file might be --
-- covered by the GNU Public License. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with Ada.Strings.Maps; use Ada.Strings.Maps;
with Ada.Strings.Search;
package body Ada.Strings.Superbounded is
------------
-- Concat --
------------
function Concat
(Left : Super_String;
Right : Super_String)
return Super_String
is
Result : Super_String (Left.Max_Length);
Llen : constant Natural := Left.Current_Length;
Rlen : constant Natural := Right.Current_Length;
Nlen : constant Natural := Llen + Rlen;
begin
if Nlen > Left.Max_Length then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Nlen;
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen);
end if;
return Result;
end Concat;
function Concat
(Left : Super_String;
Right : String)
return Super_String
is
Result : Super_String (Left.Max_Length);
Llen : constant Natural := Left.Current_Length;
Nlen : constant Natural := Llen + Right'Length;
begin
if Nlen > Left.Max_Length then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Nlen;
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Llen + 1 .. Nlen) := Right;
end if;
return Result;
end Concat;
function Concat
(Left : String;
Right : Super_String)
return Super_String
is
Result : Super_String (Right.Max_Length);
Llen : constant Natural := Left'Length;
Rlen : constant Natural := Right.Current_Length;
Nlen : constant Natural := Llen + Rlen;
begin
if Nlen > Right.Max_Length then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Nlen;
Result.Data (1 .. Llen) := Left;
Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen);
end if;
return Result;
end Concat;
function Concat
(Left : Super_String;
Right : Character)
return Super_String
is
Result : Super_String (Left.Max_Length);
Llen : constant Natural := Left.Current_Length;
begin
if Llen = Left.Max_Length then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Llen + 1;
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Result.Current_Length) := Right;
end if;
return Result;
end Concat;
function Concat
(Left : Character;
Right : Super_String)
return Super_String
is
Result : Super_String (Right.Max_Length);
Rlen : constant Natural := Right.Current_Length;
begin
if Rlen = Right.Max_Length then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Rlen + 1;
Result.Data (1) := Left;
Result.Data (2 .. Result.Current_Length) := Right.Data (1 .. Rlen);
end if;
return Result;
end Concat;
-----------
-- Equal --
-----------
function "=" (Left, Right : Super_String) return Boolean is
begin
return Left.Current_Length = Right.Current_Length
and then Left.Data (1 .. Left.Current_Length) =
Right.Data (1 .. Right.Current_Length);
end "=";
function Equal (Left : Super_String; Right : String)
return Boolean is
begin
return Left.Current_Length = Right'Length
and then Left.Data (1 .. Left.Current_Length) = Right;
end Equal;
function Equal (Left : String; Right : Super_String)
return Boolean is
begin
return Left'Length = Right.Current_Length
and then Left = Right.Data (1 .. Right.Current_Length);
end Equal;
-------------
-- Greater --
-------------
function Greater (Left, Right : Super_String) return Boolean is
begin
return Left.Data (1 .. Left.Current_Length) >
Right.Data (1 .. Right.Current_Length);
end Greater;
function Greater
(Left : Super_String;
Right : String)
return Boolean
is
begin
return Left.Data (1 .. Left.Current_Length) > Right;
end Greater;
function Greater
(Left : String;
Right : Super_String)
return Boolean
is
begin
return Left > Right.Data (1 .. Right.Current_Length);
end Greater;
----------------------
-- Greater_Or_Equal --
----------------------
function Greater_Or_Equal (Left, Right : Super_String) return Boolean is
begin
return Left.Data (1 .. Left.Current_Length) >=
Right.Data (1 .. Right.Current_Length);
end Greater_Or_Equal;
function Greater_Or_Equal
(Left : Super_String;
Right : String)
return Boolean
is
begin
return Left.Data (1 .. Left.Current_Length) >= Right;
end Greater_Or_Equal;
function Greater_Or_Equal
(Left : String;
Right : Super_String)
return Boolean
is
begin
return Left >= Right.Data (1 .. Right.Current_Length);
end Greater_Or_Equal;
----------
-- Less --
----------
function Less (Left, Right : Super_String) return Boolean is
begin
return Left.Data (1 .. Left.Current_Length) <
Right.Data (1 .. Right.Current_Length);
end Less;
function Less
(Left : Super_String;
Right : String)
return Boolean
is
begin
return Left.Data (1 .. Left.Current_Length) < Right;
end Less;
function Less
(Left : String;
Right : Super_String)
return Boolean
is
begin
return Left < Right.Data (1 .. Right.Current_Length);
end Less;
-------------------
-- Less_Or_Equal --
-------------------
function Less_Or_Equal (Left, Right : Super_String) return Boolean is
begin
return Left.Data (1 .. Left.Current_Length) <=
Right.Data (1 .. Right.Current_Length);
end Less_Or_Equal;
function Less_Or_Equal
(Left : Super_String;
Right : String)
return Boolean
is
begin
return Left.Data (1 .. Left.Current_Length) <= Right;
end Less_Or_Equal;
function Less_Or_Equal
(Left : String;
Right : Super_String)
return Boolean
is
begin
return Left <= Right.Data (1 .. Right.Current_Length);
end Less_Or_Equal;
------------------
-- Super_Append --
------------------
-- Case of Super_String and Super_String
function Super_Append
(Left, Right : Super_String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Left.Max_Length;
Result : Super_String (Max_Length);
Llen : constant Natural := Left.Current_Length;
Rlen : constant Natural := Right.Current_Length;
Nlen : constant Natural := Llen + Rlen;
begin
if Nlen <= Max_Length then
Result.Current_Length := Nlen;
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen);
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
if Llen >= Max_Length then -- only case is Llen = Max_Length
Result.Data := Left.Data;
else
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Llen + 1 .. Max_Length) :=
Right.Data (1 .. Max_Length - Llen);
end if;
when Strings.Left =>
if Rlen >= Max_Length then -- only case is Rlen = Max_Length
Result.Data := Right.Data;
else
Result.Data (1 .. Max_Length - Rlen) :=
Left.Data (Llen - (Max_Length - Rlen - 1) .. Llen);
Result.Data (Max_Length - Rlen + 1 .. Max_Length) :=
Right.Data (1 .. Rlen);
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end Super_Append;
procedure Super_Append
(Source : in out Super_String;
New_Item : Super_String;
Drop : Truncation := Error)
is
Max_Length : constant Positive := Source.Max_Length;
Llen : constant Natural := Source.Current_Length;
Rlen : constant Natural := New_Item.Current_Length;
Nlen : constant Natural := Llen + Rlen;
begin
if Nlen <= Max_Length then
Source.Current_Length := Nlen;
Source.Data (Llen + 1 .. Nlen) := New_Item.Data (1 .. Rlen);
else
Source.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
if Llen < Max_Length then
Source.Data (Llen + 1 .. Max_Length) :=
New_Item.Data (1 .. Max_Length - Llen);
end if;
when Strings.Left =>
if Rlen >= Max_Length then -- only case is Rlen = Max_Length
Source.Data := New_Item.Data;
else
Source.Data (1 .. Max_Length - Rlen) :=
Source.Data (Llen - (Max_Length - Rlen - 1) .. Llen);
Source.Data (Max_Length - Rlen + 1 .. Max_Length) :=
New_Item.Data (1 .. Rlen);
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Append;
-- Case of Super_String and String
function Super_Append
(Left : Super_String;
Right : String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Left.Max_Length;
Result : Super_String (Max_Length);
Llen : constant Natural := Left.Current_Length;
Rlen : constant Natural := Right'Length;
Nlen : constant Natural := Llen + Rlen;
begin
if Nlen <= Max_Length then
Result.Current_Length := Nlen;
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Llen + 1 .. Nlen) := Right;
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
if Llen >= Max_Length then -- only case is Llen = Max_Length
Result.Data := Left.Data;
else
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Llen + 1 .. Max_Length) :=
Right (Right'First .. Right'First - 1 +
Max_Length - Llen);
end if;
when Strings.Left =>
if Rlen >= Max_Length then
Result.Data (1 .. Max_Length) :=
Right (Right'Last - (Max_Length - 1) .. Right'Last);
else
Result.Data (1 .. Max_Length - Rlen) :=
Left.Data (Llen - (Max_Length - Rlen - 1) .. Llen);
Result.Data (Max_Length - Rlen + 1 .. Max_Length) :=
Right;
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end Super_Append;
procedure Super_Append
(Source : in out Super_String;
New_Item : String;
Drop : Truncation := Error)
is
Max_Length : constant Positive := Source.Max_Length;
Llen : constant Natural := Source.Current_Length;
Rlen : constant Natural := New_Item'Length;
Nlen : constant Natural := Llen + Rlen;
begin
if Nlen <= Max_Length then
Source.Current_Length := Nlen;
Source.Data (Llen + 1 .. Nlen) := New_Item;
else
Source.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
if Llen < Max_Length then
Source.Data (Llen + 1 .. Max_Length) :=
New_Item (New_Item'First ..
New_Item'First - 1 + Max_Length - Llen);
end if;
when Strings.Left =>
if Rlen >= Max_Length then
Source.Data (1 .. Max_Length) :=
New_Item (New_Item'Last - (Max_Length - 1) ..
New_Item'Last);
else
Source.Data (1 .. Max_Length - Rlen) :=
Source.Data (Llen - (Max_Length - Rlen - 1) .. Llen);
Source.Data (Max_Length - Rlen + 1 .. Max_Length) :=
New_Item;
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Append;
-- Case of String and Super_String
function Super_Append
(Left : String;
Right : Super_String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Right.Max_Length;
Result : Super_String (Max_Length);
Llen : constant Natural := Left'Length;
Rlen : constant Natural := Right.Current_Length;
Nlen : constant Natural := Llen + Rlen;
begin
if Nlen <= Max_Length then
Result.Current_Length := Nlen;
Result.Data (1 .. Llen) := Left;
Result.Data (Llen + 1 .. Llen + Rlen) := Right.Data (1 .. Rlen);
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
if Llen >= Max_Length then
Result.Data (1 .. Max_Length) :=
Left (Left'First .. Left'First + (Max_Length - 1));
else
Result.Data (1 .. Llen) := Left;
Result.Data (Llen + 1 .. Max_Length) :=
Right.Data (1 .. Max_Length - Llen);
end if;
when Strings.Left =>
if Rlen >= Max_Length then
Result.Data (1 .. Max_Length) :=
Right.Data (Rlen - (Max_Length - 1) .. Rlen);
else
Result.Data (1 .. Max_Length - Rlen) :=
Left (Left'Last - (Max_Length - Rlen - 1) .. Left'Last);
Result.Data (Max_Length - Rlen + 1 .. Max_Length) :=
Right.Data (1 .. Rlen);
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end Super_Append;
-- Case of Super_String and Character
function Super_Append
(Left : Super_String;
Right : Character;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Left.Max_Length;
Result : Super_String (Max_Length);
Llen : constant Natural := Left.Current_Length;
begin
if Llen < Max_Length then
Result.Current_Length := Llen + 1;
Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
Result.Data (Llen + 1) := Right;
return Result;
else
case Drop is
when Strings.Right =>
return Left;
when Strings.Left =>
Result.Current_Length := Max_Length;
Result.Data (1 .. Max_Length - 1) :=
Left.Data (2 .. Max_Length);
Result.Data (Max_Length) := Right;
return Result;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Append;
procedure Super_Append
(Source : in out Super_String;
New_Item : Character;
Drop : Truncation := Error)
is
Max_Length : constant Positive := Source.Max_Length;
Llen : constant Natural := Source.Current_Length;
begin
if Llen < Max_Length then
Source.Current_Length := Llen + 1;
Source.Data (Llen + 1) := New_Item;
else
Source.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
null;
when Strings.Left =>
Source.Data (1 .. Max_Length - 1) :=
Source.Data (2 .. Max_Length);
Source.Data (Max_Length) := New_Item;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Append;
-- Case of Character and Super_String
function Super_Append
(Left : Character;
Right : Super_String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Right.Max_Length;
Result : Super_String (Max_Length);
Rlen : constant Natural := Right.Current_Length;
begin
if Rlen < Max_Length then
Result.Current_Length := Rlen + 1;
Result.Data (1) := Left;
Result.Data (2 .. Rlen + 1) := Right.Data (1 .. Rlen);
return Result;
else
case Drop is
when Strings.Right =>
Result.Current_Length := Max_Length;
Result.Data (1) := Left;
Result.Data (2 .. Max_Length) :=
Right.Data (1 .. Max_Length - 1);
return Result;
when Strings.Left =>
return Right;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Append;
-----------------
-- Super_Count --
-----------------
function Super_Count
(Source : Super_String;
Pattern : String;
Mapping : Maps.Character_Mapping := Maps.Identity)
return Natural
is
begin
return
Search.Count
(Source.Data (1 .. Source.Current_Length), Pattern, Mapping);
end Super_Count;
function Super_Count
(Source : Super_String;
Pattern : String;
Mapping : Maps.Character_Mapping_Function)
return Natural
is
begin
return
Search.Count
(Source.Data (1 .. Source.Current_Length), Pattern, Mapping);
end Super_Count;
function Super_Count
(Source : Super_String;
Set : Maps.Character_Set)
return Natural
is
begin
return Search.Count (Source.Data (1 .. Source.Current_Length), Set);
end Super_Count;
------------------
-- Super_Delete --
------------------
function Super_Delete
(Source : Super_String;
From : Positive;
Through : Natural)
return Super_String
is
Result : Super_String (Source.Max_Length);
Slen : constant Natural := Source.Current_Length;
Num_Delete : constant Integer := Through - From + 1;
begin
if Num_Delete <= 0 then
return Source;
elsif From > Slen + 1 then
raise Ada.Strings.Index_Error;
elsif Through >= Slen then
Result.Current_Length := From - 1;
Result.Data (1 .. From - 1) := Source.Data (1 .. From - 1);
return Result;
else
Result.Current_Length := Slen - Num_Delete;
Result.Data (1 .. From - 1) := Source.Data (1 .. From - 1);
Result.Data (From .. Result.Current_Length) :=
Source.Data (Through + 1 .. Slen);
return Result;
end if;
end Super_Delete;
procedure Super_Delete
(Source : in out Super_String;
From : Positive;
Through : Natural)
is
Slen : constant Natural := Source.Current_Length;
Num_Delete : constant Integer := Through - From + 1;
begin
if Num_Delete <= 0 then
return;
elsif From > Slen + 1 then
raise Ada.Strings.Index_Error;
elsif Through >= Slen then
Source.Current_Length := From - 1;
else
Source.Current_Length := Slen - Num_Delete;
Source.Data (From .. Source.Current_Length) :=
Source.Data (Through + 1 .. Slen);
end if;
end Super_Delete;
-------------------
-- Super_Element --
-------------------
function Super_Element
(Source : Super_String;
Index : Positive)
return Character
is
begin
if Index in 1 .. Source.Current_Length then
return Source.Data (Index);
else
raise Strings.Index_Error;
end if;
end Super_Element;
----------------------
-- Super_Find_Token --
----------------------
procedure Super_Find_Token
(Source : Super_String;
Set : Maps.Character_Set;
Test : Strings.Membership;
First : out Positive;
Last : out Natural)
is
begin
Search.Find_Token
(Source.Data (1 .. Source.Current_Length), Set, Test, First, Last);
end Super_Find_Token;
----------------
-- Super_Head --
----------------
function Super_Head
(Source : Super_String;
Count : Natural;
Pad : Character := Space;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Source.Max_Length;
Result : Super_String (Max_Length);
Slen : constant Natural := Source.Current_Length;
Npad : constant Integer := Count - Slen;
begin
if Npad <= 0 then
Result.Current_Length := Count;
Result.Data (1 .. Count) := Source.Data (1 .. Count);
elsif Count <= Max_Length then
Result.Current_Length := Count;
Result.Data (1 .. Slen) := Source.Data (1 .. Slen);
Result.Data (Slen + 1 .. Count) := (others => Pad);
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
Result.Data (1 .. Slen) := Source.Data (1 .. Slen);
Result.Data (Slen + 1 .. Max_Length) := (others => Pad);
when Strings.Left =>
if Npad >= Max_Length then
Result.Data := (others => Pad);
else
Result.Data (1 .. Max_Length - Npad) :=
Source.Data (Count - Max_Length + 1 .. Slen);
Result.Data (Max_Length - Npad + 1 .. Max_Length) :=
(others => Pad);
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end Super_Head;
procedure Super_Head
(Source : in out Super_String;
Count : Natural;
Pad : Character := Space;
Drop : Truncation := Error)
is
Max_Length : constant Positive := Source.Max_Length;
Slen : constant Natural := Source.Current_Length;
Npad : constant Integer := Count - Slen;
Temp : String (1 .. Max_Length);
begin
if Npad <= 0 then
Source.Current_Length := Count;
elsif Count <= Max_Length then
Source.Current_Length := Count;
Source.Data (Slen + 1 .. Count) := (others => Pad);
else
Source.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
Source.Data (Slen + 1 .. Max_Length) := (others => Pad);
when Strings.Left =>
if Npad > Max_Length then
Source.Data := (others => Pad);
else
Temp := Source.Data;
Source.Data (1 .. Max_Length - Npad) :=
Temp (Count - Max_Length + 1 .. Slen);
for J in Max_Length - Npad + 1 .. Max_Length loop
Source.Data (J) := Pad;
end loop;
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Head;
-----------------
-- Super_Index --
-----------------
function Super_Index
(Source : Super_String;
Pattern : String;
Going : Strings.Direction := Strings.Forward;
Mapping : Maps.Character_Mapping := Maps.Identity)
return Natural
is
begin
return Search.Index
(Source.Data (1 .. Source.Current_Length), Pattern, Going, Mapping);
end Super_Index;
function Super_Index
(Source : Super_String;
Pattern : String;
Going : Direction := Forward;
Mapping : Maps.Character_Mapping_Function)
return Natural
is
begin
return Search.Index
(Source.Data (1 .. Source.Current_Length), Pattern, Going, Mapping);
end Super_Index;
function Super_Index
(Source : Super_String;
Set : Maps.Character_Set;
Test : Strings.Membership := Strings.Inside;
Going : Strings.Direction := Strings.Forward)
return Natural
is
begin
return Search.Index
(Source.Data (1 .. Source.Current_Length), Set, Test, Going);
end Super_Index;
---------------------------
-- Super_Index_Non_Blank --
---------------------------
function Super_Index_Non_Blank
(Source : Super_String;
Going : Strings.Direction := Strings.Forward)
return Natural
is
begin
return
Search.Index_Non_Blank
(Source.Data (1 .. Source.Current_Length), Going);
end Super_Index_Non_Blank;
------------------
-- Super_Insert --
------------------
function Super_Insert
(Source : Super_String;
Before : Positive;
New_Item : String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Source.Max_Length;
Result : Super_String (Max_Length);
Slen : constant Natural := Source.Current_Length;
Nlen : constant Natural := New_Item'Length;
Tlen : constant Natural := Slen + Nlen;
Blen : constant Natural := Before - 1;
Alen : constant Integer := Slen - Blen;
Droplen : constant Integer := Tlen - Max_Length;
-- Tlen is the length of the total string before possible truncation.
-- Blen, Alen are the lengths of the before and after pieces of the
-- source string.
begin
if Alen < 0 then
raise Ada.Strings.Index_Error;
elsif Droplen <= 0 then
Result.Current_Length := Tlen;
Result.Data (1 .. Blen) := Source.Data (1 .. Blen);
Result.Data (Before .. Before + Nlen - 1) := New_Item;
Result.Data (Before + Nlen .. Tlen) :=
Source.Data (Before .. Slen);
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
Result.Data (1 .. Blen) := Source.Data (1 .. Blen);
if Droplen > Alen then
Result.Data (Before .. Max_Length) :=
New_Item (New_Item'First
.. New_Item'First + Max_Length - Before);
else
Result.Data (Before .. Before + Nlen - 1) := New_Item;
Result.Data (Before + Nlen .. Max_Length) :=
Source.Data (Before .. Slen - Droplen);
end if;
when Strings.Left =>
Result.Data (Max_Length - (Alen - 1) .. Max_Length) :=
Source.Data (Before .. Slen);
if Droplen >= Blen then
Result.Data (1 .. Max_Length - Alen) :=
New_Item (New_Item'Last - (Max_Length - Alen) + 1
.. New_Item'Last);
else
Result.Data
(Blen - Droplen + 1 .. Max_Length - Alen) :=
New_Item;
Result.Data (1 .. Blen - Droplen) :=
Source.Data (Droplen + 1 .. Blen);
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end Super_Insert;
procedure Super_Insert
(Source : in out Super_String;
Before : Positive;
New_Item : String;
Drop : Strings.Truncation := Strings.Error)
is
begin
-- We do a double copy here because this is one of the situations
-- in which we move data to the right, and at least at the moment,
-- GNAT is not handling such cases correctly ???
Source := Super_Insert (Source, Before, New_Item, Drop);
end Super_Insert;
------------------
-- Super_Length --
------------------
function Super_Length (Source : Super_String) return Natural is
begin
return Source.Current_Length;
end Super_Length;
---------------------
-- Super_Overwrite --
---------------------
function Super_Overwrite
(Source : Super_String;
Position : Positive;
New_Item : String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Source.Max_Length;
Result : Super_String (Max_Length);
Endpos : constant Natural := Position + New_Item'Length - 1;
Slen : constant Natural := Source.Current_Length;
Droplen : Natural;
begin
if Position > Slen + 1 then
raise Ada.Strings.Index_Error;
elsif New_Item'Length = 0 then
return Source;
elsif Endpos <= Slen then
Result.Current_Length := Source.Current_Length;
Result.Data (1 .. Slen) := Source.Data (1 .. Slen);
Result.Data (Position .. Endpos) := New_Item;
return Result;
elsif Endpos <= Max_Length then
Result.Current_Length := Endpos;
Result.Data (1 .. Position - 1) := Source.Data (1 .. Position - 1);
Result.Data (Position .. Endpos) := New_Item;
return Result;
else
Result.Current_Length := Max_Length;
Droplen := Endpos - Max_Length;
case Drop is
when Strings.Right =>
Result.Data (1 .. Position - 1) :=
Source.Data (1 .. Position - 1);
Result.Data (Position .. Max_Length) :=
New_Item (New_Item'First .. New_Item'Last - Droplen);
return Result;
when Strings.Left =>
if New_Item'Length >= Max_Length then
Result.Data (1 .. Max_Length) :=
New_Item (New_Item'Last - Max_Length + 1 ..
New_Item'Last);
return Result;
else
Result.Data (1 .. Max_Length - New_Item'Length) :=
Source.Data (Droplen + 1 .. Position - 1);
Result.Data
(Max_Length - New_Item'Length + 1 .. Max_Length) :=
New_Item;
return Result;
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Overwrite;
procedure Super_Overwrite
(Source : in out Super_String;
Position : Positive;
New_Item : String;
Drop : Strings.Truncation := Strings.Error)
is
Max_Length : constant Positive := Source.Max_Length;
Endpos : constant Positive := Position + New_Item'Length - 1;
Slen : constant Natural := Source.Current_Length;
Droplen : Natural;
begin
if Position > Slen + 1 then
raise Ada.Strings.Index_Error;
elsif Endpos <= Slen then
Source.Data (Position .. Endpos) := New_Item;
elsif Endpos <= Max_Length then
Source.Data (Position .. Endpos) := New_Item;
Source.Current_Length := Endpos;
else
Source.Current_Length := Max_Length;
Droplen := Endpos - Max_Length;
case Drop is
when Strings.Right =>
Source.Data (Position .. Max_Length) :=
New_Item (New_Item'First .. New_Item'Last - Droplen);
when Strings.Left =>
if New_Item'Length > Max_Length then
Source.Data (1 .. Max_Length) :=
New_Item (New_Item'Last - Max_Length + 1 ..
New_Item'Last);
else
Source.Data (1 .. Max_Length - New_Item'Length) :=
Source.Data (Droplen + 1 .. Position - 1);
Source.Data
(Max_Length - New_Item'Length + 1 .. Max_Length) :=
New_Item;
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Overwrite;
---------------------------
-- Super_Replace_Element --
---------------------------
procedure Super_Replace_Element
(Source : in out Super_String;
Index : Positive;
By : Character)
is
begin
if Index <= Source.Current_Length then
Source.Data (Index) := By;
else
raise Ada.Strings.Index_Error;
end if;
end Super_Replace_Element;
-------------------------
-- Super_Replace_Slice --
-------------------------
function Super_Replace_Slice
(Source : Super_String;
Low : Positive;
High : Natural;
By : String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Source.Max_Length;
Slen : constant Natural := Source.Current_Length;
begin
if Low > Slen + 1 then
raise Strings.Index_Error;
elsif High < Low then
return Super_Insert (Source, Low, By, Drop);
else
declare
Blen : constant Natural := Natural'Max (0, Low - 1);
Alen : constant Natural := Natural'Max (0, Slen - High);
Tlen : constant Natural := Blen + By'Length + Alen;
Droplen : constant Integer := Tlen - Max_Length;
Result : Super_String (Max_Length);
-- Tlen is the total length of the result string before any
-- truncation. Blen and Alen are the lengths of the pieces
-- of the original string that end up in the result string
-- before and after the replaced slice.
begin
if Droplen <= 0 then
Result.Current_Length := Tlen;
Result.Data (1 .. Blen) := Source.Data (1 .. Blen);
Result.Data (Low .. Low + By'Length - 1) := By;
Result.Data (Low + By'Length .. Tlen) :=
Source.Data (High + 1 .. Slen);
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
Result.Data (1 .. Blen) := Source.Data (1 .. Blen);
if Droplen > Alen then
Result.Data (Low .. Max_Length) :=
By (By'First .. By'First + Max_Length - Low);
else
Result.Data (Low .. Low + By'Length - 1) := By;
Result.Data (Low + By'Length .. Max_Length) :=
Source.Data (High + 1 .. Slen - Droplen);
end if;
when Strings.Left =>
Result.Data (Max_Length - (Alen - 1) .. Max_Length) :=
Source.Data (High + 1 .. Slen);
if Droplen >= Blen then
Result.Data (1 .. Max_Length - Alen) :=
By (By'Last - (Max_Length - Alen) + 1 .. By'Last);
else
Result.Data
(Blen - Droplen + 1 .. Max_Length - Alen) := By;
Result.Data (1 .. Blen - Droplen) :=
Source.Data (Droplen + 1 .. Blen);
end if;
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end;
end if;
end Super_Replace_Slice;
procedure Super_Replace_Slice
(Source : in out Super_String;
Low : Positive;
High : Natural;
By : String;
Drop : Strings.Truncation := Strings.Error)
is
begin
-- We do a double copy here because this is one of the situations
-- in which we move data to the right, and at least at the moment,
-- GNAT is not handling such cases correctly ???
Source := Super_Replace_Slice (Source, Low, High, By, Drop);
end Super_Replace_Slice;
---------------------
-- Super_Replicate --
---------------------
function Super_Replicate
(Count : Natural;
Item : Character;
Drop : Truncation := Error;
Max_Length : Positive)
return Super_String
is
Result : Super_String (Max_Length);
begin
if Count <= Max_Length then
Result.Current_Length := Count;
elsif Drop = Strings.Error then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Max_Length;
end if;
Result.Data (1 .. Result.Current_Length) := (others => Item);
return Result;
end Super_Replicate;
function Super_Replicate
(Count : Natural;
Item : String;
Drop : Truncation := Error;
Max_Length : Positive)
return Super_String
is
Length : constant Integer := Count * Item'Length;
Result : Super_String (Max_Length);
Indx : Positive;
begin
if Length <= Max_Length then
Result.Current_Length := Length;
if Length > 0 then
Indx := 1;
for J in 1 .. Count loop
Result.Data (Indx .. Indx + Item'Length - 1) := Item;
Indx := Indx + Item'Length;
end loop;
end if;
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
Indx := 1;
while Indx + Item'Length <= Max_Length + 1 loop
Result.Data (Indx .. Indx + Item'Length - 1) := Item;
Indx := Indx + Item'Length;
end loop;
Result.Data (Indx .. Max_Length) :=
Item (Item'First .. Item'First + Max_Length - Indx);
when Strings.Left =>
Indx := Max_Length;
while Indx - Item'Length >= 1 loop
Result.Data (Indx - (Item'Length - 1) .. Indx) := Item;
Indx := Indx - Item'Length;
end loop;
Result.Data (1 .. Indx) :=
Item (Item'Last - Indx + 1 .. Item'Last);
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end Super_Replicate;
function Super_Replicate
(Count : Natural;
Item : Super_String;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
begin
return
Super_Replicate
(Count,
Item.Data (1 .. Item.Current_Length),
Drop,
Item.Max_Length);
end Super_Replicate;
-----------------
-- Super_Slice --
-----------------
function Super_Slice
(Source : Super_String;
Low : Positive;
High : Natural)
return String
is
begin
-- Note: test of High > Length is in accordance with AI95-00128
if Low > Source.Current_Length + 1
or else High > Source.Current_Length
then
raise Index_Error;
else
return Source.Data (Low .. High);
end if;
end Super_Slice;
----------------
-- Super_Tail --
----------------
function Super_Tail
(Source : Super_String;
Count : Natural;
Pad : Character := Space;
Drop : Strings.Truncation := Strings.Error)
return Super_String
is
Max_Length : constant Positive := Source.Max_Length;
Result : Super_String (Max_Length);
Slen : constant Natural := Source.Current_Length;
Npad : constant Integer := Count - Slen;
begin
if Npad <= 0 then
Result.Current_Length := Count;
Result.Data (1 .. Count) :=
Source.Data (Slen - (Count - 1) .. Slen);
elsif Count <= Max_Length then
Result.Current_Length := Count;
Result.Data (1 .. Npad) := (others => Pad);
Result.Data (Npad + 1 .. Count) := Source.Data (1 .. Slen);
else
Result.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
if Npad >= Max_Length then
Result.Data := (others => Pad);
else
Result.Data (1 .. Npad) := (others => Pad);
Result.Data (Npad + 1 .. Max_Length) :=
Source.Data (1 .. Max_Length - Npad);
end if;
when Strings.Left =>
Result.Data (1 .. Max_Length - Slen) := (others => Pad);
Result.Data (Max_Length - Slen + 1 .. Max_Length) :=
Source.Data (1 .. Slen);
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end Super_Tail;
procedure Super_Tail
(Source : in out Super_String;
Count : Natural;
Pad : Character := Space;
Drop : Truncation := Error)
is
Max_Length : constant Positive := Source.Max_Length;
Slen : constant Natural := Source.Current_Length;
Npad : constant Integer := Count - Slen;
Temp : constant String (1 .. Max_Length) := Source.Data;
begin
if Npad <= 0 then
Source.Current_Length := Count;
Source.Data (1 .. Count) :=
Temp (Slen - (Count - 1) .. Slen);
elsif Count <= Max_Length then
Source.Current_Length := Count;
Source.Data (1 .. Npad) := (others => Pad);
Source.Data (Npad + 1 .. Count) := Temp (1 .. Slen);
else
Source.Current_Length := Max_Length;
case Drop is
when Strings.Right =>
if Npad >= Max_Length then
Source.Data := (others => Pad);
else
Source.Data (1 .. Npad) := (others => Pad);
Source.Data (Npad + 1 .. Max_Length) :=
Temp (1 .. Max_Length - Npad);
end if;
when Strings.Left =>
for J in 1 .. Max_Length - Slen loop
Source.Data (J) := Pad;
end loop;
Source.Data (Max_Length - Slen + 1 .. Max_Length) :=
Temp (1 .. Slen);
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
end Super_Tail;
---------------------
-- Super_To_String --
---------------------
function Super_To_String (Source : in Super_String) return String is
begin
return Source.Data (1 .. Source.Current_Length);
end Super_To_String;
---------------------
-- Super_Translate --
---------------------
function Super_Translate
(Source : Super_String;
Mapping : Maps.Character_Mapping)
return Super_String
is
Result : Super_String (Source.Max_Length);
begin
Result.Current_Length := Source.Current_Length;
for J in 1 .. Source.Current_Length loop
Result.Data (J) := Value (Mapping, Source.Data (J));
end loop;
return Result;
end Super_Translate;
procedure Super_Translate
(Source : in out Super_String;
Mapping : Maps.Character_Mapping)
is
begin
for J in 1 .. Source.Current_Length loop
Source.Data (J) := Value (Mapping, Source.Data (J));
end loop;
end Super_Translate;
function Super_Translate
(Source : Super_String;
Mapping : Maps.Character_Mapping_Function)
return Super_String
is
Result : Super_String (Source.Max_Length);
begin
Result.Current_Length := Source.Current_Length;
for J in 1 .. Source.Current_Length loop
Result.Data (J) := Mapping.all (Source.Data (J));
end loop;
return Result;
end Super_Translate;
procedure Super_Translate
(Source : in out Super_String;
Mapping : Maps.Character_Mapping_Function)
is
begin
for J in 1 .. Source.Current_Length loop
Source.Data (J) := Mapping.all (Source.Data (J));
end loop;
end Super_Translate;
----------------
-- Super_Trim --
----------------
function Super_Trim (Source : Super_String; Side : Trim_End)
return Super_String
is
Result : Super_String (Source.Max_Length);
Last : Natural := Source.Current_Length;
First : Positive := 1;
begin
if Side = Left or else Side = Both then
while First <= Last and then Source.Data (First) = ' ' loop
First := First + 1;
end loop;
end if;
if Side = Right or else Side = Both then
while Last >= First and then Source.Data (Last) = ' ' loop
Last := Last - 1;
end loop;
end if;
Result.Current_Length := Last - First + 1;
Result.Data (1 .. Result.Current_Length) := Source.Data (First .. Last);
return Result;
end Super_Trim;
procedure Super_Trim
(Source : in out Super_String;
Side : Trim_End)
is
Max_Length : constant Positive := Source.Max_Length;
Last : Natural := Source.Current_Length;
First : Positive := 1;
Temp : String (1 .. Max_Length);
begin
Temp (1 .. Last) := Source.Data (1 .. Last);
if Side = Left or else Side = Both then
while First <= Last and then Temp (First) = ' ' loop
First := First + 1;
end loop;
end if;
if Side = Right or else Side = Both then
while Last >= First and then Temp (Last) = ' ' loop
Last := Last - 1;
end loop;
end if;
Source.Data := (others => ASCII.NUL);
Source.Current_Length := Last - First + 1;
Source.Data (1 .. Source.Current_Length) := Temp (First .. Last);
end Super_Trim;
function Super_Trim
(Source : Super_String;
Left : Maps.Character_Set;
Right : Maps.Character_Set)
return Super_String
is
Result : Super_String (Source.Max_Length);
begin
for First in 1 .. Source.Current_Length loop
if not Is_In (Source.Data (First), Left) then
for Last in reverse First .. Source.Current_Length loop
if not Is_In (Source.Data (Last), Right) then
Result.Current_Length := Last - First + 1;
Result.Data (1 .. Result.Current_Length) :=
Source.Data (First .. Last);
return Result;
end if;
end loop;
end if;
end loop;
Result.Current_Length := 0;
return Result;
end Super_Trim;
procedure Super_Trim
(Source : in out Super_String;
Left : Maps.Character_Set;
Right : Maps.Character_Set)
is
begin
for First in 1 .. Source.Current_Length loop
if not Is_In (Source.Data (First), Left) then
for Last in reverse First .. Source.Current_Length loop
if not Is_In (Source.Data (Last), Right) then
if First = 1 then
Source.Current_Length := Last;
return;
else
Source.Current_Length := Last - First + 1;
Source.Data (1 .. Source.Current_Length) :=
Source.Data (First .. Last);
for J in Source.Current_Length + 1 ..
Source.Max_Length
loop
Source.Data (J) := ASCII.NUL;
end loop;
return;
end if;
end if;
end loop;
Source.Current_Length := 0;
return;
end if;
end loop;
Source.Current_Length := 0;
end Super_Trim;
-----------
-- Times --
-----------
function Times
(Left : Natural;
Right : Character;
Max_Length : Positive)
return Super_String
is
Result : Super_String (Max_Length);
begin
if Left > Max_Length then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Left;
for J in 1 .. Left loop
Result.Data (J) := Right;
end loop;
end if;
return Result;
end Times;
function Times
(Left : Natural;
Right : String;
Max_Length : Positive)
return Super_String
is
Result : Super_String (Max_Length);
Pos : Positive := 1;
Rlen : constant Natural := Right'Length;
Nlen : constant Natural := Left * Rlen;
begin
if Nlen > Max_Length then
raise Ada.Strings.Index_Error;
else
Result.Current_Length := Nlen;
if Nlen > 0 then
for J in 1 .. Left loop
Result.Data (Pos .. Pos + Rlen - 1) := Right;
Pos := Pos + Rlen;
end loop;
end if;
end if;
return Result;
end Times;
function Times
(Left : Natural;
Right : Super_String)
return Super_String
is
Result : Super_String (Right.Max_Length);
Pos : Positive := 1;
Rlen : constant Natural := Right.Current_Length;
Nlen : constant Natural := Left * Rlen;
begin
if Nlen > Right.Max_Length then
raise Ada.Strings.Length_Error;
else
Result.Current_Length := Nlen;
if Nlen > 0 then
for J in 1 .. Left loop
Result.Data (Pos .. Pos + Rlen - 1) :=
Right.Data (1 .. Rlen);
Pos := Pos + Rlen;
end loop;
end if;
end if;
return Result;
end Times;
---------------------
-- To_Super_String --
---------------------
function To_Super_String
(Source : String;
Max_Length : Natural;
Drop : Truncation := Error)
return Super_String
is
Result : Super_String (Max_Length);
Slen : constant Natural := Source'Length;
begin
if Slen <= Max_Length then
Result.Current_Length := Slen;
Result.Data (1 .. Slen) := Source;
else
case Drop is
when Strings.Right =>
Result.Current_Length := Max_Length;
Result.Data (1 .. Max_Length) :=
Source (Source'First .. Source'First - 1 + Max_Length);
when Strings.Left =>
Result.Current_Length := Max_Length;
Result.Data (1 .. Max_Length) :=
Source (Source'Last - (Max_Length - 1) .. Source'Last);
when Strings.Error =>
raise Ada.Strings.Length_Error;
end case;
end if;
return Result;
end To_Super_String;
end Ada.Strings.Superbounded;