|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT RUN-TIME COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- A D A . S T R I N G S . W I D E _ M A P S --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
|
9 -- Copyright (C) 1992-2017, Free Software Foundation, Inc. --
|
|
|
10 -- --
|
|
|
11 -- This specification is derived from the Ada Reference Manual for use with --
|
|
|
12 -- GNAT. The copyright notice above, and the license provisions that follow --
|
|
|
13 -- apply solely to the contents of the part following the private keyword. --
|
|
|
14 -- --
|
|
|
15 -- GNAT is free software; you can redistribute it and/or modify it under --
|
|
|
16 -- terms of the GNU General Public License as published by the Free Soft- --
|
|
|
17 -- ware Foundation; either version 3, or (at your option) any later ver- --
|
|
|
18 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
|
|
19 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
|
|
20 -- or FITNESS FOR A PARTICULAR PURPOSE. --
|
|
|
21 -- --
|
|
|
22 -- As a special exception under Section 7 of GPL version 3, you are granted --
|
|
|
23 -- additional permissions described in the GCC Runtime Library Exception, --
|
|
|
24 -- version 3.1, as published by the Free Software Foundation. --
|
|
|
25 -- --
|
|
|
26 -- You should have received a copy of the GNU General Public License and --
|
|
|
27 -- a copy of the GCC Runtime Library Exception along with this program; --
|
|
|
28 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
|
|
|
29 -- <http://www.gnu.org/licenses/>. --
|
|
|
30 -- --
|
|
|
31 -- GNAT was originally developed by the GNAT team at New York University. --
|
|
|
32 -- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
|
33 -- --
|
|
|
34 ------------------------------------------------------------------------------
|
|
|
35
|
|
|
36 with Ada.Finalization;
|
|
|
37
|
|
|
38 package Ada.Strings.Wide_Maps is
|
|
|
39 pragma Preelaborate;
|
|
|
40
|
|
|
41 -------------------------------------
|
|
|
42 -- Wide Character Set Declarations --
|
|
|
43 -------------------------------------
|
|
|
44
|
|
|
45 type Wide_Character_Set is private;
|
|
|
46 pragma Preelaborable_Initialization (Wide_Character_Set);
|
|
|
47 -- Representation for a set of Wide_Character values:
|
|
|
48
|
|
|
49 Null_Set : constant Wide_Character_Set;
|
|
|
50
|
|
|
51 ------------------------------------------
|
|
|
52 -- Constructors for Wide Character Sets --
|
|
|
53 ------------------------------------------
|
|
|
54
|
|
|
55 type Wide_Character_Range is record
|
|
|
56 Low : Wide_Character;
|
|
|
57 High : Wide_Character;
|
|
|
58 end record;
|
|
|
59 -- Represents Wide_Character range Low .. High
|
|
|
60
|
|
|
61 type Wide_Character_Ranges is
|
|
|
62 array (Positive range <>) of Wide_Character_Range;
|
|
|
63
|
|
|
64 function To_Set
|
|
|
65 (Ranges : Wide_Character_Ranges) return Wide_Character_Set;
|
|
|
66
|
|
|
67 function To_Set
|
|
|
68 (Span : Wide_Character_Range) return Wide_Character_Set;
|
|
|
69
|
|
|
70 function To_Ranges
|
|
|
71 (Set : Wide_Character_Set) return Wide_Character_Ranges;
|
|
|
72
|
|
|
73 ---------------------------------------
|
|
|
74 -- Operations on Wide Character Sets --
|
|
|
75 ---------------------------------------
|
|
|
76
|
|
|
77 function "=" (Left, Right : Wide_Character_Set) return Boolean;
|
|
|
78
|
|
|
79 function "not"
|
|
|
80 (Right : Wide_Character_Set) return Wide_Character_Set;
|
|
|
81
|
|
|
82 function "and"
|
|
|
83 (Left, Right : Wide_Character_Set) return Wide_Character_Set;
|
|
|
84
|
|
|
85 function "or"
|
|
|
86 (Left, Right : Wide_Character_Set) return Wide_Character_Set;
|
|
|
87
|
|
|
88 function "xor"
|
|
|
89 (Left, Right : Wide_Character_Set) return Wide_Character_Set;
|
|
|
90
|
|
|
91 function "-"
|
|
|
92 (Left, Right : Wide_Character_Set) return Wide_Character_Set;
|
|
|
93
|
|
|
94 function Is_In
|
|
|
95 (Element : Wide_Character;
|
|
|
96 Set : Wide_Character_Set) return Boolean;
|
|
|
97
|
|
|
98 function Is_Subset
|
|
|
99 (Elements : Wide_Character_Set;
|
|
|
100 Set : Wide_Character_Set) return Boolean;
|
|
|
101
|
|
|
102 function "<="
|
|
|
103 (Left : Wide_Character_Set;
|
|
|
104 Right : Wide_Character_Set) return Boolean
|
|
|
105 renames Is_Subset;
|
|
|
106
|
|
|
107 subtype Wide_Character_Sequence is Wide_String;
|
|
|
108 -- Alternative representation for a set of character values
|
|
|
109
|
|
|
110 function To_Set
|
|
|
111 (Sequence : Wide_Character_Sequence) return Wide_Character_Set;
|
|
|
112
|
|
|
113 function To_Set
|
|
|
114 (Singleton : Wide_Character) return Wide_Character_Set;
|
|
|
115
|
|
|
116 function To_Sequence
|
|
|
117 (Set : Wide_Character_Set) return Wide_Character_Sequence;
|
|
|
118
|
|
|
119 -----------------------------------------
|
|
|
120 -- Wide Character Mapping Declarations --
|
|
|
121 -----------------------------------------
|
|
|
122
|
|
|
123 type Wide_Character_Mapping is private;
|
|
|
124 pragma Preelaborable_Initialization (Wide_Character_Mapping);
|
|
|
125 -- Representation for a wide character to wide character mapping:
|
|
|
126
|
|
|
127 function Value
|
|
|
128 (Map : Wide_Character_Mapping;
|
|
|
129 Element : Wide_Character) return Wide_Character;
|
|
|
130
|
|
|
131 Identity : constant Wide_Character_Mapping;
|
|
|
132
|
|
|
133 ---------------------------------
|
|
|
134 -- Operations on Wide Mappings --
|
|
|
135 ---------------------------------
|
|
|
136
|
|
|
137 function To_Mapping
|
|
|
138 (From, To : Wide_Character_Sequence) return Wide_Character_Mapping;
|
|
|
139
|
|
|
140 function To_Domain
|
|
|
141 (Map : Wide_Character_Mapping) return Wide_Character_Sequence;
|
|
|
142
|
|
|
143 function To_Range
|
|
|
144 (Map : Wide_Character_Mapping) return Wide_Character_Sequence;
|
|
|
145
|
|
|
146 type Wide_Character_Mapping_Function is
|
|
|
147 access function (From : Wide_Character) return Wide_Character;
|
|
|
148
|
|
|
149 private
|
|
|
150 package AF renames Ada.Finalization;
|
|
|
151
|
|
|
152 ------------------------------------------
|
|
|
153 -- Representation of Wide_Character_Set --
|
|
|
154 ------------------------------------------
|
|
|
155
|
|
|
156 -- A wide character set is represented as a sequence of wide character
|
|
|
157 -- ranges (i.e. an object of type Wide_Character_Ranges) in which the
|
|
|
158 -- following hold:
|
|
|
159
|
|
|
160 -- The lower bound is 1
|
|
|
161 -- The ranges are in order by increasing Low values
|
|
|
162 -- The ranges are non-overlapping and discontigous
|
|
|
163
|
|
|
164 -- A character value is in the set if it is contained in one of the
|
|
|
165 -- ranges. The actual Wide_Character_Set value is a controlled pointer
|
|
|
166 -- to this Wide_Character_Ranges value. The use of a controlled type
|
|
|
167 -- is necessary to prevent storage leaks.
|
|
|
168
|
|
|
169 type Wide_Character_Ranges_Access is access all Wide_Character_Ranges;
|
|
|
170
|
|
|
171 type Wide_Character_Set is new AF.Controlled with record
|
|
|
172 Set : Wide_Character_Ranges_Access;
|
|
|
173 end record;
|
|
|
174
|
|
|
175 pragma Finalize_Storage_Only (Wide_Character_Set);
|
|
|
176 -- This avoids useless finalizations, and, more importantly avoids
|
|
|
177 -- incorrect attempts to finalize constants that are statically
|
|
|
178 -- declared here and in Ada.Strings.Wide_Maps, which is incorrect.
|
|
|
179
|
|
|
180 overriding procedure Initialize (Object : in out Wide_Character_Set);
|
|
|
181 overriding procedure Adjust (Object : in out Wide_Character_Set);
|
|
|
182 overriding procedure Finalize (Object : in out Wide_Character_Set);
|
|
|
183
|
|
|
184 Null_Range : aliased constant Wide_Character_Ranges :=
|
|
|
185 (1 .. 0 => (Low => ' ', High => ' '));
|
|
|
186
|
|
|
187 Null_Set : constant Wide_Character_Set :=
|
|
|
188 (AF.Controlled with
|
|
|
189 Set => Null_Range'Unrestricted_Access);
|
|
|
190
|
|
|
191 ----------------------------------------------
|
|
|
192 -- Representation of Wide_Character_Mapping --
|
|
|
193 ----------------------------------------------
|
|
|
194
|
|
|
195 -- A wide character mapping is represented as two strings of equal
|
|
|
196 -- length, where any character appearing in Domain is mapped to the
|
|
|
197 -- corresponding character in Rangev. A character not appearing in
|
|
|
198 -- Domain is mapped to itself. The characters in Domain are sorted
|
|
|
199 -- in ascending order.
|
|
|
200
|
|
|
201 -- The actual Wide_Character_Mapping value is a controlled record
|
|
|
202 -- that contains a pointer to a discriminated record containing the
|
|
|
203 -- range and domain values.
|
|
|
204
|
|
|
205 -- Note: this representation is canonical, and the values stored in
|
|
|
206 -- Domain and Rangev are exactly the values that are returned by the
|
|
|
207 -- functions To_Domain and To_Range. The use of a controlled type is
|
|
|
208 -- necessary to prevent storage leaks.
|
|
|
209
|
|
|
210 type Wide_Character_Mapping_Values (Length : Natural) is record
|
|
|
211 Domain : Wide_Character_Sequence (1 .. Length);
|
|
|
212 Rangev : Wide_Character_Sequence (1 .. Length);
|
|
|
213 end record;
|
|
|
214
|
|
|
215 type Wide_Character_Mapping_Values_Access is
|
|
|
216 access all Wide_Character_Mapping_Values;
|
|
|
217
|
|
|
218 type Wide_Character_Mapping is new AF.Controlled with record
|
|
|
219 Map : Wide_Character_Mapping_Values_Access;
|
|
|
220 end record;
|
|
|
221
|
|
|
222 pragma Finalize_Storage_Only (Wide_Character_Mapping);
|
|
|
223 -- This avoids useless finalizations, and, more importantly avoids
|
|
|
224 -- incorrect attempts to finalize constants that are statically
|
|
|
225 -- declared here and in Ada.Strings.Wide_Maps, which is incorrect.
|
|
|
226
|
|
|
227 overriding procedure Initialize (Object : in out Wide_Character_Mapping);
|
|
|
228 overriding procedure Adjust (Object : in out Wide_Character_Mapping);
|
|
|
229 overriding procedure Finalize (Object : in out Wide_Character_Mapping);
|
|
|
230
|
|
|
231 Null_Map : aliased constant Wide_Character_Mapping_Values :=
|
|
|
232 (Length => 0,
|
|
|
233 Domain => "",
|
|
|
234 Rangev => "");
|
|
|
235
|
|
|
236 Identity : constant Wide_Character_Mapping :=
|
|
|
237 (AF.Controlled with
|
|
|
238 Map => Null_Map'Unrestricted_Access);
|
|
|
239
|
|
|
240 end Ada.Strings.Wide_Maps;
|
