DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ B T

⟦e1427055c⟧ TextFile

    Length: 81997 (0x1404d)
    Types: TextFile
    Names: »B«

Derivation

└─⟦85b835f43⟧ Bits:30000549 8mm tape, Rational 1000, Xlib rev 6.00
    └─ ⟦0c20f784e⟧ »DATA« 
        └─⟦1abbe589f⟧ 
            └─⟦49e7f20b9⟧ 
                └─⟦this⟧ 

TextFile

--/ if R1000 then
with Directory_Tools;
--/ elsif TeleGen2 and then Unix then
--// with Error_Messages;                    -- Unix error codes
--// with File_Ops;                          -- Unix file operations
--// with Integer_Text_Io;
--// with Process_Control;                   -- Unix process controls
--// with System_Calls;                      -- Unix system calls
--// with Unix_Types;                        -- Unix system types
--// use Unix_Types;
--/ end if;

with Text_Io;  
with Unchecked_Deallocation;

with Xlbt_Arithmetic;  
use Xlbt_Arithmetic;  
with Xlbt_String;  
use Xlbt_String;

package body Test_Io is
------------------------------------------------------------------------------
-- X Library Testing
--
-- Test_Io - Basic I/O facilities for the tests.
------------------------------------------------------------------------------
-- Copyright 1990 - 1990 by Rational, Santa Clara, California.
--
--                  All Rights Reserved.
--
-- Permission to use, copy, modify, and distribute this software and its
-- documentation for any purpose and without fee is hereby granted,
-- provided that the above copyright notice(s) appear in all copies and that
-- both that copyright notice(s) and this permission notice appear in
-- supporting documentation, and that the name of Rational not be used in
-- advertising or publicity pertaining to distribution of the software
-- without specific, written prior permission.
--
-- Rational disclaims all warranties with regard to this software, including
-- all implied warranties of merchantability and fitness, in no event shall
-- Rational be liable for any special, indirect or consequential damages or
-- any damages whatsoever resulting from loss of use, data or profits, whether
-- in an action of contract, negligence or other tortious action, arising out
-- of or in connection with the use or performance of this software.
------------------------------------------------------------------------------

--/ if R1000 then
    package Integer_Text_Io is new Text_Io.Integer_Io (Integer);
--/ end if;

------------------------------------------------------------------------------
-- File_List - List of all open output files.
------------------------------------------------------------------------------
    type File_List_Rec;  
    type File_List is access File_List_Rec;

    type File_List_Rec is  
        record  
            Next      : File_List;  
            File      : Text_Io.File_Type;  
            Duplicate : Boolean;  
        end record;

--/ if Enable_Deallocation then
    pragma Enable_Deallocation (File_List);
--/ end if;

    procedure Free_File_List is new Unchecked_Deallocation (File_List_Rec,  
                                                            File_List);

    Current : File_List := null;

------------------------------------------------------------------------------
-- File_Line - Line of a file we are diff'ing.
------------------------------------------------------------------------------

    type String_Pointer is access String;

--/ if Enable_Deallocation then
    pragma Enable_Deallocation (String_Pointer);
--/ end if;

    procedure Free_String_Pointer is  
       new Unchecked_Deallocation (String, String_Pointer);

    type File_Line_Rec is  
        record  
            Line  : String_Pointer;  
            Hash  : S_Long;  
            Eop   : Boolean;  
            Blank : Boolean;  
        end record;

    type File_Line is access File_Line_Rec;

--/ if Enable_Deallocation then
    pragma Enable_Deallocation (File_Line);
--/ end if;

    type File_Line_Array is array (S_Natural range <>) of File_Line;  
    type File_Line_List  is access File_Line_Array;

--/ if Enable_Deallocation then
    pragma Enable_Deallocation (File_Line_List);
--/ end if;

    procedure Free_File_Line       is new Unchecked_Deallocation (File_Line_Rec,  
                                                                  File_Line);  
    procedure Free_File_Line_Array is  
       new Unchecked_Deallocation (File_Line_Array,  
                                   File_Line_List);

------------------------------------------------------------------------------
-- Wildcards
------------------------------------------------------------------------------

    type File_Name_Rec;  
    type File_Name is access File_Name_Rec;

    type File_Name_Rec is  
        record  
            Next : File_Name;  
            Name : String_Pointer;  
        end record;

--/ if Enable_Deallocation then
    pragma Enable_Deallocation (File_Name);
--/ end if;

    procedure Free_File_Name_Rec is new Unchecked_Deallocation (File_Name_Rec,  
                                                                File_Name);

    Name_List : File_Name;

--\f

    function To_String (Str : X_String) return String is  
        Stro : String (1 .. Str'Length) := Xlbt_String.To_String (Str);  
    begin  
        for I in Stro'Range loop  
            if Character'Pos (Stro (I)) not in 32 .. 127 then  
                return Stro (Stro'First .. I - 1) &  
                          '\' & Natural'Image (Character'Pos (Stro (I))) & '\' &  
                          To_String (Str (Str'First + S_Natural (I) ..  
                                             Str'Last));  
            end if;  
        end loop;  
        return Stro;  
    end To_String;

--\f

    procedure Free_File_Name (Name : in out File_Name) is
------------------------------------------------------------------------------
--  List    - Specfies the list to deallocatd
--
-- We deallocate all elements of the list and then the list itself.
------------------------------------------------------------------------------
    begin

        Free_String_Pointer (Name.Name);  
        Free_File_Name_Rec (Name);

    end Free_File_Name;

--\f

    procedure Free_File_Line_List (List : in out File_Line_List) is
------------------------------------------------------------------------------
--  List    - Specfies the list to deallocatd
--
-- We deallocate all elements of the list and then the list itself.
------------------------------------------------------------------------------
    begin

        for I in List'Range loop  
            if List (I) /= null then  
                Free_String_Pointer (List (I).Line);  
                Free_File_Line (List (I));  
            end if;  
        end loop;  
        Free_File_Line_Array (List);

    end Free_File_Line_List;

--\f

    procedure Put_Aux (Msg : String) is
------------------------------------------------------------------------------
--  Msg - Specifies the ::: error message to put out.
--
-- Put out "::: " and Msg to all active outputs regardless of Duplicate flag.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put (File.File, "::: ");  
            Text_Io.Put_Line (File.File, Msg);  
            File := File.Next;  
        end loop;  
        Text_Io.Put (Text_Io.Standard_Output, "::: ");  
        Text_Io.Put_Line (Text_Io.Standard_Output, Msg);

    end Put_Aux;

--\f

    procedure Put_Error (Msg : String) is
------------------------------------------------------------------------------
--  Msg - Specifies the *** error message to put out.
--
-- Put out "*** " and Msg to all active outputs regardless of Duplicate flag.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put (File.File, "*** ");  
            Text_Io.Put_Line (File.File, Msg);  
            File := File.Next;  
        end loop;  
        Text_Io.Put (Text_Io.Standard_Output, "*** ");  
        Text_Io.Put_Line (Text_Io.Standard_Output, Msg);

    end Put_Error;

--\f

    procedure Put_Exception (Msg : String) is
------------------------------------------------------------------------------
--  Msg - Specifies the %%% error message to put out.
--
-- Put out "%%% " and Msg to all active outputs regardless of Duplicate flag.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put (File.File, "*** ");  
            Text_Io.Put_Line (File.File, Msg);  
            File := File.Next;  
        end loop;  
        Text_Io.Put (Text_Io.Standard_Output, "*** ");  
        Text_Io.Put_Line (Text_Io.Standard_Output, Msg);

    end Put_Exception;

--\f

    procedure Push_Output (File      : String;  
                           Duplicate : Boolean := True) is
------------------------------------------------------------------------------
--  File        - Specifies the name of the new output file
--  Duplicate   - Specifies TRUE if output should go to all stacked outputs
--
-- Opens the file for writing and sets it so that it is used for future output.
--
-- Duplicate => FALSE will block normal output from duplication in "outer"
-- log files.  If another Push is done with Duplicate => TRUE then output
-- will go to that file and this one but no further because this one has
-- Duplicate => FALSE which blocks further output.
--
-- Put_Error and Put_Exception ignore the Duplicate flag.
------------------------------------------------------------------------------
        New_File : File_List := new File_List_Rec;  
    begin

----Create/Open the new output file.

        begin  
            Text_Io.Create (New_File.File, Text_Io.Out_File, File);  
            New_File.Duplicate := Duplicate;  
        exception  
            when others =>  
                begin  
                    Text_Io.Open (New_File.File, Text_Io.Out_File, File);  
                exception  
                    when others =>  
                        Free_File_List (New_File);  
                        Put_Error ("Failed to open output file [" &  
                                   File & "].");  
                        raise;  
                end;  
        end;

----Link the new file onto our list of files and make it the current output.

        New_File.Next := Current;  
        Current       := New_File;  
        Text_Io.Set_Output (New_File.File);

    end Push_Output;

--\f

    procedure Pop_Output is
------------------------------------------------------------------------------
-- Closes the current output file and reverts to the previous output file.
-- Raises Constraint_Error if there was no previous file.
------------------------------------------------------------------------------
        Old_File : File_List;  
    begin

----Make sure that we have an old file.

        if Current = null then  
            raise Constraint_Error;  
        end if;

----Close the old file.

        Text_Io.New_Line (Current.File);  
        Text_Io.Put_Line (Current.File, "End of log.");  
        Text_Io.Close (Current.File);

----Remove the old file from the list and free the storage.

        Old_File := Current;  
        Current  := Current.Next;  
        Free_File_List (Old_File);

----Set the current output file.

        if Current /= null then  
            Text_Io.Set_Output (Current.File);  
        else  
            Text_Io.Set_Output (Text_Io.Standard_Output);  
        end if;

    end Pop_Output;

--\f

    procedure Section (Name : String) is
------------------------------------------------------------------------------
--  Name    - Specifies the name of a "section" in the log file
--
-- Called within tests so that we can log "where we are" while running a test.
-- Some tests will have many "parts" and each part will start by identifying
-- itself to the log.  This helps when initially tracking down bugs that show
-- up when running the regression tests.
------------------------------------------------------------------------------
    begin

        New_Line;  
        Put ("=== Test Section => ");  
        Put_Line (Name);  
        New_Line;

    end Section;

--\f

    procedure New_Line (Spacing : Positive := 1) is
------------------------------------------------------------------------------
--  Spacing - Specifies the number of new-lines to produce
--
-- Called to go to a new line in the log file.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.New_Line (File.File, Text_Io.Positive_Count (Spacing));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Text_Io.New_Line (Text_Io.Standard_Output,  
                          Text_Io.Positive_Count (Spacing));

    end New_Line;

--\f

    procedure Set_Col (To : Positive) is
------------------------------------------------------------------------------
--  To  - Specifies the column to go to, 1..N
--
-- Used to put out column information in the log file.  Helps when you want
-- various things to line up in the log.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Set_Col (File.File, Text_Io.Positive_Count (To));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Text_Io.Set_Col (Text_Io.Standard_Output, Text_Io.Positive_Count (To));

    end Set_Col;

--\f

    procedure Put (Ch : Character) is
------------------------------------------------------------------------------
--  Ch  - Specifies the character to put out
--
-- Used to put one character into the log.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put (File.File, Ch);  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Text_Io.Put (Text_Io.Standard_Output, Ch);

    end Put;

--\f

    procedure Put (Str : String) is
------------------------------------------------------------------------------
--  Str - Specifies the string to put out
--
-- Used to put a string into the log.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put (File.File, Str);  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Text_Io.Put (Text_Io.Standard_Output, Str);

    end Put;

--\f

    procedure Put_Line (Str : String) is
------------------------------------------------------------------------------
--  Str - Specifies the string to put out
--
-- Used to put a string into the log and ends it in a new-line.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put_Line (File.File, Str);  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Text_Io.Put_Line (Text_Io.Standard_Output, Str);

    end Put_Line;

--\f

    procedure Putx (Str : X_String) is
------------------------------------------------------------------------------
--  Str - Specifies the string to put out
--
-- Used to put a string into the log.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put (File.File, To_String (Str));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Text_Io.Put (Text_Io.Standard_Output, To_String (Str));

    end Putx;

--\f

    procedure Putx_Line (Str : X_String) is
------------------------------------------------------------------------------
--  Str - Specifies the string to put out
--
-- Used to put a string into the log and ends it in a new-line.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Text_Io.Put_Line (File.File, To_String (Str));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Text_Io.Put_Line (Text_Io.Standard_Output, To_String (Str));

    end Putx_Line;

--\f

    procedure Put (Int   : Integer;  
                   Width : Natural  := 1;  
                   Base  : Positive := 10) is
------------------------------------------------------------------------------
--  Int     - Specifies the integer value
--  Width   - Specifies the width of the output
--  Base    - Specifies the base of the output
--
-- Used to put an integer into the log; base 10.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Integer_Text_Io.Put (File.File, Int, Text_Io.Field (Width),  
                                 Text_Io.Number_Base (Base));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Integer_Text_Io.Put (Text_Io.Standard_Output, Int,  
                             Text_Io.Field (Width), Text_Io.Number_Base (Base));

    end Put;

--\f

    procedure Hex (Int   : Integer;  
                   Width : Natural  := 1;  
                   Base  : Positive := 16) is
------------------------------------------------------------------------------
--  Int     - Specifies the integer value
--  Width   - Specifies the width of the output
--  Base    - Specifies the base of the output
--
-- Used to put an integer into the log; base 16.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            Integer_Text_Io.Put (File.File, Int, Text_Io.Field (Width),  
                                 Text_Io.Number_Base (Base));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        Integer_Text_Io.Put (Text_Io.Standard_Output, Int,  
                             Text_Io.Field (Width), Text_Io.Number_Base (Base));

    end Hex;

--\f

    procedure Put (Ul    : S_Long;  
                   Width : Natural  := 1;  
                   Base  : Positive := 10) is
------------------------------------------------------------------------------
--  Int     - Specifies the S_Long value
--  Width   - Specifies the width of the output
--  Base    - Specifies the base of the output
--
-- Used to put an S_Long into the log; base 10.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            S_Long_Io.Put (File.File, Ul, Text_Io.Field (Width),  
                           Text_Io.Number_Base (Base));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        S_Long_Io.Put (Text_Io.Standard_Output, Ul, Text_Io.Field (Width),  
                       Text_Io.Number_Base (Base));

    end Put;

--\f

    procedure Hex (Ul    : S_Long;  
                   Width : Natural  := 1;  
                   Base  : Positive := 16) is
------------------------------------------------------------------------------
--  Int     - Specifies the S_Long value
--  Width   - Specifies the width of the output
--  Base    - Specifies the base of the output
--
-- Used to put an S_Long into the log; base 16.
------------------------------------------------------------------------------
        File : File_List := Current;  
    begin

        while File /= null loop  
            S_Long_Io.Put (File.File, Ul, Text_Io.Field (Width),  
                           Text_Io.Number_Base (Base));  
            if not File.Duplicate then  
                return;  
            end if;  
            File := File.Next;  
        end loop;  
        S_Long_Io.Put (Text_Io.Standard_Output, Ul, Text_Io.Field (Width),  
                       Text_Io.Number_Base (Base));

    end Hex;

--\f

    function Append_File_Extension (File      : String;  
                                    Extension : String) return String is
------------------------------------------------------------------------------
--  File        - Specifies the basic name of the file, eg. "foobar".
--  Extension   - Specifies the extension to give to the file, eg. "log".
--
-- Adds the Extension to the File with the appropriate system-dependent
-- character(s) in between.  Eg. "foobar.log" or "foobar_log"
------------------------------------------------------------------------------
    begin

--/ if R1000 then

        return File & '_' & Extension;

--/ elsif Unix then
--//
--//         return File & '.' & Extension;
--//
--/ else
--//
--//   return need_something_here;
--//
--/ end if;

    end Append_File_Extension;

--\f

    function File_Context (File : String) return String is
------------------------------------------------------------------------------
--  File    - Specifies a file name
--
-- Returns the path portion of the name.  Returns something like "$" or "."
-- for files that have no explicit path.
------------------------------------------------------------------------------
    begin

--/ if R1000 then

        declare  
            Prefix : constant String := Directory_Tools.Naming.Prefix (File);  
        begin  
            if Prefix = "" then  
                return "$";  
            else  
                return Directory_Tools.Naming.Prefix (File);  
            end if;  
        end;

--/ elsif Unix then
--//
--//         for I in reverse File'Range loop
--//             if File (I) = '/' then
--//                 return File (File'First .. I - 1);
--//             end if;
--//         end loop;
--//         return ".";
--//
--/ else
--//
--//         Need_Something_Here;
--//
--/ end if;

    end File_Context;

--\f

--/ if R1000 then

    procedure File_Delete (File : String) is
------------------------------------------------------------------------------
--  File    - Specifies the file to delete
--
-- Called to delete a particular file.
------------------------------------------------------------------------------
        Handle : Directory_Tools.Object.Handle;  
        Status : Directory_Tools.Object.Error_Code;  
    begin

----First we locate the object.

        Handle := Directory_Tools.Naming.Resolution (File);  
        if Directory_Tools.Object.Is_Bad (Handle) then  
            Put_Error ("Could not find [" & File & "] to delete it.");  
            Put_Error ("Error: " & Directory_Tools.Object.Message (Handle));  
            raise Test_Io_Error;  
        end if;

----Second we delete the object.

        Directory_Tools.Any_Object.Delete (Handle, Status);  
        if Directory_Tools.Object.Is_Bad (Status) then  
            Put_Error ("Could not delete [" & File & "].");  
            Put_Error ("Error: " & Directory_Tools.Object.Message (Handle));  
            raise Test_Io_Error;  
        end if;

    end File_Delete;

--/ end if; -- R1000

--\f

--/ if TeleGen2 and then Unix then
--//
--//     procedure File_Delete (File : String) is
--// ------------------------------------------------------------------------------
--// --  File    - Specifies the file to delete
--// --
--// -- Called to delete a particular file.
--// ------------------------------------------------------------------------------
--//     begin
--//
--//         File_Ops.Unlink (File);
--//
--//     end File_Delete;
--//
--/ end if; -- TeleGen2 and then Unix

--\f

    function File_Exists (File : String) return Boolean is
------------------------------------------------------------------------------
--  File    - Specifies the name of the file to check for
--
-- Called to check to see whether or not a file exists and is readable.
------------------------------------------------------------------------------
        Old_File : Text_Io.File_Type;  
    begin

        begin  
            Text_Io.Open (Old_File, Text_Io.In_File, File);  
            Text_Io.Close (Old_File);  
            return True;  
        exception  
            when others =>  
                return False;  
        end;

    end File_Exists;

--\f

    procedure Read_Line (File  :     Text_Io.File_Type;  
                         Line  : out String;  
                         Linei : out Natural;  
                         Eop   : out Boolean;  
                         Eof   : out Boolean) is
------------------------------------------------------------------------------
--  File    - Specifies the file to read
--  Line    - Receives the next line of input
--  Linei   - Receives the length of the next line
--  Eop     - Receives TRUE if this line is the last line of a page
--  Eof     - Receives TRUE if we just encountered EOF and Line is empty
--
-- Called to read the next line of input from a file.
------------------------------------------------------------------------------
    begin

        Text_Io.Get_Line (File, Line, Linei);  
        Eop := Text_Io.End_Of_Page (File);  
        Eof := False;

    exception

        when Text_Io.End_Error =>  
            Linei := 0;  
            Eop   := False;  
            Eof   := True;

    end Read_Line;

--\f

    function Equal_Uc (Str1 : String;  
                       Str2 : String) return Boolean is
------------------------------------------------------------------------------
--  Str1    - Specifies the first string
--  Str2    - Specifies the second string
--
-- Called to compare two strings without regard to the case of the strings.
-- Returns TRUE if they are equal.
------------------------------------------------------------------------------
        C1 : Character;  
        C2 : Character;  
    begin

        if Str1'Length /= Str2'Length then  
            return False;  
        end if;  
        for I in reverse Natural range 0 .. Str1'Length - 1 loop  
            C1 := Str1 (Str1'First + I);  
            C2 := Str2 (Str2'First + I);  
            if C1 /= C2 then  
                if C1 in 'a' .. 'z' then  
                    if C2 in 'A' .. 'Z' then
                        ----C1 and C2 are both letters.
                        if Character'Pos (C1) /=  
                           Character'Pos (C2) - (Character'Pos ('A') -  
                                                 Character'Pos ('a')) then  
                            return False;  
                        end if;  
                    else
                        ----C1 is a letter but C2 is not.
                        return False;  
                    end if;  
                elsif C1 in 'A' .. 'Z' then  
                    if C2 in 'a' .. 'z' then
                        ----C1 and C2 are both letters.
                        if Character'Pos (C1) /=  
                           Character'Pos (C2) - (Character'Pos ('a') -  
                                                 Character'Pos ('A')) then  
                            return False;  
                        end if;  
                    else
                        ----C1 is a letter but C2 is not.
                        return False;  
                    end if;  
                else
                    ----C1 is not a letter and C1 /= C2.
                    return False;  
                end if;  
            end if;  
        end loop;  
        return True;

    end Equal_Uc;

--\f

    function Is_Blank (Str : String) return Boolean is
------------------------------------------------------------------------------
--  Str     - Specifies the string to check
--
-- Returns TRUE if Str is empty or contains only ' ' and/or Ascii.Ht.
------------------------------------------------------------------------------
        C : Character;  
    begin

        for I in Str'Range loop  
            C := Str (I);  
            if C /= ' ' and then C /= Ascii.Ht then  
                return False;  
            end if;  
        end loop;  
        return True;

    end Is_Blank;

--\f

    function Files_Equal (File1              : String;  
                          File2              : String;  
                          Ignore_Case        : Boolean;  
                          Ignore_Blank_Lines : Boolean) return Boolean is
------------------------------------------------------------------------------
--  File1   - Specifies the name of the first file
--  File2   - Specifies the name of the second file
--
-- We do a "fast" comparison of the two files.  Our only concern is 'equality'.
-- call the File_Difference routine for a diff output.
------------------------------------------------------------------------------
        F1     : Text_Io.File_Type;  
        F2     : Text_Io.File_Type;  
        Result : Boolean := False;

        Line1  : String (1 .. 1024);  
        Line2  : String (1 .. 1024);  
        Line1i : Natural;  
        Line2i : Natural;  
        Eop1   : Boolean;  
        Eop2   : Boolean;  
        Eof1   : Boolean := False;  
        Eof2   : Boolean := False;

    begin

----Open the files for reading.

        begin  
            Text_Io.Open (F1, Text_Io.In_File, File1);  
        exception  
            when others =>  
                Put_Error ("Could not open file to compare [" & File1 & "}.");  
                return False;  
        end;  
        begin  
            Text_Io.Open (F2, Text_Io.In_File, File2);  
        exception  
            when others =>  
                Put_Error ("Could not open file to compare [" & File2 & "}.");  
                Text_Io.Close (F1);  
                return False;  
        end;

----Loop reading lines until we get to something that is different.

        if Ignore_Blank_Lines then

----We are ignoring blank lines and case differences.

            if Ignore_Case then  
                loop  
                    loop  
                        Read_Line (F1, Line1, Line1i, Eop1, Eof1);  
                        if Eof1 or else not Is_Blank (Line1 (1 .. Line1i)) then  
                            exit;  
                        end if;  
                    end loop;  
                    loop  
                        Read_Line (F2, Line2, Line2i, Eop2, Eof2);  
                        if Eof2 or else not Is_Blank (Line2 (1 .. Line2i)) then  
                            exit;  
                        end if;  
                    end loop;  
                    if (Line1 (1 .. Line1i) /= Line2 (1 .. Line2i) and then  
                        not Equal_Uc (Line1 (1 .. Line1i),  
                                      Line2 (1 .. Line2i))) or else  
                       Eop1 /= Eop2 or else  
                       Eof1 /= Eof2 then  
                        Result := False;  
                        exit;  
                    elsif Eof1 then  
                        Result := True;  
                        exit;  
                    end if;  
                end loop;

----We are ignoring blank lines but not case differences.

            else  
                loop  
                    loop  
                        Read_Line (F1, Line1, Line1i, Eop1, Eof1);  
                        if Eof1 or else not Is_Blank (Line1 (1 .. Line1i)) then  
                            exit;  
                        end if;  
                    end loop;  
                    loop  
                        Read_Line (F2, Line2, Line2i, Eop2, Eof2);  
                        if Eof2 or else not Is_Blank (Line2 (1 .. Line2i)) then  
                            exit;  
                        end if;  
                    end loop;  
                    if Line1 (1 .. Line1i) /= Line2 (1 .. Line2i) or else  
                       Eop1 /= Eop2 or else  
                       Eof1 /= Eof2 then  
                        Result := False;  
                        exit;  
                    elsif Eof1 then  
                        Result := True;  
                        exit;  
                    end if;  
                end loop;  
            end if;

----We are not ignoring blank lines.

        else

----We are not ignoring blank lines but we are ignoring case differences.

            if Ignore_Case then  
                loop  
                    Read_Line (F1, Line1, Line1i, Eop1, Eof1);  
                    Read_Line (F2, Line2, Line2i, Eop2, Eof2);  
                    if (Line1 (1 .. Line1i) /= Line2 (1 .. Line2i) and then  
                        not Equal_Uc (Line1 (1 .. Line1i),  
                                      Line2 (1 .. Line2i))) or else  
                       Eop1 /= Eop2 or else  
                       Eof1 /= Eof2 then  
                        Result := False;  
                        exit;  
                    elsif Eof1 then  
                        Result := True;  
                        exit;  
                    end if;  
                end loop;

----We are not ignoring blank lines or case differences.

            else  
                loop  
                    Read_Line (F1, Line1, Line1i, Eop1, Eof1);  
                    Read_Line (F2, Line2, Line2i, Eop2, Eof2);  
                    if Line1 (1 .. Line1i) /= Line2 (1 .. Line2i) or else  
                       Eop1 /= Eop2 or else  
                       Eof1 /= Eof2 then  
                        Result := False;  
                        exit;  
                    elsif Eof1 then  
                        Result := True;  
                        exit;  
                    end if;  
                end loop;  
            end if;  
        end if;

----Close the files and return our result.

        Text_Io.Close (F1);  
        Text_Io.Close (F2);  
        return Result;

    exception

        when others =>  
            Put_Line ("%%% Unexpected exception in Text_Io.Files_Equal?");  
            Text_Io.Close (F1);  
            Text_Io.Close (F2);  
            return False;

    end Files_Equal;

--\f

    function Hash (Str         : String;  
                   Ignore_Case : Boolean) return S_Long is
------------------------------------------------------------------------------
--  Str         - Specifies the string to hash
--  Ignore_Case - Specifies TRUE if we are ignoring case
--
-- Computes a hash function for a string.  Could overflow for very long strings
-- but lines are limited to 1024 characters so it won't in practice.
------------------------------------------------------------------------------
        H : S_Long  := 0;  
        I : Natural := Str'First;  
        C : Character;  
    begin

----Do it this way if we are not ignoring case.

        if not Ignore_Case then  
            loop  
                if I > Str'Last then  
                    exit;  
                end if;  
                H := H + Character'Pos (Str (I));  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                H := H + Character'Pos (Str (I)) * 2 ** 4;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                H := H + Character'Pos (Str (I)) * 2 ** 8;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                H := H + Character'Pos (Str (I)) * 2 ** 12;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                H := H + Character'Pos (Str (I)) * 2 ** 16;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                H := H + Character'Pos (Str (I)) * 2 ** 20;  
                I := I + 1;  
            end loop;

----Do it this way if we are not ignoring case.

        else  
            loop  
                if I > Str'Last then  
                    exit;  
                end if;  
                C := Str (I);  
                if C in 'a' .. 'z' then  
                    C := Character'Val (Character'Pos (C) -  
                                        (Character'Pos ('a') -  
                                         Character'Pos ('A')));  
                end if;  
                H := H + Character'Pos (C);  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                C := Str (I);  
                if C in 'a' .. 'z' then  
                    C := Character'Val (Character'Pos (C) -  
                                        (Character'Pos ('a') -  
                                         Character'Pos ('A')));  
                end if;  
                H := H + Character'Pos (C) * 2 ** 4;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                C := Str (I);  
                if C in 'a' .. 'z' then  
                    C := Character'Val (Character'Pos (C) -  
                                        (Character'Pos ('a') -  
                                         Character'Pos ('A')));  
                end if;  
                H := H + Character'Pos (C) * 2 ** 8;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                C := Str (I);  
                if C in 'a' .. 'z' then  
                    C := Character'Val (Character'Pos (C) -  
                                        (Character'Pos ('a') -  
                                         Character'Pos ('A')));  
                end if;  
                H := H + Character'Pos (C) * 2 ** 12;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                C := Str (I);  
                if C in 'a' .. 'z' then  
                    C := Character'Val (Character'Pos (C) -  
                                        (Character'Pos ('a') -  
                                         Character'Pos ('A')));  
                end if;  
                H := H + Character'Pos (C) * 2 ** 16;  
                I := I + 1;  
                if I > Str'Last then  
                    exit;  
                end if;  
                C := Str (I);  
                if C in 'a' .. 'z' then  
                    C := Character'Val (Character'Pos (C) -  
                                        (Character'Pos ('a') -  
                                         Character'Pos ('A')));  
                end if;  
                H := H + Character'Pos (C) * 2 ** 20;  
                I := I + 1;  
            end loop;  
        end if;  
        return H;

    end Hash;

--\f

    procedure Read_File (File        :        Text_Io.File_Type;  
                         Line_List   : in out File_Line_List;  
                         Line_Listi  : in out S_Natural;  
                         Ignore_Case :        Boolean) is
------------------------------------------------------------------------------
--  File        - Specifies the file to read.
--  Line_List   - Receives the list of lines read
--  Line_Listi  - Receives the number of lines in the list
--  Ignore_Case - Specifies TRUE if the hash is to ignore case
--
-- Called to read an entire file into memory.
------------------------------------------------------------------------------
        Line  : String (1 .. 1024);  
        Linei : Natural;  
        Eop   : Boolean;  
        Eof   : Boolean;  
    begin

----Initialize our output array.


        Line_List  := new File_Line_Array (1 .. 1000);  
        Line_Listi := 0;

----Read the file to the end.

        loop  
            Read_Line (File, Line, Linei, Eop, Eof);  
            if Eof then  
                return;  
            end if;  
            if Line_Listi = Line_List'Last then  
                declare  
                    Newl : File_Line_List :=  
                       new File_Line_Array (1 .. Line_List'Length * 2);  
                begin  
                    Newl (1 .. Line_List'Length) := Line_List.all;  
                    Free_File_Line_Array (Line_List);  
                    Line_List := Newl;  
                end;  
            end if;  
            Line_Listi             := Line_Listi + 1;  
            Line_List (Line_Listi) :=  
               new File_Line_Rec'(Line => new String'(Line (1 .. Linei)),  
                                  Hash => Hash (Line (1 .. Linei), Ignore_Case),  
                                  Eop => Eop,  
                                  Blank => Is_Blank (Line (1 .. Linei)));  
        end loop;

    end Read_File;

--\f

    procedure Regions_Differ (List1 : File_Line_Array;  
                              List2 : File_Line_Array) is
------------------------------------------------------------------------------
--  List1   - Specifies the lines in file 1 that don't match
--  List2   - Specifies the lines in file 2 that don't match
--
-- Called when we (may) have a region of lines in file1 that don't match some
-- region of lines in file2.  Report them to the log.
------------------------------------------------------------------------------
    begin

----If there are no lines from File1 then we either have no difference or else
--  we have an Insert.

        if List1'Length = 0 then  
            if List2'Length = 0 then  
                return;     -- Nothing to report.
            end if;  
            New_Line;  
            Put ("--- Insert ");  
            Put (List1'First);  
            Put (",");  
            Put (S_Long (List2'Length));  
            New_Line;  
            for I in List2'Range loop  
                Put ("> ");  
                Put_Line (List2 (I).Line.all);  
            end loop;  
            return;  
        end if;

----If there are no lines from File2 then we have a Delete.

        if List2'Length = 0 then  
            New_Line;  
            Put ("--- Delete ");  
            Put (List1'First);  
            Put (",");  
            Put (S_Long (List1'Length));  
            New_Line;  
            for I in List1'Range loop  
                Put ("< ");  
                Put_Line (List1 (I).Line.all);  
            end loop;  
            return;  
        end if;

----Otherwise we have a change.

        New_Line;  
        Put ("--- Change ");  
        Put (List1'First);  
        Put (",");  
        Put (S_Long (List1'Length));  
        Put (",");  
        Put (S_Long (List2'Length));  
        New_Line;  
        for I in List1'Range loop  
            Put ("< ");  
            Put_Line (List1 (I).Line.all);  
        end loop;  
        Put_Line ("--- ------");  
        for I in List2'Range loop  
            Put ("> ");  
            Put_Line (List2 (I).Line.all);  
        end loop;  
        return;

    end Regions_Differ;

--\f

    procedure Diff_Cb (List1 : File_Line_Array;  
                       List2 : File_Line_Array) is
------------------------------------------------------------------------------
--  List1               - Specifies the lines from file 1
--  List2               - Specifies the lines from file 2
--
-- Called to perform the main work of the Files_Diff routine.
--
-- Ignore_Case        => FALSE
-- Ignore_Blank_Lines => FALSE
------------------------------------------------------------------------------
        Line1       : File_Line;  
        Line2       : File_Line;  
        Line1i      : S_Natural := 0;  
        Line2i      : S_Natural := 0;  
        Last_Line1i : S_Natural := 0;  
        Last_Line2i : S_Natural := 0;  
        Tmp1        : S_Natural;  
        Tmp2        : S_Natural;  
    begin

----Check our assumptions.

        if List1'First /= List2'First then  
            raise Program_Error;        -- Our assumption fails.
        end if;

----Match lines starting at the top until we don't match any more.

        for I in List1'Range loop  
            if I > List2'Last then  
                exit;  
            end if;  
            Line1 := List1 (I);  
            Line2 := List2 (I);  
            if Line1.Hash /= Line2.Hash or else  
               Line1.Line.all /= Line2.Line.all then  
                exit;  
            end if;  
            Last_Line1i := I;  
            Last_Line2i := I;  
        end loop;

----Loop until we have gone over the entirety of both lists.

        Main_Diff_Loop:  
            loop

----Loop until we find a non-blank Line1 that has a matching Line2.

                Line1_Line2_Loop:  
                    loop

----Loop until we find the next non-blank Line1 of any flavor.

                        for I in Line1i + 1 .. List1'Last loop  
                            if not List1 (I).Blank then  
                                Line1  := List1 (I);  
                                Line1i := I;  
                                goto Have_Line1;  
                            end if;  
                        end loop;  
                        exit Main_Diff_Loop;    -- Can't find a next Line1.

----We get here when we have a Line1 and we need to find a matchine Line2.

                        <<Have_Line1>> null;  
                        for I in Line2i + 1 .. List2'Last loop  
                            Line2 := List2 (I);  
                            if not Line2.Blank then  
                                if Line1.Hash = Line2.Hash and then  
                                   Line1.Line.all = Line2.Line.all then  
                                    Line2i := I;  
                                    exit Line1_Line2_Loop;  
                                end if;  
                            end if;  
                        end loop;

----If we get here then there is no Line2 that matches Line1.  Loop and go
--  after the next non-blank Line1.

                    end loop Line1_Line2_Loop;

----Come here when we have Line1 = Line2 and we now want to expand the
--  region of match.  Loop backwards looking for a line that doesn't match.
--  Then report that region of difference.

                <<Have_A_Match>> null;  
                Tmp1 := Line1i;  
                Tmp2 := Line2i;  
                while Line1i - 1 > Last_Line1i and then  
                         Line2i - 1 > Last_Line2i loop  
                    Line1 := List1 (Line1i - 1);  
                    Line2 := List2 (Line2i - 1);  
                    if Line1.Hash /= Line2.Hash or else  
                       Line1.Line.all /= Line2.Line.all then  
                        exit;  
                    end if;  
                    Line1i := Line1i - 1;  
                    Line2i := Line2i - 1;  
                end loop;  
                Regions_Differ (List1 (Last_Line1i + 1 .. Line1i - 1),  
                                List2 (Last_Line2i + 1 .. Line2i - 1));

----Now loop forwards looking for a line that doesn't match.  That defines
--  our next starting point.

                Line1i := Tmp1;  
                Line2i := Tmp2;  
                while Line1i < List1'Last and then  
                         Line2i < List2'Last loop  
                    Line1 := List1 (Line1i + 1);  
                    Line2 := List2 (Line2i + 1);  
                    if Line1.Hash /= Line2.Hash or else  
                       Line1.Line.all /= Line2.Line.all then  
                        exit;  
                    end if;  
                    Line1i := Line1i + 1;  
                    Line2i := Line2i + 1;  
                end loop;  
                Last_Line1i := Line1i;  
                Last_Line2i := Line2i;

----Loop and go after the next matching region.

            end loop Main_Diff_Loop;

----Come here when we can't find a next-non-blank Line1.

        Regions_Differ (List1 (Last_Line1i + 1 .. List1'Last),  
                        List2 (Last_Line2i + 1 .. List2'Last));

    end Diff_Cb;

--\f

    procedure Diff_Ci (List1 : File_Line_Array;  
                       List2 : File_Line_Array) is
------------------------------------------------------------------------------
--  List1               - Specifies the lines from file 1
--  List2               - Specifies the lines from file 2
--
-- Called to perform the main work of the Files_Diff routine.
--
-- Ignore_Case        => FALSE
-- Ignore_Blank_Lines => TRUE
------------------------------------------------------------------------------
        Line1       : File_Line;  
        Line2       : File_Line;  
        Line1i      : S_Natural := 0;  
        Line2i      : S_Natural := 0;  
        Last_Line1i : S_Natural := 0;  
        Last_Line2i : S_Natural := 0;  
        Tmp1        : S_Natural;  
        Tmp2        : S_Natural;  
    begin

----Check our assumptions.

        if List1'First /= List2'First then  
            raise Program_Error;        -- Our assumption fails.
        end if;

----Match lines starting at the top until we don't match any more.

        Pre_Diff_Loop:  
            loop  
                loop  
                    if Last_Line1i = List1'Last then  
                        exit Pre_Diff_Loop;  
                    elsif not List1 (Last_Line1i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line1i := Last_Line1i + 1;  
                end loop;  
                Line1 := List1 (Last_Line1i + 1);  
                loop  
                    if Last_Line2i = List1'Last then  
                        exit Pre_Diff_Loop;  
                    elsif not List1 (Last_Line2i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line2i := Last_Line2i + 1;  
                end loop;  
                Line2 := List1 (Last_Line2i + 1);  
                if Line1.Hash /= Line2.Hash or else  
                   Line1.Line.all /= Line2.Line.all then  
                    exit;  
                end if;  
                Last_Line1i := Last_Line1i + 1;  
                Last_Line2i := Last_Line2i + 1;  
            end loop Pre_Diff_Loop;

----Loop until we have gone over the entirety of both lists.

        Main_Diff_Loop:  
            loop

----Loop until we find a non-blank Line1 that has a matching Line2.

                Line1_Line2_Loop:  
                    loop

----Loop until we find the next non-blank Line1 of any flavor.

                        for I in Line1i + 1 .. List1'Last loop  
                            if not List1 (I).Blank then  
                                Line1  := List1 (I);  
                                Line1i := I;  
                                goto Have_Line1;  
                            end if;  
                        end loop;  
                        exit Main_Diff_Loop;    -- Can't find a next Line1.

----We get here when we have a Line1 and we need to find a matchine Line2.

                        <<Have_Line1>> null;  
                        for I in Line2i + 1 .. List2'Last loop  
                            Line2 := List2 (I);  
                            if not Line2.Blank then  
                                if Line1.Hash = Line2.Hash and then  
                                   Line1.Line.all = Line2.Line.all then  
                                    Line2i := I;  
                                    exit Line1_Line2_Loop;  
                                end if;  
                            end if;  
                        end loop;

----If we get here then there is no Line2 that matches Line1.  Loop and go
--  after the next non-blank Line1.

                    end loop Line1_Line2_Loop;

----Come here when we have Line1 = Line2 and we now want to expand the
--  region of match.  Loop backwards looking for a line that doesn't match.
--  Then report that region of difference.

                <<Have_A_Match>> null;  
                Tmp1 := Line1i;  
                Tmp2 := Line2i;

----Skip backwards from the match looking for lines that aren't blank and which
--  don't match.

                Post_Diff_Loop1:  
                    loop  
                        loop  
                            if Line1i - 1 <= Last_Line1i then  
                                exit Post_Diff_Loop1;  
                            end if;  
                            Line1 := List1 (Line1i - 1);  
                            if not Line1.Blank then  
                                exit;  
                            end if;  
                            Line1i := Line1i - 1;  
                        end loop;  
                        loop  
                            if Line2i - 1 <= Last_Line2i then  
                                exit Post_Diff_Loop1;  
                            end if;  
                            Line2 := List2 (Line2i - 1);  
                            if not Line2.Blank then  
                                exit;  
                            end if;  
                            Line2i := Line2i - 1;  
                        end loop;  
                        if Line1.Hash /= Line2.Hash or else  
                           Line1.Line.all /= Line2.Line.all then  
                            exit Post_Diff_Loop1;  
                        end if;  
                        Line1i := Line1i - 1;  
                        Line2i := Line2i - 1;  
                    end loop Post_Diff_Loop1;

----Skip blanks at the start of the difference regions.

                while Last_Line1i + 1 < Line1i - 1 loop  
                    if not List1 (Last_Line1i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line1i := Last_Line1i + 1;  
                end loop;  
                while Last_Line2i + 1 < Line2i - 1 loop  
                    if not List1 (Last_Line2i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line2i := Last_Line2i + 1;  
                end loop;  
                Regions_Differ (List1 (Last_Line1i + 1 .. Line1i - 1),  
                                List2 (Last_Line2i + 1 .. Line2i - 1));

----Now loop forwards looking for a line that doesn't match.  That defines
--  our next starting point.

                Line1i := Tmp1;  
                Line2i := Tmp2;  
                Post_Diff_Loop2:  
                    loop  
                        loop  
                            if Line1i >= List1'Last then  
                                exit Post_Diff_Loop2;  
                            end if;  
                            Line1 := List1 (Line1i + 1);  
                            if not Line1.Blank then  
                                exit;  
                            end if;  
                            Line1i := Line1i + 1;  
                        end loop;  
                        loop  
                            if Line2i >= List2'Last then  
                                exit Post_Diff_Loop2;  
                            end if;  
                            Line2 := List2 (Line2i + 1);  
                            if not Line2.Blank then  
                                exit;  
                            end if;  
                            Line2i := Line2i + 1;  
                        end loop;  
                        if Line1.Hash /= Line2.Hash or else  
                           Line1.Line.all /= Line2.Line.all then  
                            exit Post_Diff_Loop2;  
                        end if;  
                        Line1i := Line1i + 1;  
                        Line2i := Line2i + 1;  
                    end loop Post_Diff_Loop2;  
                Last_Line1i := Line1i;  
                Last_Line2i := Line2i;

----Loop and go after the next matching region.

            end loop Main_Diff_Loop;

----Come here when we can't find a next-non-blank Line1.

        while Last_Line1i + 1 < List1'Last loop  
            if not List1 (Last_Line1i + 1).Blank then  
                exit;  
            end if;  
            Last_Line1i := Last_Line1i + 1;  
        end loop;  
        while Last_Line2i + 1 < List2'Last loop  
            if not List1 (Last_Line2i + 1).Blank then  
                exit;  
            end if;  
            Last_Line2i := Last_Line2i + 1;  
        end loop;  
        Regions_Differ (List1 (Last_Line1i + 1 .. List1'Last),  
                        List2 (Last_Line2i + 1 .. List2'Last));

    end Diff_Ci;

--\f

    procedure Diff_Ib (List1 : File_Line_Array;  
                       List2 : File_Line_Array) is
------------------------------------------------------------------------------
--  List1               - Specifies the lines from file 1
--  List2               - Specifies the lines from file 2
--
-- Called to perform the main work of the Files_Diff routine.
--
-- Ignore_Case        => TRUE
-- Ignore_Blank_Lines => FALSE
------------------------------------------------------------------------------
        Line1       : File_Line;  
        Line2       : File_Line;  
        Line1i      : S_Natural := 0;  
        Line2i      : S_Natural := 0;  
        Last_Line1i : S_Natural := 0;  
        Last_Line2i : S_Natural := 0;  
        Tmp1        : S_Natural;  
        Tmp2        : S_Natural;  
    begin

----Check our assumptions.

        if List1'First /= List2'First then  
            raise Program_Error;        -- Our assumption fails.
        end if;

----Match lines starting at the top until we don't match any more.

        for I in List1'Range loop  
            if I > List2'Last then  
                exit;  
            end if;  
            Line1 := List1 (I);  
            Line2 := List2 (I);  
            if Line1.Hash /= Line2.Hash or else  
               not Equal_Uc (Line1.Line.all, Line2.Line.all) then  
                exit;  
            end if;  
            Last_Line1i := I;  
            Last_Line2i := I;  
        end loop;

----Loop until we have gone over the entirety of both lists.

        Main_Diff_Loop:  
            loop

----Loop until we find a non-blank Line1 that has a matching Line2.

                Line1_Line2_Loop:  
                    loop

----Loop until we find the next non-blank Line1 of any flavor.

                        for I in Line1i + 1 .. List1'Last loop  
                            if not List1 (I).Blank then  
                                Line1  := List1 (I);  
                                Line1i := I;  
                                goto Have_Line1;  
                            end if;  
                        end loop;  
                        exit Main_Diff_Loop;    -- Can't find a next Line1.

----We get here when we have a Line1 and we need to find a matchine Line2.

                        <<Have_Line1>> null;  
                        for I in Line2i + 1 .. List2'Last loop  
                            Line2 := List2 (I);  
                            if not Line2.Blank then  
                                if Line1.Hash = Line2.Hash and then  
                                   Equal_Uc (Line1.Line.all,  
                                             Line2.Line.all) then  
                                    Line2i := I;  
                                    exit Line1_Line2_Loop;  
                                end if;  
                            end if;  
                        end loop;

----If we get here then there is no Line2 that matches Line1.  Loop and go
--  after the next non-blank Line1.

                    end loop Line1_Line2_Loop;

----Come here when we have Line1 = Line2 and we now want to expand the
--  region of match.  Loop backwards looking for a line that doesn't match.
--  Then report that region of difference.

                <<Have_A_Match>> null;  
                Tmp1 := Line1i;  
                Tmp2 := Line2i;  
                while Line1i - 1 > Last_Line1i and then  
                         Line2i - 1 > Last_Line2i loop  
                    Line1 := List1 (Line1i - 1);  
                    Line2 := List2 (Line2i - 1);  
                    if Line1.Hash /= Line2.Hash or else  
                       not Equal_Uc (Line1.Line.all, Line2.Line.all) then  
                        exit;  
                    end if;  
                    Line1i := Line1i - 1;  
                    Line2i := Line2i - 1;  
                end loop;  
                Regions_Differ (List1 (Last_Line1i + 1 .. Line1i - 1),  
                                List2 (Last_Line2i + 1 .. Line2i - 1));

----Now loop forwards looking for a line that doesn't match.  That defines
--  our next starting point.

                Line1i := Tmp1;  
                Line2i := Tmp2;  
                while Line1i < List1'Last and then  
                         Line2i < List2'Last loop  
                    Line1 := List1 (Line1i + 1);  
                    Line2 := List2 (Line2i + 1);  
                    if Line1.Hash /= Line2.Hash or else  
                       not Equal_Uc (Line1.Line.all, Line2.Line.all) then  
                        exit;  
                    end if;  
                    Line1i := Line1i + 1;  
                    Line2i := Line2i + 1;  
                end loop;  
                Last_Line1i := Line1i;  
                Last_Line2i := Line2i;

----Loop and go after the next matching region.

            end loop Main_Diff_Loop;

----Come here when we can't find a next-non-blank Line1.

        Regions_Differ (List1 (Last_Line1i + 1 .. List1'Last),  
                        List2 (Last_Line2i + 1 .. List2'Last));

    end Diff_Ib;

--\f

    procedure Diff_Ii (List1 : File_Line_Array;  
                       List2 : File_Line_Array) is
------------------------------------------------------------------------------
--  List1               - Specifies the lines from file 1
--  List2               - Specifies the lines from file 2
--
-- Called to perform the main work of the Files_Diff routine.
--
-- Ignore_Case        => TRUE
-- Ignore_Blank_Lines => TRUE
------------------------------------------------------------------------------
        Line1       : File_Line;  
        Line2       : File_Line;  
        Line1i      : S_Natural := 0;  
        Line2i      : S_Natural := 0;  
        Last_Line1i : S_Natural := 0;  
        Last_Line2i : S_Natural := 0;  
        Tmp1        : S_Natural;  
        Tmp2        : S_Natural;  
    begin

----Check our assumptions.

        if List1'First /= List2'First then  
            raise Program_Error;        -- Our assumption fails.
        end if;

----Match lines starting at the top until we don't match any more.

        Pre_Diff_Loop:  
            loop  
                loop  
                    if Last_Line1i = List1'Last then  
                        exit Pre_Diff_Loop;  
                    elsif not List1 (Last_Line1i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line1i := Last_Line1i + 1;  
                end loop;  
                Line1 := List1 (Last_Line1i + 1);  
                loop  
                    if Last_Line2i = List1'Last then  
                        exit Pre_Diff_Loop;  
                    elsif not List1 (Last_Line2i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line2i := Last_Line2i + 1;  
                end loop;  
                Line2 := List1 (Last_Line2i + 1);  
                if Line1.Hash /= Line2.Hash or else  
                   not Equal_Uc (Line1.Line.all, Line2.Line.all) then  
                    exit;  
                end if;  
                Last_Line1i := Last_Line1i + 1;  
                Last_Line2i := Last_Line2i + 1;  
            end loop Pre_Diff_Loop;

----Loop until we have gone over the entirety of both lists.

        Main_Diff_Loop:  
            loop

----Loop until we find a non-blank Line1 that has a matching Line2.

                Line1_Line2_Loop:  
                    loop

----Loop until we find the next non-blank Line1 of any flavor.

                        for I in Line1i + 1 .. List1'Last loop  
                            if not List1 (I).Blank then  
                                Line1  := List1 (I);  
                                Line1i := I;  
                                goto Have_Line1;  
                            end if;  
                        end loop;  
                        exit Main_Diff_Loop;    -- Can't find a next Line1.

----We get here when we have a Line1 and we need to find a matchine Line2.

                        <<Have_Line1>> null;  
                        for I in Line2i + 1 .. List2'Last loop  
                            Line2 := List2 (I);  
                            if not Line2.Blank then  
                                if Line1.Hash = Line2.Hash and then  
                                   Equal_Uc (Line1.Line.all,  
                                             Line2.Line.all) then  
                                    Line2i := I;  
                                    exit Line1_Line2_Loop;  
                                end if;  
                            end if;  
                        end loop;

----If we get here then there is no Line2 that matches Line1.  Loop and go
--  after the next non-blank Line1.

                    end loop Line1_Line2_Loop;

----Come here when we have Line1 = Line2 and we now want to expand the
--  region of match.  Loop backwards looking for a line that doesn't match.
--  Then report that region of difference.

                <<Have_A_Match>> null;  
                Tmp1 := Line1i;  
                Tmp2 := Line2i;

----Skip backwards from the match looking for lines that aren't blank and which
--  don't match.

                Post_Diff_Loop1:  
                    loop  
                        loop  
                            if Line1i - 1 <= Last_Line1i then  
                                exit Post_Diff_Loop1;  
                            end if;  
                            Line1 := List1 (Line1i - 1);  
                            if not Line1.Blank then  
                                exit;  
                            end if;  
                            Line1i := Line1i - 1;  
                        end loop;  
                        loop  
                            if Line2i - 1 <= Last_Line2i then  
                                exit Post_Diff_Loop1;  
                            end if;  
                            Line2 := List2 (Line2i - 1);  
                            if not Line2.Blank then  
                                exit;  
                            end if;  
                            Line2i := Line2i - 1;  
                        end loop;  
                        if Line1.Hash /= Line2.Hash or else  
                           not Equal_Uc (Line1.Line.all, Line2.Line.all) then  
                            exit Post_Diff_Loop1;  
                        end if;  
                        Line1i := Line1i - 1;  
                        Line2i := Line2i - 1;  
                    end loop Post_Diff_Loop1;

----Skip blanks at the start of the difference regions.

                while Last_Line1i + 1 < Line1i - 1 loop  
                    if not List1 (Last_Line1i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line1i := Last_Line1i + 1;  
                end loop;  
                while Last_Line2i + 1 < Line2i - 1 loop  
                    if not List1 (Last_Line2i + 1).Blank then  
                        exit;  
                    end if;  
                    Last_Line2i := Last_Line2i + 1;  
                end loop;  
                Regions_Differ (List1 (Last_Line1i + 1 .. Line1i - 1),  
                                List2 (Last_Line2i + 1 .. Line2i - 1));

----Now loop forwards looking for a line that doesn't match.  That defines
--  our next starting point.

                Line1i := Tmp1;  
                Line2i := Tmp2;  
                Post_Diff_Loop2:  
                    loop  
                        loop  
                            if Line1i >= List1'Last then  
                                exit Post_Diff_Loop2;  
                            end if;  
                            Line1 := List1 (Line1i + 1);  
                            if not Line1.Blank then  
                                exit;  
                            end if;  
                            Line1i := Line1i + 1;  
                        end loop;  
                        loop  
                            if Line2i >= List2'Last then  
                                exit Post_Diff_Loop2;  
                            end if;  
                            Line2 := List2 (Line2i + 1);  
                            if not Line2.Blank then  
                                exit;  
                            end if;  
                            Line2i := Line2i + 1;  
                        end loop;  
                        if Line1.Hash /= Line2.Hash or else  
                           not Equal_Uc (Line1.Line.all, Line2.Line.all) then  
                            exit Post_Diff_Loop2;  
                        end if;  
                        Line1i := Line1i + 1;  
                        Line2i := Line2i + 1;  
                    end loop Post_Diff_Loop2;  
                Last_Line1i := Line1i;  
                Last_Line2i := Line2i;

----Loop and go after the next matching region.

            end loop Main_Diff_Loop;

----Come here when we can't find a next-non-blank Line1.

        while Last_Line1i + 1 < List1'Last loop  
            if not List1 (Last_Line1i + 1).Blank then  
                exit;  
            end if;  
            Last_Line1i := Last_Line1i + 1;  
        end loop;  
        while Last_Line2i + 1 < List2'Last loop  
            if not List1 (Last_Line2i + 1).Blank then  
                exit;  
            end if;  
            Last_Line2i := Last_Line2i + 1;  
        end loop;  
        Regions_Differ (List1 (Last_Line1i + 1 .. List1'Last),  
                        List2 (Last_Line2i + 1 .. List2'Last));

    end Diff_Ii;

--\f

    procedure Files_Diff (File1              : String;  
                          File2              : String;  
                          Ignore_Case        : Boolean;  
                          Ignore_Blank_Lines : Boolean) is
------------------------------------------------------------------------------
--  File1               - Specifies the name of the first file
--  File2               - Specifies the name of the second file
--  Ignore_Case         - Specifies TRUE if 'a' = 'A'
--  Ignore_Blank_Lines  - Specifies TRUE if blanks lines "don't exist"
--
-- We do a simple minded "diff" of two files and send the output to the log.
-- We don't expect to handle megabytes of stuff so don't be surprised if we
-- blow up on very large files.  We bring the entirity of both files into
-- memory.
------------------------------------------------------------------------------
        F1 : Text_Io.File_Type;  
        F2 : Text_Io.File_Type;

        List1  : File_Line_List;  
        List2  : File_Line_List;  
        List1i : S_Natural;  
        List2i : S_Natural;

    begin

----Open the files for reading.

        Put_Line ("::: diff( " & File1 & ", " & File2 & " );");  
        begin  
            Text_Io.Open (F1, Text_Io.In_File, File1);  
        exception  
            when others =>  
                Put_Error ("Could not open file to compare [" & File1 & "}.");  
                return;  
        end;  
        begin  
            Text_Io.Open (F2, Text_Io.In_File, File2);  
        exception  
            when others =>  
                Put_Error ("Could not open file to compare [" & File2 & "}.");  
                Text_Io.Close (F1);  
                return;  
        end;

----Read in the files.

        Read_File (F1, List1, List1i, Ignore_Case);  
        Read_File (F2, List2, List2i, Ignore_Case);

----Close the files.

        Text_Io.Close (F1);  
        Text_Io.Close (F2);

----Diff the files.

        if Ignore_Case then  
            if Ignore_Blank_Lines then  
                Diff_Ii (List1 (1 .. List1i), List2 (1 .. List2i));  
            else  
                Diff_Ib (List1 (1 .. List1i), List2 (1 .. List2i));  
            end if;  
        else  
            if Ignore_Blank_Lines then  
                Diff_Ci (List1 (1 .. List1i), List2 (1 .. List2i));  
            else  
                Diff_Cb (List1 (1 .. List1i), List2 (1 .. List2i));  
            end if;  
        end if;

----Free our storage and return.

        Free_File_Line_List (List1);  
        Free_File_Line_List (List2);

    exception

        when others =>  
            Free_File_Line_List (List1);  
            Free_File_Line_List (List2);  
            Put_Line ("%%% Unexpected exception in Text_Io.Files_Diff?");  
            Text_Io.Close (F1);  
            Text_Io.Close (F2);  
            return;

    end Files_Diff;

--\f

    function Change_Wildcards (Wild_In : String) return String is
------------------------------------------------------------------------------
--  Wild_In - Specifies a wildcard file name in R1000 format
--
-- Returns the local equivalent to the R1000 wildcarded string.
------------------------------------------------------------------------------
--/ if Unix then
--//
--//         Wild_Out  : String (1 .. Wild_In'Length * 3);
--//         Wild_Outi : Natural := 0;
--//         Wild_Ini  : Natural := Wild_In'First;
--//
--/ end if;
    begin

--/ if R1000 then

        return Wild_In;

--/ elsif Unix then
--//
--//         while Wild_Ini <= Wild_In'Last loop
--//             if Wild_In (Wild_Ini) = '^' then
--//                 Wild_Ini := Wild_Ini + 1;
--//                 if Wild_Ini > Wild_In'Last then
--//                     Wild_Out (Wild_Outi + 1 .. Wild_Outi + 2) := "..";
--//                     Wild_Outi := Wild_Outi + 2;
--//                 else
--//                     if Wild_In (Wild_Ini) = '.' then
--//                         Wild_Ini := Wild_Ini + 1;
--//                     end if;
--//                     Wild_Out (Wild_Outi + 1 .. Wild_Outi + 3) := "../";
--//                     Wild_Outi := Wild_Outi + 3;
--//                 end if;
--//             elsif Wild_In (Wild_Ini) = '$' then
--//                 Wild_Ini := Wild_Ini + 1;
--//                 if Wild_Ini > Wild_In'Last then
--//                     Wild_Outi                        := Wild_Outi + 1;
--//                     Wild_Out (Wild_Outi .. Wild_Outi) := ".";
--//                 else
--//                     if Wild_In (Wild_Ini) = '.' then
--//                         Wild_Ini := Wild_Ini + 1;
--//                     end if;
--//                     Wild_Out (Wild_Outi + 1 .. Wild_Outi + 2) := "./";
--//                     Wild_Outi := Wild_Outi + 2;
--//                 end if;
--//             elsif Wild_In (Wild_Ini) = '.' then
--//                 Wild_Ini             := Wild_Ini + 1;
--//                 Wild_Outi            := Wild_Outi + 1;
--//                 Wild_Out (Wild_Outi) := '/';
--//             elsif Wild_In (Wild_Ini) = '@' then
--//                 Wild_Ini             := Wild_Ini + 1;
--//                 Wild_Outi            := Wild_Outi + 1;
--//                 Wild_Out (Wild_Outi) := '*';
--//             else
--//                 Wild_Outi            := Wild_Outi + 1;
--//                 Wild_Out (Wild_Outi) := Wild_In (Wild_Ini);
--//             end if;
--//         end loop;
--//         return Wild_Out (1 .. Wild_Outi);
--//
--/ else
--//
--//         Need_Something_Here;
--//
--/ end if;

    end Change_Wildcards;

--\f

    procedure Resolve_Wildcards (Names : String;  
                                 Extra : String) is
------------------------------------------------------------------------------
--  Names   - Specifies the name with wildcards
--  Extra   - Specifies extra stuff to go onto the end of the Name string
--
-- Called to find all of the files referenced by the Name string.
-- We process the Name string.  It is expected to be in R1000 wildcard
-- notation ($/^/./@ only are allowed).  We change it to be suitable for
-- the current system and then we append the Extra to it.
-- Usage:
--      Resolve_Wildcards( "@", ".exe" );
--      while not Wild_Done loop
--          do_something( Wild_Current );
--          Wild_Next;
--      end loop;
------------------------------------------------------------------------------
--/ if R1000 then

        Wild_Iter : Directory_Tools.Object.Iterator;  
        Name      : File_Name;  
        Last      : File_Name;  
        Str       : String_Pointer;

--/ elsif Unix then
--//
--//         File  : Text_Io.File_Type;
--//         Line  : String (1 .. 1024);
--//         Linei : Natural;
--//         Name  : File_Name;
--//         Last  : File_Name;
--//         Str   : String_Pointer;
--//
--/ end if;
    begin

--/ if R1000 then

----Resolve the wildcards and check for errors.

        Wild_Iter := Directory_Tools.Naming.Resolution (Names & Extra);  
        if Directory_Tools.Object.Is_Bad (Wild_Iter) then  
            Put_Error ("Could not locate wildcards [" & Names & Extra & "].");  
            Put_Error ("Error: " & Directory_Tools.Object.Message (Wild_Iter));  
            raise Test_Io_Error;  
        end if;

----Put all of the names onto our list.

        Name_List := null;  
        Last      := null;  
        while not Directory_Tools.Object.Done (Wild_Iter) loop  
            Str  := new String'(Directory_Tools.Naming.Full_Name  
                                   (Directory_Tools.Object.Value (Wild_Iter)));  
            Name := new File_Name_Rec'(Next => null,  
                                       Name => Str);  
            if Last /= null then  
                Last.Next := Name;  
            end if;  
            Last := Name;  
            if Name_List = null then  
                Name_List := Name;  
            end if;  
            Directory_Tools.Object.Next (Wild_Iter);  
        end loop;

--/ elsif TeleGen2 and then Unix then
--//
--// ----Resolve the wildcards and check for errors.
--//
--//         if System_Calls.System ("/bin/ls -l " &
--//                                 Change_Wildcards (Names) & Extra &
--//                                 " > ./_Wild_Test_Io") < 0 then
--//             Put_Error ("Could not execute ls to resolve wildcards?");
--//             Put_Error (Error_Messages.Sys_Error_Message (Error_Messages.Errno));
--//             raise Test_Io_Error;
--//         end if;
--//
--// ----Put all of the names onto our list.
--//
--//         Text_Io.Open (File, Text_Io.In_File, "./_Wild_Test_Io");
--//         Text_Io.Get_Line (File, Line, Linei);
--//         Name_List := null;
--//         Last      := null;
--//         while not Text_Io.End_Of_File (File) loop
--//             Text_Io.Get_Line (File, Line, Linei);
--//             for I in reverse 1 .. Linei loop
--//                 if Line (I) /= ' ' then
--//                     Linei := I;
--//                     exit;
--//                 end if;
--//             end loop;
--//             for I in reverse 1 .. Linei loop
--//                 if Line (I) = ' ' then
--//                     Str := new String'(Line (I + 1 .. Linei));
--//                     exit;
--//                 end if;
--//             end loop;
--//             Name := new File_Name_Rec' (Next => null,
--//                                         Name => Str);
--//             if Last /= null then
--//                 Last.Next := Name;
--//             end if;
--//             Last := Name;
--//             if Name_List = null then
--//                 Name_List := Name;
--//             end if;
--//         end loop;
--//         Text_Io.Close (File);
--//
--/ else
--//
--//         Need_Something_Here;
--//
--/ end if;

    end Resolve_Wildcards;

--\f

    procedure Wild_Next is
------------------------------------------------------------------------------
-- Called to progress to the next wildcard.
------------------------------------------------------------------------------
        Name : File_Name;  
    begin

        if Name_List = null then  
            raise Test_Io_Error;  
        end if;  
        Name      := Name_List;  
        Name_List := Name_List.Next;  
        Free_File_Name (Name);

    end Wild_Next;

--\f

    function Wild_Current return String is
------------------------------------------------------------------------------
-- Called to obtain the current value of the wildcard.
------------------------------------------------------------------------------
    begin

        if Name_List = null then  
            raise Test_Io_Error;  
        end if;  
        return Name_List.Name.all;

    end Wild_Current;

--\f

    function Wild_Done return Boolean is
------------------------------------------------------------------------------
-- Called to see if there are more wildcards available.
------------------------------------------------------------------------------
    begin

        return Name_List = null;

    end Wild_Done;

--\f

end Test_Io;