⟦49bb8d4f2⟧

E3 Source Code



with Log;
with Profile;
with Common;
with Add_Hyper_Table;
with Create_Null_Document;
with Lrm_Renames;
use Lrm_Renames;
with Directory_Renames;
use Directory_Renames;
with Errors;
with Simple_Status;
with Lrm_Utilities;
with Unused_Withs;
package body Find_Unused_Withs is


    procedure Add (Units       :        String := "";
                   To_Document : in out Abstract_Document.Handle;
                   Response    :        String := "<PROFILE>") is

        Units_Iter : Object.Iterator := Naming.Resolution (Units);

        type Columns is (Compilation_Unit, Unused_With_Clauses, Not_Required);

        Unused    : Ada.Element_List;
        Only_Used : Ada.Element_List;

        function Is_Integer_Column (C : Columns) return Boolean is
        begin
            case C is
                when Unused_With_Clauses | Not_Required =>
                    return True;
                when others =>
                    return False;
            end case;
        end Is_Integer_Column;

        function Is_Included (Elem : Ada.Element) return Boolean is
        begin
            case Ada.Kind (Elem) is
                when Ada.A_Compilation_Unit =>
                    Unused    := Ada.Nil_List;
                    Only_Used := Ada.Nil_List;
                    Unused_Withs (Elem, Unused, Only_Used);

                    if Unused = Ada.Nil_List and then
                       Only_Used = Ada.Nil_List then
                        return False;
                    else
                        return True;
                    end if;
                when others =>
                    return False;
            end case;

        end Is_Included;

        function Column_Image (C : Columns; Elem : Ada.Element) return String is
        begin
            case C is
                when Compilation_Unit =>
                    return Decls.Name (Lrm_Utilities.Comp_Unit_Id (Elem));
                when Unused_With_Clauses =>
                    return Integer'Image (Lrm_Utilities.Count (Unused));
                when Not_Required =>
                    return Integer'Image (Lrm_Utilities.Count (Only_Used));
            end case;
        end Column_Image;

        function Explanation (C : Columns; Elem : Ada.Element) return String is
        begin
            case C is
                when Compilation_Unit =>
                    return "Name of the compilation unit";
                when Unused_With_Clauses =>
                    return "Number of unused with clauses";
                when Not_Required =>
                    return
                       "Number of with clauses used only is a use clause or a renaming clause";
            end case;
        end Explanation;

        procedure Linkage (C                :     Columns;
                           Elem             :     Ada.Element;
                           Linkage_Element  : out Ada.Element;
                           Linkage_Elements : out Ada.Element_List) is
        begin
            -- default values changed within the case statement as necessary
            Linkage_Element  := Ada.Nil_Element;
            Linkage_Elements := Ada.Nil_List;

            case C is
                when Compilation_Unit =>
                    Linkage_Element := Lrm_Utilities.Comp_Unit_Id (Elem);
                when Unused_With_Clauses =>
                    Linkage_Elements := Unused;
                when Not_Required =>
                    Linkage_Elements := Only_Used;
            end case;
        end Linkage;

        procedure Add_Hyper_Table_To_Doc is
           new Add_Hyper_Table
                  (Is_Included,  
                   Columns,  
                   Is_Integer_Column,  
                   Column_Image,  
                   Explanation,  
                   Linkage,  
                   Table_Title =>
                      "Uused with clauses in each compilation unit");
    begin
        if Object.Is_Bad (Units_Iter) then
            Log.Put_Line (Units & " is not a valid pathname",
                          Profile.Error_Msg);
        else
            Add_Hyper_Table_To_Doc (Units_Iter, To_Document, Response);
        end if;
    end Add;

    procedure Display (Units             : String := "";
                       To_Preview_Object : String := "Unused_Withs_Info";
                       Response          : String := "<PROFILE>") is
        Document  : Abstract_Document.Handle;
        Condition : Errors.Condition;
    begin

        Create_Null_Document (Named           => To_Preview_Object,
                              Error_Info      => Condition,
                              Document_Handle => Document);

        case Errors.Severity (Condition) is
            when Simple_Status.Problem | Simple_Status.Fatal =>
                Log.Put_Line ("Problem creating object " & To_Preview_Object &
                              ".  " & Errors.Info (Condition),
                              Profile.Error_Msg);
            when others =>

                Add (Units, Document, Response);

                Abstract_Document.Close (Document);

                Common.Definition (To_Preview_Object);

        end case;
    end Display;
end Find_Unused_Withs;
DataMuseum.dk

Rational R1000/400

⟦49bb8d4f2⟧ Ada Source

Derivation

E3 Source Code

E3 Meta Data
