DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400

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

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download

⟦2521d0321⟧ Ada Source

    Length: 17408 (0x4400)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, procedure Analyze, seg_004567

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

E3 Source Code



with Program_Analysis;
with Lrm_Utilities;
with Log;
with Profile;
with Errors;
with Common;
with Ada_Traversal;
with Directory_Renames;
use Directory_Renames;
with Lrm_Renames;
use Lrm_Renames;
with Abstract_Document;
with Table_Formatter;
with Subprogram_Analysis;
procedure Analyze (Units             : String := "";
                   To_Preview_Object : String := "subprogram_info") is

    package Ad         renames Abstract_Document;
    package Ad_Specify renames Abstract_Document.Specify;

    package Sub_Table  is new Table_Formatter (8);
    package Unit_Table is new Table_Formatter (6);

    Bad_Input_String : exception;

    B               : Boolean         := True;
    Current_Context : constant String := Naming.Default_Context;
    Object_Status   : Object.Error_Code;

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

    Document : Ad.Handle;
    Status   : Errors.Condition;

    Uses_Total       : Natural := 0;
    Anon_Total       : Natural := 0;
    Goto_Total       : Natural := 0;
    Predefined_Total : Natural := 0;
    Vars_Total       : Natural := 0;

    function Unit_Name (Comp_Unit : Ada.Element) return String is
        Decl : Ada.Declaration := Comp_Units.Unit_Declaration (Comp_Unit);
        Name : constant String := Decls.Name (Decl);
    begin
        if Decls.Is_Visible (Decl) then
            return Name & "'spec";
        else
            return Name & "'body";
        end if;
    end Unit_Name;

    function Subprogram_Name (Sub_Body : Ada.Element) return String is
        Spec : Ada.Element := Decls.Specification (Sub_Body);
        Id   : Ada.Element;
    begin
        if Ada.Is_Nil (Spec) then
            Id := Ada.Value (Decls.Identifiers (Sub_Body));
        else
            Id := Ada.Value (Decls.Identifiers (Spec));
        end if;
        return Lrm_Utilities.Qualified_Reference (Id);
    end Subprogram_Name;

    procedure Pre_Op (Program_Element :        Ada.Element;
                      State           : in out Boolean;
                      Control         : in out Ada.Traversal_Control) is
    begin
        case Ada.Kind (Program_Element) is
            when Ada.A_Declaration =>
                case Decls.Kind (Program_Element) is
                    when Decls.A_Procedure_Body_Declaration |
                         Decls.A_Function_Body_Declaration =>
                        declare
                            Data : Subprogram_Analysis.Subprogram_Data :=
                               Subprogram_Analysis.Analyze (Program_Element);
                        begin
                            Sub_Table.Item (S => Subprogram_Name
                                                    (Program_Element),
                                            Linkage => Program_Element,
                                            Linkage_List => Ada.Nil_List,
                                            Explanation => "Subprogram Name");

                            Sub_Table.Item
                               (S           => Integer'Image
                                                  (Subprogram_Analysis.
                                                   Number_Of_Parameters (Data)),
                                Explanation =>
                                   "Number of paramters in the subprogram");

                            Sub_Table.Item
                               (S => Integer'Image
                                        (Lrm_Utilities.Count
                                            (Subprogram_Analysis.Branches
                                                (Data))),
                                Linkage_List =>
                                   Subprogram_Analysis.Branches (Data),
                                Explanation =>
                                   "Number of branch points in the subprogram");

                            Sub_Table.Item
                               (S => Integer'Image
                                        (Subprogram_Analysis.Nesting_Depth
                                            (Data)),
                                Linkage_List => Ada.Nil_List,
                                Explanation => "Maximum depth of nesting");
                            Sub_Table.Item
                               (S => Integer'Image
                                        (Lrm_Utilities.Count
                                            (Subprogram_Analysis.Exits (Data))),
                                Linkage_List =>
                                   Subprogram_Analysis.Exits (Data),
                                Explanation =>
                                   "Number of subprogram return statements");

                            Sub_Table.Item
                               (S => Integer'Image
                                        (Lrm_Utilities.Count
                                            (Subprogram_Analysis.                                            Global_References (Data))),
                                Linkage_List =>
                                   Subprogram_Analysis.Global_References (Data),
                                Explanation =>
                                   "Number of references to global variables");

                            Sub_Table.Item
                               (S => Integer'Image
                                        (Subprogram_Analysis.
                                         Number_Of_Local_Declarations (Data)),
                                Linkage_List => Ada.Nil_List,
                                Explanation => "Number of local declarations");
                            Sub_Table.Item
                               (S            =>
                                   Integer'Image
                                      (Subprogram_Analysis.Number_Of_Statements
                                          (Data)),
                                Linkage_List => Ada.Nil_List,
                                Explanation  =>
                                   "Total number of statements in the subprogram");
                        end;
                        Control := Ada.Abandon_Children;
                    when others =>
                        Control := Ada.Continue;
                end case;
            when others =>
                null;
        end case;
    end Pre_Op;

    procedure Post_Op (Program_Element :        Ada.Element;
                       State           : in out Boolean;
                       Control         : in out Ada.Traversal_Control) is
    begin
        Control := Ada.Continue;
    end Post_Op;

    procedure Traverse is new Ada.Depth_First_Traversal
                                 (Boolean, Pre_Op, Post_Op);

    procedure Yield_Unit_Subs (Unit : Object.Handle) is
    begin
        Traverse (Ada.Conversion.To_Compilation_Unit (Unit), B, True);
    end Yield_Unit_Subs;

    procedure Yield_Unit (Unit : Object.Handle) is
        Comp_Unit : Ada.Element := Ada.Conversion.To_Compilation_Unit (Unit);
        Data      : Program_Analysis.Unit_Data :=
           Program_Analysis.Analyze (Comp_Unit);

        procedure Add_Item (List        :        Ada.Element_List;
                            Explanation :        String;
                            Total       : in out Natural) is
            Count : Natural := Lrm_Utilities.Count (List);
        begin
            Unit_Table.Item (S            => Integer'Image (Count),
                             Linkage_List => List,
                             Explanation  => Explanation);
            Total := Total + Count;
        end Add_Item;
    begin
        Unit_Table.Item (S            => Unit_Name (Comp_Unit),
                         Linkage      => Lrm_Utilities.Comp_Unit_Id (Comp_Unit),
                         Linkage_List => Ada.Nil_List,
                         Explanation  => "Unit Name");

        Add_Item (List        => Program_Analysis.Use_Clauses (Data),
                  Total       => Uses_Total,
                  Explanation => "Number of use clauses in the unit");

        Add_Item (List        => Program_Analysis.Go_Tos (Data),
                  Total       => Goto_Total,
                  Explanation => "Number of goto statemetns in the unit");

        Add_Item (List        => Program_Analysis.Predefined_Numerics (Data),
                  Total       => Predefined_Total,
                  Explanation =>
                     "Number of uses of predefined numerics in the unit");

        Add_Item
           (List        => Program_Analysis.Uninitialized_Variables (Data),
            Total       => Vars_Total,
            Explanation =>
               "Number of variable declarations without explicit initialization");

        Add_Item
           (List        => Program_Analysis.Anonymous_Array_Decls (Data),
            Total       => Anon_Total,
            Explanation =>
               "Number of variables declared with an anonymous array type");

    end Yield_Unit;

    procedure Traverse_All_Ada_Units_For_Subs is
       new Ada_Traversal (Yield_Unit_Subs);

    procedure Traverse_All_Ada_Units is new Ada_Traversal (Yield_Unit);

begin  
    if Object.Is_Bad (Unit_Iter) then
        raise Bad_Input_String;
    end if;

    Ad.Create (Document, To_Preview_Object, Status);
    Ad_Specify.Cover (Document, "");
    Ad_Specify.Cover_Item (Document, "");

    Naming.Set_Default_Context (Current_Context, Object_Status);

    Ad_Specify.Paragraph (Document, 1, "Analysis of all units");

    declare
        package Key_Table is new Table_Formatter (2);
    begin
        Key_Table.Header ("Metric", Format => Key_Table.Left);
        Key_Table.Header ("Reference", Format => Key_Table.Centered);
        Key_Table.Item ("Number of Use Clauses");
        Key_Table.Item ("Uses");
        Key_Table.Item ("Number of Goto Statements");
        Key_Table.Item ("GoTos");
        Key_Table.Item ("Number of Predefine Numerics");
        Key_Table.Item ("Predefined");
        Key_Table.Item ("Number of Uninitialized Variables");
        Key_Table.Item ("Un-init");
        Key_Table.Item ("Number of Anonymous Arrays");
        Key_Table.Item ("Anons");

        Key_Table.Display (Document, "Key");

    end;

    Unit_Table.Header ("Unit");
    Unit_Table.Header ("Uses", Unit_Table.Right);
    Unit_Table.Header ("GoTos", Unit_Table.Right);
    Unit_Table.Header ("Predefined", Unit_Table.Right);
    Unit_Table.Header ("Un-init", Unit_Table.Right);
    Unit_Table.Header ("Anons", Unit_Table.Right);

    Traverse_All_Ada_Units (Unit_Iter);

    Unit_Table.Sort (1);

    Unit_Table.Item ("TOTAL");
    Unit_Table.Item (Integer'Image (Uses_Total));
    Unit_Table.Item (Integer'Image (Goto_Total));
    Unit_Table.Item (Integer'Image (Predefined_Total));
    Unit_Table.Item (Integer'Image (Vars_Total));
    Unit_Table.Item (Integer'Image (Anon_Total));

    Unit_Table.Display (Document, "Unit Analysis");

    Ad_Specify.Paragraph (Document, 2, "Analysis of all subprograms");

    declare
        package Key_Table is new Table_Formatter (2);
    begin
        Key_Table.Header ("Metric", Format => Key_Table.Left);
        Key_Table.Header ("Reference", Format => Key_Table.Centered);
        Key_Table.Item ("Number of Parameters");
        Key_Table.Item ("Param");
        Key_Table.Item ("Number of Branch Statements");
        Key_Table.Item ("Brnch");
        Key_Table.Item ("Maximun Branching Depth");
        Key_Table.Item ("Dep");
        Key_Table.Item ("Number of Exits");
        Key_Table.Item ("Exit");
        Key_Table.Item ("Number of Global References");
        Key_Table.Item ("Glob");
        Key_Table.Item ("Number of Local Declarations");
        Key_Table.Item ("Decl");
        Key_Table.Item ("Number of Statements");
        Key_Table.Item ("Stmt");

        Key_Table.Display (Document, "Key");

    end;

    Sub_Table.Header ("Unit");
    Sub_Table.Header ("Param", Sub_Table.Right);
    Sub_Table.Header ("Brnch", Sub_Table.Right);
    Sub_Table.Header ("Dep", Sub_Table.Right);
    Sub_Table.Header ("Exit", Sub_Table.Right);
    Sub_Table.Header ("Glob", Sub_Table.Right);
    Sub_Table.Header ("Decl", Sub_Table.Right);
    Sub_Table.Header ("Stmt", Sub_Table.Right);

    Traverse_All_Ada_Units_For_Subs (Unit_Iter);

    Sub_Table.Sort (1);
    Sub_Table.Display (Document, "Subprogram Analysis");

    Ad.Close (Document);
    Common.Definition (To_Preview_Object);
exception
    when Bad_Input_String =>
        Log.Put_Line ("Units string " & Units & " does not resolve",
                      Profile.Error_Msg);
        Ad.Close (Document);
end Analyze;

E3 Meta Data

    nblk1=10
    nid=e
    hdr6=1e
        [0x00] rec0=24 rec1=00 rec2=01 rec3=03c
        [0x01] rec0=1d rec1=00 rec2=0f rec3=012
        [0x02] rec0=01 rec1=00 rec2=02 rec3=012
        [0x03] rec0=12 rec1=00 rec2=03 rec3=022
        [0x04] rec0=12 rec1=00 rec2=04 rec3=04a
        [0x05] rec0=12 rec1=00 rec2=05 rec3=002
        [0x06] rec0=11 rec1=00 rec2=06 rec3=00c
        [0x07] rec0=19 rec1=00 rec2=07 rec3=07c
        [0x08] rec0=16 rec1=00 rec2=08 rec3=00a
        [0x09] rec0=00 rec1=00 rec2=10 rec3=00a
        [0x0a] rec0=16 rec1=00 rec2=09 rec3=070
        [0x0b] rec0=1e rec1=00 rec2=0a rec3=054
        [0x0c] rec0=1c rec1=00 rec2=0b rec3=062
        [0x0d] rec0=18 rec1=00 rec2=0c rec3=070
        [0x0e] rec0=1f rec1=00 rec2=0d rec3=000
        [0x0f] rec0=00 rec1=00 rec2=00 rec3=000
    tail 0x217001f28815c64e31016 0x42a00088462061e03
Free Block Chain:
  0xe: 0000  00 00 00 0c 00 09 20 20 20 20 20 20 20 20 20 09  ┆                ┆