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-2011, 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 36with Ada.Finalization; 37 38package 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 149private 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 240end Ada.Strings.Wide_Maps; 241