DataMuseum.dk

top - metrics - download

    Length: 3770 (0xeba)
    Types: TextFile
    Names: »B«

└─⟦180fe333a⟧ Bits:30000405 8mm tape, Rational 1000, SW CATALOG, 10_20_0
└─⟦180fe333a⟧ Bits:30000537 8mm tape, Rational 1000, SW Catalog 10_20_0
    └─⟦5cb1d1d7f⟧ »DATA« 
        └─⟦3b1ee7bd8⟧ 
            └─⟦this⟧ 

TextFile

with Debug_Tools;
with Lines;
with Analyze;
with Representation_Clauses;
with Diana;
with Walk_Generic;
with Debug_Util;
with Ada_Program;
with Directory;
with Io;
with String_Utilities;
procedure Traverse_Files (Files : String := "<selection>") is
    package Reps renames Representation_Clauses;
    package Su   renames String_Utilities;
    package Ap   renames Ada_Program;
    package Din  renames Directory.Naming;
    package Di   renames Directory;
    function "=" (A, B : Directory.Error_Status) return Boolean
        renames Directory."=";

    function "=" (A, B : Din.Name_Status) return Boolean renames Din."=";


    Estatus   : Di.Error_Status;
    File_Iter : Di.Naming.Iterator;
    Status    : Din.Name_Status;
    Root      : Diana.Tree;

    File_Object : Di.Object;
    Bad_Resolve : exception;

    procedure Display_Data (L : Lines.Lines_Type) is
        Liter : Lines.Line_Iterator := Lines.Initialize (L);
    begin
        while not Lines.Done (Liter) loop
            Put_Line ("       " & Lines.Value (Liter));
            Lines.Next (Liter);
        end loop;

    end Display_Data;
    procedure P (Node : Diana.Tree; C : in out Boolean) is
        E : Ap.Element;
        L : Lines.Lines_Type;
    begin
        case Diana.Kind (Node) is
            when Diana.Dn_Record_Rep | Diana.Dn_Simple_Rep =>
                begin
                    E := Ap.Conversion.Convert (Node);
                    case Reps.Kind (E) is
                        when Reps.A_Length_Clause =>
                            Analyze.Length_Clause (E, L);
                            Display_Data (L);
                        when Reps.A_Record_Representation_Clause =>
                            Analyze.Record_Representation_Clause (E, L);
                            Display_Data (L);
                        when Reps.An_Enumeration_Representation_Clause =>
                            Analyze.Enumeration_Clause (E, L);
                            Display_Data (L);

                        when others =>
                            null;
                    end case;
                    null;
                exception
                    when others =>
                        null;

                end;
            when others =>
                null;
        end case;
        C := True;
    exception
        when others =>
            C := True;
    end P;

    procedure Walk is new Walk_Generic (P);

begin
    Din.Resolve (File_Iter, Files, Status);
    if Status /= Din.Successful then
        raise Bad_Resolve;
    end if;
    Put_Line ("----  Representation Clause Analysis (Rev 10.0)");

    while not Din.Done (File_Iter) loop
        Din.Get_Object (File_Iter, File_Object, Estatus);
        if Estatus = Di.Successful then
            Put_Line ("");
            Put_Line ("----  " & Su.Capitalize
                                    (Din.Unique_Full_Name (File_Object)));

            Put_Line ("");

            Din.Get_Root (File_Iter, Root, Estatus);

            if Estatus = Di.Successful then
                Walk (Root);
            else
                Put_Line ("****  " & Su.Capitalize
                                        (Di.Error_Status'Image (Estatus)));
            end if;
        else
            Put_Line ("****  " & Su.Capitalize
                                    (Di.Error_Status'Image (Estatus)));

        end if;
        Din.Next (File_Iter);
    end loop;

exception
    when Bad_Resolve =>
        Io.Put (Io.Standard_Error,
                "Error : " & Su.Capitalize (Din.Name_Status'Image (Status)) &
                   ", Could Not Resolve");
    when others =>
        Io.Put (Io.Standard_Error, Su.Capitalize
                                      (Debug_Tools.Get_Exception_Name));
end Traverse_Files;