1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
5 -- G N A T . A R R A Y _ S P L I T --
9 -- Copyright (C) 2002-2013, Free Software Foundation, Inc. --
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. --
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. --
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/>. --
27 -- GNAT was originally developed by the GNAT team at New York University. --
28 -- Extensive contributions were provided by Ada Core Technologies Inc. --
30 ------------------------------------------------------------------------------
32 with Ada.Unchecked_Deallocation;
34 package body GNAT.Array_Split is
37 new Ada.Unchecked_Deallocation (Slices_Indexes, Slices_Access);
40 new Ada.Unchecked_Deallocation (Separators_Indexes, Indexes_Access);
43 (Source : Element_Sequence;
44 Pattern : Element_Set) return Natural;
45 -- Returns the number of occurrences of Pattern elements in Source, 0 is
46 -- returned if no occurrence is found in Source.
52 procedure Adjust (S : in out Slice_Set) is
54 S.D.Ref_Counter := S.D.Ref_Counter + 1;
63 From : Element_Sequence;
64 Separators : Element_Sequence;
65 Mode : Separator_Mode := Single)
68 Create (S, From, To_Set (Separators), Mode);
77 From : Element_Sequence;
78 Separators : Element_Set;
79 Mode : Separator_Mode := Single)
83 Result.D.Source := new Element_Sequence'(From);
84 Set (Result, Separators, Mode);
93 (Source : Element_Sequence;
94 Pattern : Element_Set) return Natural
98 for K in Source'Range loop
99 if Is_In (Source (K), Pattern) then
111 procedure Finalize (S : in out Slice_Set) is
114 new Ada.Unchecked_Deallocation (Element_Sequence, Element_Access);
117 new Ada.Unchecked_Deallocation (Data, Data_Access);
119 D : Data_Access := S.D;
122 -- Ensure call is idempotent
127 D.Ref_Counter := D.Ref_Counter - 1;
129 if D.Ref_Counter = 0 then
142 procedure Initialize (S : in out Slice_Set) is
144 S.D := new Data'(1, null, 0, null, null);
153 Index : Slice_Number) return Slice_Separators
156 if Index > S.D.N_Slice then
160 or else (Index = 1 and then S.D.N_Slice = 1)
162 -- Whole string, or no separator used
164 return (Before => Array_End,
168 return (Before => Array_End,
169 After => S.D.Source (S.D.Slices (Index).Stop + 1));
171 elsif Index = S.D.N_Slice then
172 return (Before => S.D.Source (S.D.Slices (Index).Start - 1),
176 return (Before => S.D.Source (S.D.Slices (Index).Start - 1),
177 After => S.D.Source (S.D.Slices (Index).Stop + 1));
185 function Separators (S : Slice_Set) return Separators_Indexes is
187 return S.D.Indexes.all;
195 (S : in out Slice_Set;
196 Separators : Element_Sequence;
197 Mode : Separator_Mode := Single)
200 Set (S, To_Set (Separators), Mode);
208 (S : in out Slice_Set;
209 Separators : Element_Set;
210 Mode : Separator_Mode := Single)
213 procedure Copy_On_Write (S : in out Slice_Set);
214 -- Make a copy of S if shared with another variable
220 procedure Copy_On_Write (S : in out Slice_Set) is
222 if S.D.Ref_Counter > 1 then
223 -- First let's remove our count from the current data
225 S.D.Ref_Counter := S.D.Ref_Counter - 1;
227 -- Then duplicate the data
229 S.D := new Data'(S.D.all);
230 S.D.Ref_Counter := 1;
232 if S.D.Source /= null then
233 S.D.Source := new Element_Sequence'(S.D.Source.all);
239 -- If there is a single reference to this variable, free it now
240 -- as it will be redefined below.
247 Count_Sep : constant Natural := Count (S.D.Source.all, Separators);
253 -- Compute all separator's indexes
255 S.D.Indexes := new Separators_Indexes (1 .. Count_Sep);
256 J := S.D.Indexes'First;
258 for K in S.D.Source'Range loop
259 if Is_In (S.D.Source (K), Separators) then
260 S.D.Indexes (J) := K;
265 -- Compute slice info for fast slice access
268 S_Info : Slices_Indexes (1 .. Slice_Number (Count_Sep) + 1);
270 Start, Stop : Natural;
275 Start := S.D.Source'First;
279 if K > Count_Sep then
281 -- No more separators, last slice ends at end of source string
283 Stop := S.D.Source'Last;
286 Stop := S.D.Indexes (K) - 1;
289 -- Add slice to the table
291 S.D.N_Slice := S.D.N_Slice + 1;
292 S_Info (S.D.N_Slice) := (Start, Stop);
294 exit when K > Count_Sep;
300 -- In this mode just set start to character next to the
301 -- current separator, advance the separator index.
303 Start := S.D.Indexes (K) + 1;
308 -- In this mode skip separators following each other
311 Start := S.D.Indexes (K) + 1;
313 exit when K > Count_Sep
314 or else S.D.Indexes (K) > S.D.Indexes (K - 1) + 1;
320 S.D.Slices := new Slices_Indexes'(S_Info (1 .. S.D.N_Slice));
330 Index : Slice_Number) return Element_Sequence
334 return S.D.Source.all;
336 elsif Index > S.D.N_Slice then
341 S.D.Source (S.D.Slices (Index).Start .. S.D.Slices (Index).Stop);
349 function Slice_Count (S : Slice_Set) return Slice_Number is
354 end GNAT.Array_Split;