1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378 | --
-- Copyright (C) 2014-2022, AdaCore
-- SPDX-License-Identifier: Apache-2.0
--
with Ada.Containers.Generic_Array_Sort;
with System; use System;
with System.Memory; use System.Memory;
-----------------------------
-- Gpr_Parser_Support.Vectors --
-----------------------------
package body Gpr_Parser_Support.Vectors is
El_Size : constant size_t := Elements_Array'Component_Size / Storage_Unit;
--------------
-- Is_Empty --
--------------
function Is_Empty (Self : Vector) return Boolean is
begin
return Self.Size = 0;
end Is_Empty;
-------------
-- Reserve --
-------------
procedure Reserve (Self : in out Vector; Capacity : Natural) is
Siz : constant size_t := size_t (Capacity) * El_Size;
begin
if Small_Vector_Capacity > 0
and then Self.Capacity = Small_Vector_Capacity
then
-- We have an inline small vector, and we're still using it
-- If the small vector has capacity, then Reserve is a no-op
if Capacity <= Self.Capacity then
return;
end if;
-- The small vector is smaller than the required capacity. So we'll
-- allocate and transfer the items from the small vector to the
-- dynamically allocated one.
Self.E := To_Pointer (Alloc (Siz));
for I in Self.SV'Range loop
Self.E.all (I) := Self.SV (I);
end loop;
else
-- We don't want to alloc/realloc any space if ``Capacity`` is
-- smaller than the current capacity.
if Capacity <= Self.Capacity then
return;
end if;
if Self.E = null then
-- E is null: First alloc
Self.E := To_Pointer (Alloc (Siz));
else
-- E is not null: realloc
Self.E := To_Pointer (Realloc (Self.E.all'Address, Siz));
end if;
end if;
Self.Capacity := Capacity;
end Reserve;
------------
-- Append --
------------
procedure Append (Self : in out Vector; Element : Element_Type) is
begin
if Self.Capacity = Self.Size then
Reserve (Self, (Self.Capacity * 2) + 1);
end if;
Self.Size := Self.Size + 1;
declare
Index : constant Index_Type := Last_Index (Self);
begin
if Small_Vector_Capacity = 0 then
Self.E.all (Index) := Element;
else
if Self.Capacity = Small_Vector_Capacity then
Self.SV (Index) := Element;
else
Self.E.all (Index) := Element;
end if;
end if;
end;
end Append;
------------
-- Concat --
------------
procedure Concat (Self : in out Vector; Elements : Elements_Array) is
begin
for El of Elements loop
Self.Append (El);
end loop;
end Concat;
------------
-- Concat --
------------
procedure Concat (Self : in out Vector; Elements : Vector) is
begin
Self.Reserve (Self.Length + Elements.Length);
for I in Elements.First_Index .. Elements.Last_Index loop
Self.Append (Elements.Get (I));
end loop;
end Concat;
---------------
-- Remove_At --
---------------
procedure Remove_At (Self : in out Vector; Index : Index_Type) is
begin
for I in Index .. Self.Length - 1 loop
Set (Self, I, Get (Self, I + 1));
end loop;
Pop (Self);
end Remove_At;
---------
-- Get --
---------
function Get
(Self : Vector; Index : Iteration_Index_Type) return Element_Type
is
begin
if Index > Self.Size then
raise Constraint_Error with "Out of bound access";
end if;
if Small_Vector_Capacity = 0 then
return Self.E (Index);
else
if Self.Capacity = Small_Vector_Capacity then
return Self.SV (Index);
else
return Self.E (Index);
end if;
end if;
end Get;
---------
-- Set --
---------
procedure Set (Self : in out Vector; Index : Index_Type; E : Element_Type)
is
begin
if Small_Vector_Capacity = 0 then
Self.E (Index) := E;
else
if Self.Capacity = Small_Vector_Capacity then
Self.SV (Index) := E;
else
Self.E (Index) := E;
end if;
end if;
end Set;
----------------
-- Get_Access --
----------------
function Get_Access
(Self : Vector; Index : Index_Type) return Element_Access
is
begin
if Small_Vector_Capacity = 0 then
return Self.E (Index)'Unrestricted_Access;
else
if Self.Capacity = Small_Vector_Capacity then
return Self.SV (Index)'Unrestricted_Access;
else
return Self.E (Index)'Unrestricted_Access;
end if;
end if;
end Get_Access;
-------------
-- Destroy --
-------------
procedure Destroy (Self : in out Vector) is
begin
Free (Self.E);
end Destroy;
-----------
-- Clear --
-----------
procedure Clear (Self : in out Vector) is
begin
Self.Size := 0;
end Clear;
---------
-- Pop --
---------
function Pop (Self : in out Vector) return Element_Type is
Index : constant Index_Type := Last_Index (Self);
Res : constant Element_Type := Get (Self, Index);
begin
Self.Size := Self.Size - 1;
return Res;
end Pop;
---------
-- Pop --
---------
procedure Pop (Self : in out Vector) is
Discard : constant Element_Type := Pop (Self);
begin
null;
end Pop;
---------
-- Cut --
---------
procedure Cut (Self : in out Vector; Index : Iteration_Index_Type) is
begin
Self.Size := Index;
end Cut;
---------
-- Pop --
---------
function Pop (Self : in out Vector; N : Index_Type) return Element_Type is
Result : constant Element_Type := Self.Get (N);
begin
Self.Set (N, Self.Last_Element);
Self.Size := Self.Size - 1;
return Result;
end Pop;
---------
-- Pop --
---------
procedure Pop (Self : in out Vector; N : Index_Type) is
Discard : constant Element_Type := Self.Pop (N);
begin
null;
end Pop;
-------------------
-- First_Element --
-------------------
function First_Element (Self : Vector) return Element_Type
is (Get (Self, First_Index (Self)));
------------------
-- Last_Element --
------------------
function Last_Element (Self : Vector) return Element_Type
is
begin
return Get (Self, Last_Index (Self));
end Last_Element;
------------------
-- Last_Element --
------------------
function Last_Element (Self : Vector) return Element_Access
is
begin
return Get_Access (Self, Last_Index (Self));
end Last_Element;
------------
-- Length --
------------
function Length (Self : Vector) return Natural is (Self.Size);
-----------
-- Slice --
-----------
function Slice
(Self : Vector; First, Last : Natural) return Elements_Array
is
begin
if Small_Vector_Capacity = 0 then
return Self.E (First .. Last);
else
if Self.Capacity = Small_Vector_Capacity then
return Self.SV (First .. Last);
else
return Self.E (First .. Last);
end if;
end if;
end Slice;
--------------
-- To_Array --
--------------
function To_Array
(Self : Vector) return Elements_Array
is
begin
if Self.Size = 0 then
return Empty_Array;
else
return Slice (Self, First_Index (Self), Last_Index (Self));
end if;
end To_Array;
-----------
-- Image --
-----------
function Image (Self : Vector) return String is
function Image (Self : Vector; I : Index_Type) return String
is
(if I < Last_Index (Self)
then Image (Get (Self, I)) & ", " & Image (Self, I + 1)
else Image (Get (Self, I)));
begin
return "[" & (if Self.Size > 0
then Image (Self, First_Index (Self))
else "") & "]";
end Image;
----------
-- Copy --
----------
function Copy (Self : Vector) return Vector is
N : Vector;
begin
if Self.Length > 0 then
N.Reserve (Self.Length);
end if;
for El of Self loop
N.Append (El);
end loop;
return N;
end Copy;
------------------
-- Generic_Sort --
------------------
procedure Generic_Sort (Self : in out Vector) is
procedure Sort is new Ada.Containers.Generic_Array_Sort
(Positive, Element_Type, Elements_Array, "<");
begin
if Self.Capacity = Small_Vector_Capacity then
Sort (Self.SV (1 .. Self.Size));
else
Sort (Self.E.all (1 .. Self.Size));
end if;
end Generic_Sort;
end Gpr_Parser_Support.Vectors;
|