| 1 |
-- WIDECHR.A |
| 2 |
-- |
| 3 |
-- Grant of Unlimited Rights |
| 4 |
-- |
| 5 |
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687, |
| 6 |
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained |
| 7 |
-- unlimited rights in the software and documentation contained herein. |
| 8 |
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making |
| 9 |
-- this public release, the Government intends to confer upon all |
| 10 |
-- recipients unlimited rights equal to those held by the Government. |
| 11 |
-- These rights include rights to use, duplicate, release or disclose the |
| 12 |
-- released technical data and computer software in whole or in part, in |
| 13 |
-- any manner and for any purpose whatsoever, and to have or permit others |
| 14 |
-- to do so. |
| 15 |
-- |
| 16 |
-- DISCLAIMER |
| 17 |
-- |
| 18 |
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR |
| 19 |
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED |
| 20 |
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE |
| 21 |
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE |
| 22 |
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A |
| 23 |
-- PARTICULAR PURPOSE OF SAID MATERIAL. |
| 24 |
--* |
| 25 |
-- |
| 26 |
-- DESCRIPTION: |
| 27 |
-- |
| 28 |
-- This program reads C250001.AW and C250002.AW; translates a special |
| 29 |
-- character sequence into characters and wide characters with positions |
| 30 |
-- above ASCII.DEL. The resulting tests are written as C250001.A and |
| 31 |
-- C250002.A respectively. This program may need to |
| 32 |
-- be modified if the Wide_Character representation recognized by |
| 33 |
-- your compiler differs from the Wide_Character |
| 34 |
-- representation generated by the package Ada.Wide_Text_IO. |
| 35 |
-- Modify this program as needed to translate that file. |
| 36 |
-- |
| 37 |
-- A wide character is represented by an 8 character sequence: |
| 38 |
-- |
| 39 |
-- ["abcd"] |
| 40 |
-- |
| 41 |
-- where the character code represented is specified by four hexadecimal |
| 42 |
-- digits, abcd, with letters in upper case. For example the wide |
| 43 |
-- character with the code 16#AB13# is represented by the eight |
| 44 |
-- character sequence: |
| 45 |
-- |
| 46 |
-- ["AB13"] |
| 47 |
-- |
| 48 |
-- ASSUMPTIONS: |
| 49 |
-- |
| 50 |
-- The path for these files is specified in ImpDef. |
| 51 |
-- |
| 52 |
-- SPECIAL REQUIREMENTS: |
| 53 |
-- |
| 54 |
-- Compile, bind and execute this program. It will process the ".AW" |
| 55 |
-- tests, "translating" them to ".A" tests. |
| 56 |
-- |
| 57 |
-- CHANGE HISTORY: |
| 58 |
-- 11 DEC 96 SAIC ACVC 2.1 Release |
| 59 |
-- |
| 60 |
-- 11 DEC 96 Keith Constructed initial release version |
| 61 |
--! |
| 62 |
|
| 63 |
with Ada.Text_IO; |
| 64 |
with Ada.Wide_Text_IO; |
| 65 |
with Ada.Strings.Fixed; |
| 66 |
with Impdef; |
| 67 |
|
| 68 |
procedure WideChr is |
| 69 |
|
| 70 |
-- Debug |
| 71 |
-- |
| 72 |
-- To have the program generate trace/debugging information, de-comment |
| 73 |
-- the call to Put_Line |
| 74 |
|
| 75 |
procedure Debug( S: String ) is |
| 76 |
begin |
| 77 |
null; -- Ada.Text_IO.Put_Line(S); |
| 78 |
end Debug; |
| 79 |
|
| 80 |
package TIO renames Ada.Text_IO; |
| 81 |
package WIO renames Ada.Wide_Text_IO; |
| 82 |
package SF renames Ada.Strings.Fixed; |
| 83 |
|
| 84 |
In_File : TIO.File_Type; |
| 85 |
|
| 86 |
-- This program is actually dual-purpose. It translates the ["xxxx"] |
| 87 |
-- notation to Wide_Character, as well as a similar notation ["xx"] into |
| 88 |
-- Character. The intent of the latter being the ability to represent |
| 89 |
-- literals in the Latin-1 character set that have position numbers |
| 90 |
-- greater than ASCII.DEL. The variable Output_Mode drives the algorithms |
| 91 |
-- to generate Wide_Character output (Wide) or Character output (Narrow). |
| 92 |
|
| 93 |
type Output_Modes is ( Wide, Narrow ); |
| 94 |
Output_Mode : Output_Modes := Wide; |
| 95 |
|
| 96 |
Wide_Out : WIO.File_Type; |
| 97 |
Narrow_Out : TIO.File_Type; |
| 98 |
|
| 99 |
In_Line : String(1..132); -- SB: $MAX_LINE_LENGTH |
| 100 |
|
| 101 |
-- Index variables |
| 102 |
-- |
| 103 |
-- the following index variables: In_Length, Front, Open_Bracket and |
| 104 |
-- Close_Bracket are used by the scanning software to keep track of |
| 105 |
-- what's where. |
| 106 |
-- |
| 107 |
-- In_Length stores the value returned by Ada.Text_IO.Get_Line indicating |
| 108 |
-- the position of the last "useful" character in the string In_Line. |
| 109 |
-- |
| 110 |
-- Front retains the index of the first non-translating character in |
| 111 |
-- In_Line, it is used to indicate the starting index of the portion of |
| 112 |
-- the string to save without special interpretation. In the example |
| 113 |
-- below, where there are two consecutive characters to translate, we see |
| 114 |
-- that Front will assume three different values processing the string, |
| 115 |
-- these are indicated by the digits '1', '2' & '3' in the comment |
| 116 |
-- attached to the declaration. The processing software will dump |
| 117 |
-- In_Line(Front..Open_Bracket-1) to the output stream. Note that in |
| 118 |
-- the second case, this results in a null string, and in the third case, |
| 119 |
-- where Open_Bracket does not obtain a third value, the slice |
| 120 |
-- In_Line(Front..In_Length) is used instead. |
| 121 |
-- |
| 122 |
-- Open_Bracket and Close_Bracket are used to retain the starting index |
| 123 |
-- of the character pairs [" and "] respectively. For the purposes of |
| 124 |
-- this software the character pairs are what are considered to be the |
| 125 |
-- "brackets" enclosing the hexadecimal values to be translated. |
| 126 |
-- Looking at the example below you will see where these index variables |
| 127 |
-- will "point" in the first and second case. |
| 128 |
|
| 129 |
In_Length : Natural := 0; ---> Some_["0A12"]["0B13"]_Thing |
| 130 |
Front : Natural := 0; -- 1 2 3 |
| 131 |
Open_Bracket : Natural := 0; -- 1 2 |
| 132 |
Close_Bracket : Natural := 0; -- 1 2 |
| 133 |
|
| 134 |
-- Xlation |
| 135 |
-- |
| 136 |
-- This translation table gives an easy way to translate the "decimal" |
| 137 |
-- value of a hex digit (as represented by a Latin-1 character) |
| 138 |
|
| 139 |
type Xlate is array(Character range '0'..'F') of Natural; |
| 140 |
Xlation : constant Xlate := |
| 141 |
('0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, |
| 142 |
'5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, |
| 143 |
'A' => 10, 'B' => 11, 'C' => 12, 'D' => 13, 'E' => 14, |
| 144 |
'F' => 15, |
| 145 |
others => 0); |
| 146 |
|
| 147 |
-- To_Ch |
| 148 |
-- |
| 149 |
-- This function takes a string which is assumed to be trimmed to just a |
| 150 |
-- hexadecimal representation of a Latin-1 character. The result of the |
| 151 |
-- function is the Latin-1 character at the position designated by the |
| 152 |
-- incoming hexadecimal value. (hexadecimal in human readable form) |
| 153 |
|
| 154 |
function To_Ch( S:String ) return Character is |
| 155 |
Numerical : Natural := 0; |
| 156 |
begin |
| 157 |
Debug("To Wide: " & S); |
| 158 |
for I in S'Range loop |
| 159 |
Numerical := Numerical * 16 + Xlation(S(I)); |
| 160 |
end loop; |
| 161 |
return Character'Val(Numerical); |
| 162 |
exception |
| 163 |
when Constraint_Error => return '_'; |
| 164 |
end To_Ch; |
| 165 |
|
| 166 |
-- To_Wide |
| 167 |
-- |
| 168 |
-- This function takes a string which is assumed to be trimmed to just a |
| 169 |
-- hexadecimal representation of a Wide_character. The result of the |
| 170 |
-- function is the Wide_character at the position designated by the |
| 171 |
-- incoming hexadecimal value. (hexadecimal in human readable form) |
| 172 |
|
| 173 |
function To_Wide( S:String ) return Wide_character is |
| 174 |
Numerical : Natural := 0; |
| 175 |
begin |
| 176 |
Debug("To Wide: " & S); |
| 177 |
for I in S'Range loop |
| 178 |
Numerical := Numerical * 16 + Xlation(S(I)); |
| 179 |
end loop; |
| 180 |
return Wide_Character'Val(Numerical); |
| 181 |
exception |
| 182 |
when Constraint_Error => return '_'; |
| 183 |
end To_Wide; |
| 184 |
|
| 185 |
-- Make_Wide |
| 186 |
-- |
| 187 |
-- this function converts a String to a Wide_String |
| 188 |
|
| 189 |
function Make_Wide( S: String ) return Wide_String is |
| 190 |
W: Wide_String(S'Range); |
| 191 |
begin |
| 192 |
for I in S'Range loop |
| 193 |
W(I) := Wide_Character'Val( Character'Pos(S(I)) ); |
| 194 |
end loop; |
| 195 |
return W; |
| 196 |
end Make_Wide; |
| 197 |
|
| 198 |
-- Close_Files |
| 199 |
-- |
| 200 |
-- Depending on which input we've processed, close the output file |
| 201 |
|
| 202 |
procedure Close_Files is |
| 203 |
begin |
| 204 |
TIO.Close(In_File); |
| 205 |
if Output_Mode = Wide then |
| 206 |
WIO.Close(Wide_Out); |
| 207 |
else |
| 208 |
TIO.Close(Narrow_Out); |
| 209 |
end if; |
| 210 |
end Close_Files; |
| 211 |
|
| 212 |
-- Process |
| 213 |
-- |
| 214 |
-- for all lines in the input file |
| 215 |
-- scan the file for occurrences of [" and "] |
| 216 |
-- for found occurrence, attempt translation of the characters found |
| 217 |
-- between the brackets. As a safeguard, unrecognizable character |
| 218 |
-- sequences will be replaced with the underscore character. This |
| 219 |
-- handles the cases in the tests where the test documentation includes |
| 220 |
-- examples that are non-conformant: i.e. ["abcd"] or ["XXXX"] |
| 221 |
|
| 222 |
procedure Process( Input_File_Name: String ) is |
| 223 |
begin |
| 224 |
TIO.Open(In_File,TIO.In_File,Input_File_Name & ".aw" ); |
| 225 |
|
| 226 |
if Output_Mode = Wide then |
| 227 |
WIO.Create(Wide_Out,WIO.Out_File, Input_File_Name & ".a" ); |
| 228 |
else |
| 229 |
TIO.Create(Narrow_Out,TIO.Out_File, Input_File_Name & ".a" ); |
| 230 |
end if; |
| 231 |
|
| 232 |
File: while not TIO.End_Of_File( In_File ) loop |
| 233 |
In_Line := (others => ' '); |
| 234 |
TIO.Get_Line(In_File,In_Line,In_Length); |
| 235 |
Debug(In_Line(1..In_Length)); |
| 236 |
|
| 237 |
Front := 1; |
| 238 |
|
| 239 |
Line: loop |
| 240 |
-- scan for next occurrence of ["abcd"] |
| 241 |
Open_Bracket := SF.Index( In_Line(Front..In_Length), "[""" ); |
| 242 |
Close_Bracket := SF.Index( In_Line(Front..In_Length), """]" ); |
| 243 |
Debug( "[=" & Natural'Image(Open_Bracket) ); |
| 244 |
Debug( "]=" & Natural'Image(Close_Bracket) ); |
| 245 |
|
| 246 |
if Open_Bracket = 0 or Close_Bracket = 0 then |
| 247 |
-- done with the line, output remaining characters and exit |
| 248 |
Debug("Done with line"); |
| 249 |
if Output_Mode = Wide then |
| 250 |
WIO.Put_Line(Wide_Out, Make_Wide(In_Line(Front..In_Length)) ); |
| 251 |
else |
| 252 |
TIO.Put_Line(Narrow_Out, In_Line(Front..In_Length) ); |
| 253 |
end if; |
| 254 |
exit Line; |
| 255 |
else |
| 256 |
-- output the "normal" stuff up to the bracket |
| 257 |
if Output_Mode = Wide then |
| 258 |
WIO.Put(Wide_Out, Make_Wide(In_Line(Front..Open_Bracket-1)) ); |
| 259 |
else |
| 260 |
TIO.Put(Narrow_Out, In_Line(Front..Open_Bracket-1) ); |
| 261 |
end if; |
| 262 |
|
| 263 |
-- point beyond the closing bracket |
| 264 |
Front := Close_Bracket +2; |
| 265 |
|
| 266 |
-- output the translated hexadecimal character |
| 267 |
if Output_Mode = Wide then |
| 268 |
WIO.Put(Wide_Out, |
| 269 |
To_Wide( In_Line(Open_Bracket+2..Close_Bracket-1) )); |
| 270 |
else |
| 271 |
TIO.Put(Narrow_Out, |
| 272 |
To_Ch( In_Line(Open_Bracket+2..Close_Bracket-1)) ); |
| 273 |
end if; |
| 274 |
end if; |
| 275 |
end loop Line; |
| 276 |
|
| 277 |
end loop File; |
| 278 |
|
| 279 |
Close_Files; |
| 280 |
exception |
| 281 |
when others => |
| 282 |
Ada.Text_IO.Put_Line("Error in processing " & Input_File_Name); |
| 283 |
raise; |
| 284 |
end Process; |
| 285 |
|
| 286 |
begin |
| 287 |
|
| 288 |
Output_Mode := Wide; |
| 289 |
Process( Impdef.Wide_Character_Test ); |
| 290 |
|
| 291 |
Output_Mode := Narrow; |
| 292 |
Process( Impdef.Upper_Latin_Test ); |
| 293 |
|
| 294 |
end WideChr; |