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
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
|
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- A D A . S T R I N G S . M A P S --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2022, Free Software Foundation, Inc. --
-- --
-- This specification is derived from the Ada Reference Manual for use with --
-- GNAT. The copyright notice above, and the license provisions that follow --
-- apply solely to the contents of the part following the private keyword. --
-- --
-- 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 3, 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. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- The package Strings.Maps defines the types, operations, and other entities
-- needed for character sets and character-to-character mappings.
-- Preconditions in this unit are meant for analysis only, not for run-time
-- checking, so that the expected exceptions are raised. This is enforced by
-- setting the corresponding assertion policy to Ignore. Postconditions and
-- ghost code should not be executed at runtime as well, in order not to slow
-- down the execution of these functions.
pragma Assertion_Policy (Pre => Ignore,
Post => Ignore,
Ghost => Ignore);
with Ada.Characters.Latin_1;
package Ada.Strings.Maps
with SPARK_Mode
is
pragma Pure;
-- In accordance with Ada 2005 AI-362
--------------------------------
-- Character Set Declarations --
--------------------------------
type Character_Set is private;
pragma Preelaborable_Initialization (Character_Set);
-- An object of type Character_Set represents a set of characters.
Null_Set : constant Character_Set;
-- Null_Set represents the set containing no characters.
---------------------------
-- Constructors for Sets --
---------------------------
type Character_Range is record
Low : Character;
High : Character;
end record;
-- An object Obj of type Character_Range represents the set of characters
-- in the range Obj.Low .. Obj.High.
type Character_Ranges is array (Positive range <>) of Character_Range;
-- An object Obj of type Character_Ranges represents the union of the sets
-- corresponding to Obj(I) for I in Obj'Range.
function To_Set (Ranges : Character_Ranges) return Character_Set with
Post =>
(if Ranges'Length = 0 then To_Set'Result = Null_Set)
and then
(for all Char in Character =>
(if Is_In (Char, To_Set'Result)
then (for some Span of Ranges => Char in Span.Low .. Span.High)))
and then
(for all Span of Ranges =>
(for all Char in Span.Low .. Span.High =>
Is_In (Char, To_Set'Result)));
-- If Ranges'Length=0 then Null_Set is returned; otherwise, the returned
-- value represents the set corresponding to Ranges.
function To_Set (Span : Character_Range) return Character_Set with
Post =>
(if Span.High < Span.Low then To_Set'Result = Null_Set)
and then
(for all Char in Character =>
(if Is_In (Char, To_Set'Result) then Char in Span.Low .. Span.High))
and then
(for all Char in Span.Low .. Span.High => Is_In (Char, To_Set'Result));
-- The returned value represents the set containing each character in Span.
function To_Ranges (Set : Character_Set) return Character_Ranges with
Post =>
(if Set = Null_Set then To_Ranges'Result'Length = 0)
and then
(for all Char in Character =>
(if Is_In (Char, Set)
then
(for some Span of To_Ranges'Result =>
Char in Span.Low .. Span.High)))
and then
(for all Span of To_Ranges'Result =>
(for all Char in Span.Low .. Span.High => Is_In (Char, Set)));
-- If Set = Null_Set, then an empty Character_Ranges array is returned;
-- otherwise, the shortest array of contiguous ranges of Character values
-- in Set, in increasing order of Low, is returned.
--
-- The postcondition above does not express that the result is the shortest
-- array and that it is sorted.
----------------------------------
-- Operations on Character Sets --
----------------------------------
function "=" (Left, Right : Character_Set) return Boolean with
Post =>
"="'Result
=
(for all Char in Character =>
(Is_In (Char, Left) = Is_In (Char, Right)));
-- The function "=" returns True if Left and Right represent identical
-- sets, and False otherwise.
-- Each of the logical operators "not", "and", "or", and "xor" returns a
-- Character_Set value that represents the set obtained by applying the
-- corresponding operation to the set(s) represented by the parameter(s)
-- of the operator.
function "not" (Right : Character_Set) return Character_Set with
Post =>
(for all Char in Character =>
(Is_In (Char, "not"'Result)
=
not Is_In (Char, Right)));
function "and" (Left, Right : Character_Set) return Character_Set with
Post =>
(for all Char in Character =>
(Is_In (Char, "and"'Result)
=
(Is_In (Char, Left) and Is_In (Char, Right))));
function "or" (Left, Right : Character_Set) return Character_Set with
Post =>
(for all Char in Character =>
(Is_In (Char, "or"'Result)
=
(Is_In (Char, Left) or Is_In (Char, Right))));
function "xor" (Left, Right : Character_Set) return Character_Set with
Post =>
(for all Char in Character =>
(Is_In (Char, "xor"'Result)
=
(Is_In (Char, Left) xor Is_In (Char, Right))));
function "-" (Left, Right : Character_Set) return Character_Set with
Post =>
(for all Char in Character =>
(Is_In (Char, "-"'Result)
=
(Is_In (Char, Left) and not Is_In (Char, Right))));
-- "-"(Left, Right) is equivalent to "and"(Left, "not"(Right)).
function Is_In
(Element : Character;
Set : Character_Set) return Boolean;
-- Is_In returns True if Element is in Set, and False otherwise.
function Is_Subset
(Elements : Character_Set;
Set : Character_Set) return Boolean
with
Post =>
Is_Subset'Result
=
(for all Char in Character =>
(if Is_In (Char, Elements) then Is_In (Char, Set)));
-- Is_Subset returns True if Elements is a subset of Set, and False
-- otherwise.
function "<="
(Left : Character_Set;
Right : Character_Set) return Boolean
renames Is_Subset;
subtype Character_Sequence is String;
-- The Character_Sequence subtype is used to portray a set of character
-- values and also to identify the domain and range of a character mapping.
function SPARK_Proof_Sorted_Character_Sequence
(Seq : Character_Sequence) return Boolean
is
(for all J in Seq'Range =>
(if J /= Seq'Last then Seq (J) < Seq (J + 1)))
with
Ghost;
-- Check whether the Character_Sequence is sorted in stricly increasing
-- order, as expected from the result of To_Sequence and To_Domain.
-- Sequence portrays the set of character values that it explicitly
-- contains (ignoring duplicates). Singleton portrays the set comprising a
-- single Character. Each of the To_Set functions returns a Character_Set
-- value that represents the set portrayed by Sequence or Singleton.
function To_Set (Sequence : Character_Sequence) return Character_Set with
Post =>
(if Sequence'Length = 0 then To_Set'Result = Null_Set)
and then
(for all Char in Character =>
(if Is_In (Char, To_Set'Result)
then (for some X of Sequence => Char = X)))
and then
(for all Char of Sequence => Is_In (Char, To_Set'Result));
function To_Set (Singleton : Character) return Character_Set with
Post =>
Is_In (Singleton, To_Set'Result)
and then
(for all Char in Character =>
(if Char /= Singleton
then not Is_In (Char, To_Set'Result)));
function To_Sequence (Set : Character_Set) return Character_Sequence with
Post =>
(if Set = Null_Set then To_Sequence'Result'Length = 0)
and then
(for all Char in Character =>
(if Is_In (Char, Set)
then (for some X of To_Sequence'Result => Char = X)))
and then
(for all Char of To_Sequence'Result => Is_In (Char, Set))
and then
SPARK_Proof_Sorted_Character_Sequence (To_Sequence'Result);
-- The function To_Sequence returns a Character_Sequence value containing
-- each of the characters in the set represented by Set, in ascending order
-- with no duplicates.
------------------------------------
-- Character Mapping Declarations --
------------------------------------
type Character_Mapping is private;
pragma Preelaborable_Initialization (Character_Mapping);
-- An object of type Character_Mapping represents a Character-to-Character
-- mapping.
type SPARK_Proof_Character_Mapping_Model is
array (Character) of Character
with Ghost;
-- Publicly visible model of a Character_Mapping
function SPARK_Proof_Model
(Map : Character_Mapping)
return SPARK_Proof_Character_Mapping_Model
with Ghost;
-- Creation of a publicly visible model of a Character_Mapping
function Value
(Map : Character_Mapping;
Element : Character) return Character
with
Post => Value'Result = SPARK_Proof_Model (Map) (Element);
-- The function Value returns the Character value to which Element maps
-- with respect to the mapping represented by Map.
-- A character C matches a pattern character P with respect to a given
-- Character_Mapping value Map if Value(Map, C) = P. A string S matches
-- a pattern string P with respect to a given Character_Mapping if
-- their lengths are the same and if each character in S matches its
-- corresponding character in the pattern string P.
-- String handling subprograms that deal with character mappings have
-- parameters whose type is Character_Mapping.
Identity : constant Character_Mapping;
-- Identity maps each Character to itself.
----------------------------
-- Operations on Mappings --
----------------------------
function To_Mapping
(From, To : Character_Sequence) return Character_Mapping
with
Pre =>
From'Length = To'Length
and then
(for all J in From'Range =>
(for all K in From'Range =>
(if J /= K then From (J) /= From (K)))),
Post =>
(if From = To then To_Mapping'Result = Identity)
and then
(for all Char in Character =>
((for all J in From'Range =>
(if From (J) = Char
then Value (To_Mapping'Result, Char)
= To (J - From'First + To'First)))
and then
(if (for all X of From => Char /= X)
then Value (To_Mapping'Result, Char) = Char)));
-- To_Mapping produces a Character_Mapping such that each element of From
-- maps to the corresponding element of To, and each other character maps
-- to itself. If From'Length /= To'Length, or if some character is repeated
-- in From, then Translation_Error is propagated.
function To_Domain
(Map : Character_Mapping) return Character_Sequence with
Post =>
(if Map = Identity then To_Domain'Result'Length = 0)
and then
To_Domain'Result'First = 1
and then
SPARK_Proof_Sorted_Character_Sequence (To_Domain'Result)
and then
(for all Char in Character =>
(if (for all X of To_Domain'Result => X /= Char)
then Value (Map, Char) = Char))
and then
(for all Char of To_Domain'Result => Value (Map, Char) /= Char);
-- To_Domain returns the shortest Character_Sequence value D such that each
-- character not in D maps to itself, and such that the characters in D are
-- in ascending order. The lower bound of D is 1.
function To_Range
(Map : Character_Mapping) return Character_Sequence with
Post =>
To_Range'Result'First = 1
and then
To_Range'Result'Length = To_Domain (Map)'Length
and then
(for all J in To_Range'Result'Range =>
To_Range'Result (J) = Value (Map, To_Domain (Map) (J)));
-- To_Range returns the Character_Sequence value R, such that if D =
-- To_Domain(Map), then R has the same bounds as D, and D(I) maps to
-- R(I) for each I in D'Range.
--
-- A direct encoding of the Ada RM would be the postcondition
-- To_Range'Result'Last = To_Domain (Map)'Last
-- which is not provable unless the postcondition of To_Domain is also
-- strengthened to state the value of the high bound for an empty result.
type Character_Mapping_Function is
access function (From : Character) return Character;
-- An object F of type Character_Mapping_Function maps a Character value C
-- to the Character value F.all(C), which is said to match C with respect
-- to mapping function F.
private
pragma Inline (Is_In);
pragma Inline (Value);
type Character_Set_Internal is array (Character) of Boolean;
pragma Pack (Character_Set_Internal);
type Character_Set is new Character_Set_Internal;
-- Note: the reason for this level of derivation is to make sure
-- that the predefined logical operations on this type remain
-- accessible. The operations on Character_Set are overridden by
-- the defined operations in the spec, but the operations defined
-- on Character_Set_Internal remain visible.
Null_Set : constant Character_Set := [others => False];
type Character_Mapping is array (Character) of Character;
function SPARK_Proof_Model
(Map : Character_Mapping)
return SPARK_Proof_Character_Mapping_Model
is
(SPARK_Proof_Character_Mapping_Model (Map));
package L renames Ada.Characters.Latin_1;
Identity : constant Character_Mapping :=
(L.NUL & -- NUL 0
L.SOH & -- SOH 1
L.STX & -- STX 2
L.ETX & -- ETX 3
L.EOT & -- EOT 4
L.ENQ & -- ENQ 5
L.ACK & -- ACK 6
L.BEL & -- BEL 7
L.BS & -- BS 8
L.HT & -- HT 9
L.LF & -- LF 10
L.VT & -- VT 11
L.FF & -- FF 12
L.CR & -- CR 13
L.SO & -- SO 14
L.SI & -- SI 15
L.DLE & -- DLE 16
L.DC1 & -- DC1 17
L.DC2 & -- DC2 18
L.DC3 & -- DC3 19
L.DC4 & -- DC4 20
L.NAK & -- NAK 21
L.SYN & -- SYN 22
L.ETB & -- ETB 23
L.CAN & -- CAN 24
L.EM & -- EM 25
L.SUB & -- SUB 26
L.ESC & -- ESC 27
L.FS & -- FS 28
L.GS & -- GS 29
L.RS & -- RS 30
L.US & -- US 31
L.Space & -- ' ' 32
L.Exclamation & -- '!' 33
L.Quotation & -- '"' 34
L.Number_Sign & -- '#' 35
L.Dollar_Sign & -- '$' 36
L.Percent_Sign & -- '%' 37
L.Ampersand & -- '&' 38
L.Apostrophe & -- ''' 39
L.Left_Parenthesis & -- '(' 40
L.Right_Parenthesis & -- ')' 41
L.Asterisk & -- '*' 42
L.Plus_Sign & -- '+' 43
L.Comma & -- ',' 44
L.Hyphen & -- '-' 45
L.Full_Stop & -- '.' 46
L.Solidus & -- '/' 47
'0' & -- '0' 48
'1' & -- '1' 49
'2' & -- '2' 50
'3' & -- '3' 51
'4' & -- '4' 52
'5' & -- '5' 53
'6' & -- '6' 54
'7' & -- '7' 55
'8' & -- '8' 56
'9' & -- '9' 57
L.Colon & -- ':' 58
L.Semicolon & -- ';' 59
L.Less_Than_Sign & -- '<' 60
L.Equals_Sign & -- '=' 61
L.Greater_Than_Sign & -- '>' 62
L.Question & -- '?' 63
L.Commercial_At & -- '@' 64
'A' & -- 'A' 65
'B' & -- 'B' 66
'C' & -- 'C' 67
'D' & -- 'D' 68
'E' & -- 'E' 69
'F' & -- 'F' 70
'G' & -- 'G' 71
'H' & -- 'H' 72
'I' & -- 'I' 73
'J' & -- 'J' 74
'K' & -- 'K' 75
'L' & -- 'L' 76
'M' & -- 'M' 77
'N' & -- 'N' 78
'O' & -- 'O' 79
'P' & -- 'P' 80
'Q' & -- 'Q' 81
'R' & -- 'R' 82
'S' & -- 'S' 83
'T' & -- 'T' 84
'U' & -- 'U' 85
'V' & -- 'V' 86
'W' & -- 'W' 87
'X' & -- 'X' 88
'Y' & -- 'Y' 89
'Z' & -- 'Z' 90
L.Left_Square_Bracket & -- '[' 91
L.Reverse_Solidus & -- '\' 92
L.Right_Square_Bracket & -- ']' 93
L.Circumflex & -- '^' 94
L.Low_Line & -- '_' 95
L.Grave & -- '`' 96
L.LC_A & -- 'a' 97
L.LC_B & -- 'b' 98
L.LC_C & -- 'c' 99
L.LC_D & -- 'd' 100
L.LC_E & -- 'e' 101
L.LC_F & -- 'f' 102
L.LC_G & -- 'g' 103
L.LC_H & -- 'h' 104
L.LC_I & -- 'i' 105
L.LC_J & -- 'j' 106
L.LC_K & -- 'k' 107
L.LC_L & -- 'l' 108
L.LC_M & -- 'm' 109
L.LC_N & -- 'n' 110
L.LC_O & -- 'o' 111
L.LC_P & -- 'p' 112
L.LC_Q & -- 'q' 113
L.LC_R & -- 'r' 114
L.LC_S & -- 's' 115
L.LC_T & -- 't' 116
L.LC_U & -- 'u' 117
L.LC_V & -- 'v' 118
L.LC_W & -- 'w' 119
L.LC_X & -- 'x' 120
L.LC_Y & -- 'y' 121
L.LC_Z & -- 'z' 122
L.Left_Curly_Bracket & -- '{' 123
L.Vertical_Line & -- '|' 124
L.Right_Curly_Bracket & -- '}' 125
L.Tilde & -- '~' 126
L.DEL & -- DEL 127
L.Reserved_128 & -- Reserved_128 128
L.Reserved_129 & -- Reserved_129 129
L.BPH & -- BPH 130
L.NBH & -- NBH 131
L.Reserved_132 & -- Reserved_132 132
L.NEL & -- NEL 133
L.SSA & -- SSA 134
L.ESA & -- ESA 135
L.HTS & -- HTS 136
L.HTJ & -- HTJ 137
L.VTS & -- VTS 138
L.PLD & -- PLD 139
L.PLU & -- PLU 140
L.RI & -- RI 141
L.SS2 & -- SS2 142
L.SS3 & -- SS3 143
L.DCS & -- DCS 144
L.PU1 & -- PU1 145
L.PU2 & -- PU2 146
L.STS & -- STS 147
L.CCH & -- CCH 148
L.MW & -- MW 149
L.SPA & -- SPA 150
L.EPA & -- EPA 151
L.SOS & -- SOS 152
L.Reserved_153 & -- Reserved_153 153
L.SCI & -- SCI 154
L.CSI & -- CSI 155
L.ST & -- ST 156
L.OSC & -- OSC 157
L.PM & -- PM 158
L.APC & -- APC 159
L.No_Break_Space & -- No_Break_Space 160
L.Inverted_Exclamation & -- Inverted_Exclamation 161
L.Cent_Sign & -- Cent_Sign 162
L.Pound_Sign & -- Pound_Sign 163
L.Currency_Sign & -- Currency_Sign 164
L.Yen_Sign & -- Yen_Sign 165
L.Broken_Bar & -- Broken_Bar 166
L.Section_Sign & -- Section_Sign 167
L.Diaeresis & -- Diaeresis 168
L.Copyright_Sign & -- Copyright_Sign 169
L.Feminine_Ordinal_Indicator & -- Feminine_Ordinal_Indicator 170
L.Left_Angle_Quotation & -- Left_Angle_Quotation 171
L.Not_Sign & -- Not_Sign 172
L.Soft_Hyphen & -- Soft_Hyphen 173
L.Registered_Trade_Mark_Sign & -- Registered_Trade_Mark_Sign 174
L.Macron & -- Macron 175
L.Degree_Sign & -- Degree_Sign 176
L.Plus_Minus_Sign & -- Plus_Minus_Sign 177
L.Superscript_Two & -- Superscript_Two 178
L.Superscript_Three & -- Superscript_Three 179
L.Acute & -- Acute 180
L.Micro_Sign & -- Micro_Sign 181
L.Pilcrow_Sign & -- Pilcrow_Sign 182
L.Middle_Dot & -- Middle_Dot 183
L.Cedilla & -- Cedilla 184
L.Superscript_One & -- Superscript_One 185
L.Masculine_Ordinal_Indicator & -- Masculine_Ordinal_Indicator 186
L.Right_Angle_Quotation & -- Right_Angle_Quotation 187
L.Fraction_One_Quarter & -- Fraction_One_Quarter 188
L.Fraction_One_Half & -- Fraction_One_Half 189
L.Fraction_Three_Quarters & -- Fraction_Three_Quarters 190
L.Inverted_Question & -- Inverted_Question 191
L.UC_A_Grave & -- UC_A_Grave 192
L.UC_A_Acute & -- UC_A_Acute 193
L.UC_A_Circumflex & -- UC_A_Circumflex 194
L.UC_A_Tilde & -- UC_A_Tilde 195
L.UC_A_Diaeresis & -- UC_A_Diaeresis 196
L.UC_A_Ring & -- UC_A_Ring 197
L.UC_AE_Diphthong & -- UC_AE_Diphthong 198
L.UC_C_Cedilla & -- UC_C_Cedilla 199
L.UC_E_Grave & -- UC_E_Grave 200
L.UC_E_Acute & -- UC_E_Acute 201
L.UC_E_Circumflex & -- UC_E_Circumflex 202
L.UC_E_Diaeresis & -- UC_E_Diaeresis 203
L.UC_I_Grave & -- UC_I_Grave 204
L.UC_I_Acute & -- UC_I_Acute 205
L.UC_I_Circumflex & -- UC_I_Circumflex 206
L.UC_I_Diaeresis & -- UC_I_Diaeresis 207
L.UC_Icelandic_Eth & -- UC_Icelandic_Eth 208
L.UC_N_Tilde & -- UC_N_Tilde 209
L.UC_O_Grave & -- UC_O_Grave 210
L.UC_O_Acute & -- UC_O_Acute 211
L.UC_O_Circumflex & -- UC_O_Circumflex 212
L.UC_O_Tilde & -- UC_O_Tilde 213
L.UC_O_Diaeresis & -- UC_O_Diaeresis 214
L.Multiplication_Sign & -- Multiplication_Sign 215
L.UC_O_Oblique_Stroke & -- UC_O_Oblique_Stroke 216
L.UC_U_Grave & -- UC_U_Grave 217
L.UC_U_Acute & -- UC_U_Acute 218
L.UC_U_Circumflex & -- UC_U_Circumflex 219
L.UC_U_Diaeresis & -- UC_U_Diaeresis 220
L.UC_Y_Acute & -- UC_Y_Acute 221
L.UC_Icelandic_Thorn & -- UC_Icelandic_Thorn 222
L.LC_German_Sharp_S & -- LC_German_Sharp_S 223
L.LC_A_Grave & -- LC_A_Grave 224
L.LC_A_Acute & -- LC_A_Acute 225
L.LC_A_Circumflex & -- LC_A_Circumflex 226
L.LC_A_Tilde & -- LC_A_Tilde 227
L.LC_A_Diaeresis & -- LC_A_Diaeresis 228
L.LC_A_Ring & -- LC_A_Ring 229
L.LC_AE_Diphthong & -- LC_AE_Diphthong 230
L.LC_C_Cedilla & -- LC_C_Cedilla 231
L.LC_E_Grave & -- LC_E_Grave 232
L.LC_E_Acute & -- LC_E_Acute 233
L.LC_E_Circumflex & -- LC_E_Circumflex 234
L.LC_E_Diaeresis & -- LC_E_Diaeresis 235
L.LC_I_Grave & -- LC_I_Grave 236
L.LC_I_Acute & -- LC_I_Acute 237
L.LC_I_Circumflex & -- LC_I_Circumflex 238
L.LC_I_Diaeresis & -- LC_I_Diaeresis 239
L.LC_Icelandic_Eth & -- LC_Icelandic_Eth 240
L.LC_N_Tilde & -- LC_N_Tilde 241
L.LC_O_Grave & -- LC_O_Grave 242
L.LC_O_Acute & -- LC_O_Acute 243
L.LC_O_Circumflex & -- LC_O_Circumflex 244
L.LC_O_Tilde & -- LC_O_Tilde 245
L.LC_O_Diaeresis & -- LC_O_Diaeresis 246
L.Division_Sign & -- Division_Sign 247
L.LC_O_Oblique_Stroke & -- LC_O_Oblique_Stroke 248
L.LC_U_Grave & -- LC_U_Grave 249
L.LC_U_Acute & -- LC_U_Acute 250
L.LC_U_Circumflex & -- LC_U_Circumflex 251
L.LC_U_Diaeresis & -- LC_U_Diaeresis 252
L.LC_Y_Acute & -- LC_Y_Acute 253
L.LC_Icelandic_Thorn & -- LC_Icelandic_Thorn 254
L.LC_Y_Diaeresis); -- LC_Y_Diaeresis 255
end Ada.Strings.Maps;
|
