Subversion Repositories openrisc

-- WIDECHR.A

--

--                             Grant of Unlimited Rights

--

--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,

--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained

--     unlimited rights in the software and documentation contained herein.

--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making

--     this public release, the Government intends to confer upon all

--     recipients unlimited rights  equal to those held by the Government.

--     These rights include rights to use, duplicate, release or disclose the

--     released technical data and computer software in whole or in part, in

--     any manner and for any purpose whatsoever, and to have or permit others

--     to do so.

--

--                                    DISCLAIMER

--

--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR

--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED

--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE

--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE

--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A

--     PARTICULAR PURPOSE OF SAID MATERIAL.

--*

--

-- DESCRIPTION:

--

--      This program reads C250001.AW and C250002.AW; translates a special

--      character sequence into characters and wide characters with positions

--      above ASCII.DEL.  The resulting tests are written as C250001.A and

--      C250002.A respectively.   This program may need to

--      be modified if the Wide_Character representation recognized by

--      your compiler differs from the Wide_Character

--      representation generated by the package Ada.Wide_Text_IO.

--      Modify this program as needed to translate that file.

--

--      A wide character is represented by an 8 character sequence:

--

--          ["abcd"]

--

--      where the character code represented is specified by four hexadecimal

--      digits, abcd, with letters in upper case. For example the wide

--      character with the code 16#AB13# is represented by the eight

--      character sequence:

--

--          ["AB13"]

--

-- ASSUMPTIONS:

--

--      The path for these files is specified in ImpDef.

--

-- SPECIAL REQUIREMENTS:

--

--     Compile, bind and execute this program.  It will process the ".AW"

--     tests, "translating" them to ".A" tests.

--

-- CHANGE HISTORY:

--      11 DEC 96   SAIC   ACVC 2.1 Release

--

--      11 DEC 96   Keith  Constructed initial release version

--!

with Ada.Text_IO;

with Ada.Wide_Text_IO;

with Ada.Strings.Fixed;

with Impdef;

procedure WideChr is

  -- Debug

  --

  -- To have the program generate trace/debugging information, de-comment

  -- the call to Put_Line

  procedure Debug( S: String ) is

  begin

    null; -- Ada.Text_IO.Put_Line(S);

  end Debug;

  package TIO renames Ada.Text_IO;

  package WIO renames Ada.Wide_Text_IO;

  package SF renames Ada.Strings.Fixed;

  In_File : TIO.File_Type;

  -- This program is actually dual-purpose.  It translates the ["xxxx"]

  -- notation to Wide_Character, as well as a similar notation ["xx"] into

  -- Character.  The intent of the latter being the ability to represent

  -- literals in the Latin-1 character set that have position numbers

  -- greater than ASCII.DEL.  The variable Output_Mode drives the algorithms

  -- to generate Wide_Character output (Wide) or Character output (Narrow).

  type Output_Modes is ( Wide, Narrow );

  Output_Mode : Output_Modes := Wide;

  Wide_Out   : WIO.File_Type;

  Narrow_Out : TIO.File_Type;

  In_Line   : String(1..132); -- SB: $MAX_LINE_LENGTH

  -- Index variables

  --

  -- the following index variables: In_Length, Front, Open_Bracket and

  -- Close_Bracket are used by the scanning software to keep track of

  -- what's where.

  --

  -- In_Length stores the value returned by Ada.Text_IO.Get_Line indicating

  -- the position of the last "useful" character in the string In_Line.

  --

  -- Front retains the index of the first non-translating character in

  -- In_Line, it is used to indicate the starting index of the portion of

  -- the string to save without special interpretation.  In the example

  -- below, where there are two consecutive characters to translate, we see

  -- that Front will assume three different values processing the string,

  -- these are indicated by the digits '1', '2' & '3' in the comment

  -- attached to the declaration.  The processing software will dump

  -- In_Line(Front..Open_Bracket-1) to the output stream.  Note that in

  -- the second case, this results in a null string, and in the third case,

  -- where Open_Bracket does not obtain a third value, the slice

  -- In_Line(Front..In_Length) is used instead.

  --

  -- Open_Bracket and Close_Bracket are used to retain the starting index

  -- of the character pairs [" and "] respectively.  For the purposes of

  -- this software the character pairs are what are considered to be the

  -- "brackets" enclosing the hexadecimal values to be translated.

  --  Looking at the example below you will see where these index variables

  -- will "point" in the first and second case.

  In_Length     : Natural := 0;  --->  Some_["0A12"]["0B13"]_Thing

  Front         : Natural := 0;  --  1              2       3

  Open_Bracket  : Natural := 0;  --         1       2

  Close_Bracket : Natural := 0;  --               1       2

  -- Xlation

  --

  -- This translation table gives an easy way to translate the "decimal"

  -- value of a hex digit (as represented by a Latin-1 character)

  type Xlate is array(Character range '0'..'F') of Natural;

  Xlation : constant Xlate :=

            ('0' =>  0, '1' =>  1, '2' =>  2, '3' =>  3, '4' =>  4,

             '5' =>  5, '6' =>  6, '7' =>  7, '8' =>  8, '9' =>  9,

             'A' => 10, 'B' => 11, 'C' => 12, 'D' => 13, 'E' => 14,

             'F' => 15,

             others => 0);

  -- To_Ch

  --

  -- This function takes a string which is assumed to be trimmed to just a

  -- hexadecimal representation of a Latin-1 character.  The result of the

  -- function is the Latin-1 character at the position designated by the

  -- incoming hexadecimal value.  (hexadecimal in human readable form)

  function To_Ch( S:String ) return Character is

    Numerical : Natural := 0;

  begin

    Debug("To Wide: " & S);

    for I in S'Range loop

      Numerical := Numerical * 16 + Xlation(S(I));

    end loop;

    return Character'Val(Numerical);

  exception

    when Constraint_Error => return '_';

  end To_Ch;

  -- To_Wide

  --

  -- This function takes a string which is assumed to be trimmed to just a

  -- hexadecimal representation of a Wide_character.  The result of the

  -- function is the Wide_character at the position designated by the

  -- incoming hexadecimal value.  (hexadecimal in human readable form)

  function To_Wide( S:String ) return Wide_character is

    Numerical : Natural := 0;

  begin

    Debug("To Wide: " & S);

    for I in S'Range loop

      Numerical := Numerical * 16 + Xlation(S(I));

    end loop;

    return Wide_Character'Val(Numerical);

  exception

    when Constraint_Error => return '_';

  end To_Wide;

  -- Make_Wide

  --

  -- this function converts a String to a Wide_String

  function Make_Wide( S: String ) return Wide_String is

    W: Wide_String(S'Range);

  begin

    for I in S'Range loop

      W(I) := Wide_Character'Val( Character'Pos(S(I)) );

    end loop;

    return W;

  end Make_Wide;

  -- Close_Files

  --

  -- Depending on which input we've processed, close the output file

  procedure Close_Files is

  begin

    TIO.Close(In_File);

    if Output_Mode = Wide then

      WIO.Close(Wide_Out);

    else

      TIO.Close(Narrow_Out);

    end if;

  end Close_Files;

  -- Process

  --

  -- for all lines in the input file

  --   scan the file for occurrences of [" and "]

  --     for found occurrence, attempt translation of the characters found

  --     between the brackets.  As a safeguard, unrecognizable character

  --     sequences will be replaced with the underscore character.  This

  --     handles the cases in the tests where the test documentation includes

  --     examples that are non-conformant: i.e. ["abcd"] or ["XXXX"]

  procedure Process( Input_File_Name: String ) is

  begin

    TIO.Open(In_File,TIO.In_File,Input_File_Name & ".aw" );

    if Output_Mode = Wide then

      WIO.Create(Wide_Out,WIO.Out_File, Input_File_Name & ".a" );

    else

      TIO.Create(Narrow_Out,TIO.Out_File, Input_File_Name & ".a" );

    end if;

    File: while not TIO.End_Of_File( In_File ) loop

      In_Line := (others => ' ');

      TIO.Get_Line(In_File,In_Line,In_Length);

      Debug(In_Line(1..In_Length));

      Front := 1;

      Line: loop

             -- scan for next occurrence of ["abcd"]

             Open_Bracket := SF.Index( In_Line(Front..In_Length), "[""" );

             Close_Bracket := SF.Index( In_Line(Front..In_Length), """]" );

             Debug( "[=" & Natural'Image(Open_Bracket) );

             Debug( "]=" & Natural'Image(Close_Bracket) );

             if Open_Bracket = 0 or Close_Bracket = 0 then

        -- done with the line, output remaining characters and exit

               Debug("Done with line");

               if Output_Mode = Wide then

                 WIO.Put_Line(Wide_Out, Make_Wide(In_Line(Front..In_Length)) );

               else

                 TIO.Put_Line(Narrow_Out, In_Line(Front..In_Length) );

               end if;

               exit Line;

             else

               -- output the "normal" stuff up to the bracket

               if Output_Mode = Wide then

                 WIO.Put(Wide_Out, Make_Wide(In_Line(Front..Open_Bracket-1)) );

               else

                 TIO.Put(Narrow_Out, In_Line(Front..Open_Bracket-1) );

               end if;

               -- point beyond the closing bracket

               Front := Close_Bracket +2;

               -- output the translated hexadecimal character

               if Output_Mode = Wide then

                 WIO.Put(Wide_Out,

                            To_Wide( In_Line(Open_Bracket+2..Close_Bracket-1) ));

               else

                 TIO.Put(Narrow_Out,

                                    To_Ch( In_Line(Open_Bracket+2..Close_Bracket-1)) );

               end if;

        end if;

      end loop Line;

    end loop File;

    Close_Files;

  exception

    when others =>

      Ada.Text_IO.Put_Line("Error in processing " & Input_File_Name);

      raise;

  end Process;

begin

  Output_Mode := Wide;

  Process( Impdef.Wide_Character_Test );

  Output_Mode := Narrow;

  Process( Impdef.Upper_Latin_Test );

end WideChr;