|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 Tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - downloadIndex: B T
Length: 28309 (0x6e95)
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⟧
with Unchecked_Deallocation;
separate (Compilation_Unit.Produce_Metrics)
task body Halstead_State_Machine is
--=============================================================
-- This task body gives the user the ability to either modify =
-- or find out the present state of the Hastead abstract =
-- state machine. Accept statements are provided to change the=
-- present number of operators, operands, and parameters. =
-- Accept statements are also provided to calculate many of =
-- Halstead's metrics plus give back each all the present =
-- values and results. All the calculations are accomplished =
-- by using operations imported from various generic packages.=
-- =
-- written by GER with help from Brad and JM =
--=============================================================
Current_Program_Unit : Program_Unit_Kind;
-- holds the type of current program unit
Stored_Operator : Halstead_Operator.Definition;
-- An operator that needs to be stored, received through a
-- task rendezvous
type Pointer_To_Operand is access Halstead_Operand.Definition;
Stored_Operand_Pointer : Pointer_To_Operand;
-- An operand that needs to be stored, received through a
-- task rendezvous
procedure Free_Operand_Node is
new Unchecked_Deallocation (Object => Halstead_Operand.Definition,
Name => Pointer_To_Operand);
Current_Parameter_Count : Natural := 0;
-- The number of formal parameters
Delta_Parameter_Count : Natural;
-- A place holder for the parameter count
Number_Of_Unique_Operators : Natural := 0;
-- The current total of unique operators
Number_Of_Unique_Operands : Natural := 0;
-- The current total of unique operands
--** changed 11/18/85 by J. Margono
--** reason: definitions of n1 and n1* were mixed up
Number_Of_Potential_Operators : Natural := 0;
-- The current total of unique operators (n1*)
--** changed 11/18/85 by J. Margono
--** reason: definitions of n2 and n2* were mixed up
Number_Of_Potential_Operands : Natural := 0;
-- The current total of unique operands (n2*)
Total_Number_Of_Operators : Natural := 0;
-- The current total of all operators
Total_Number_Of_Operands : Natural := 0;
-- The current total of all operands
Size_Of_Vocabulary : Halstead_Lower_Case_N.Result := 0;
-- The current size of vocabulary for this compilation unit
Program_Length : Halstead_Upper_Case_N.Result := 0;
-- The current Program length for this compilation unit
Current_Program_Volume : Halstead_V.Result := 0.0;
-- The current program volume for this compilation unit
Summation_Of_V_Star : Halstead_V_Star.Result := 0.0;
-- A summation of the potential operator volume
This_V_Star : Halstead_V_Star.Result := 0.0;
-- An intermediate value of V* in the summation series
Number_Of_Entries : Natural := 0;
-- holds the number of entries in a task specification or
-- number of accept statements in a task body
Current_Potential_Program_Volume : Halstead_V_Star.Result := 0.0;
-- The current amount of potential program volume
Current_Program_Level : Halstead_L.Result := 0.0;
-- The current program level for this compilation unit
Current_Difficulty_Level : Halstead_D.Result := 0.0;
-- The current difficulty level for this compilation unit
Current_Effort : Halstead_E.Result := 0.0;
-- The current effort for this compilation unit
Current_Number_Of_Delivered_Bugs : Halstead_B_Hat.Result := 0.0;
-- The current number of Delivered bugs
Current_Error_Proneness : Halstead_D_Hat.Result := 0.0;
-- The current amount of Halstead's error proneness
Current_Time : Halstead_T.Result := 0.0;
-- The current value of Halstead's time to understand
Current_Fault_Rate : Halstead_B_Over_P.Result := 0.0;
-- The current value of Halstead's fault rate
Current_Physical_Lines : Loc_Physical_Lines.Count;
-- The current number of physical lines. This total
-- be received from the Lines-Of-Code task
Current_Operator_List : Halstead_Operator_List.List;
-- A list that will contain all the unique operators and
-- their frequencies
Current_Operand_List : Halstead_Operand_List.List;
-- A list that will contain all the unique operands and
-- their frequencies
function Calculate_Lower_Case_N1
(Operator_List : in Halstead_Operator_List.List) return Natural
renames Halstead_Operator_List.Length_Of;
-- Calculate the number of unique operators
function Calculate_Lower_Case_N2
(Operand_List : Halstead_Operand_List.List) return Natural
renames Halstead_Operand_List.Length_Of;
-- Calculate the number of unique operands
function "+" (Left : in Halstead_V_Star.Result;
Right : in Halstead_V_Star.Result)
return Halstead_V_Star.Result renames Halstead_V_Star."+";
-- A renames must be used because an implicit + sign is not
-- directly visible in this task. We could have used a 'use' but
-- we want to enforce the use of qualifiers.
procedure Calculate_Upper_Case_N1
(N1 : out Natural;
Operator_List : in Halstead_Operator_List.List) is
--=============================================================
-- This operation is used to calculate N1 (Total number of =
-- operators). This is done by using a generic iterate =
-- procedure inside of the generic Halstead_List. The iterate =
-- procedure will just add up the individual frequency of each=
-- operator in the list of operator. =
-- =
-- written by GER with help from Brad and JM =
--=============================================================
Initial_N1 : Natural := 0;
-- The inital value of N1 is stored here
procedure Add_Up_The_Operators (Item : in Halstead_Operator.Definition;
Frequency_Of_Item : in Natural) is
-- This procedure will be used to instantiate the iterate
-- procedure in the Halstead_List generic. The procedure is
-- used in the generic to add up the frequency of all the
-- operators
begin
-- Add_Up_The_Operators
Initial_N1 := Initial_N1 + Frequency_Of_Item;
end Add_Up_The_Operators;
-- Instantiate the iterate procedure in the Halstead generic.
-- This will allow us to find out the total number of operators
procedure Iterate_Operators is new Halstead_Operator_List.Iterate
(Process => Add_Up_The_Operators);
begin
-- Calculate_Upper_Case_N1
Iterate_Operators (Operator_List);
N1 := Initial_N1;
end Calculate_Upper_Case_N1;
procedure Calculate_Upper_Case_N2
(N2 : out Natural;
Operand_List : in Halstead_Operand_List.List) is
--=============================================================
-- This operation is used to calculate N2 (Total number of =
-- operands). This is done by using a generic iterate =
-- procedure inside of the generic Halstead_List. The iterate =
-- procedure will just add up the individual frequency of each=
-- operand in the list of operands. =
-- =
-- written by GER with help from Brad and JM =
--=============================================================
Initial_N2 : Natural := 0;
-- The inital value of N2 is stored here
procedure Add_Up_The_Operands (Item : in Halstead_Operand.Definition;
Frequency_Of_Item : in Natural) is
-- This procedure will be used to instantiate the iterate
-- procedure in the Halstead_List generic. The procedure is
-- used in the generic to add up the frequency of all the
-- operands
begin
-- Add_Up_The_Operands
Initial_N2 := Initial_N2 + Frequency_Of_Item;
end Add_Up_The_Operands;
-- Instantiate the iterate procedure in the Halstead generic.
-- This will allow us to find out the total number of operands
procedure Iterate_Operands is new Halstead_Operand_List.Iterate
(Process => Add_Up_The_Operands);
begin
-- Calculate_Upper_Case_N2
Iterate_Operands (Operand_List);
N2 := Initial_N2;
end Calculate_Upper_Case_N2;
begin
-- Halstead_State_Machine
-- Create initalized Halstead operand and operator lists
Halstead_Operator_List.Create (Empty_List => Current_Operator_List);
Halstead_Operand_List.Create (Empty_List => Current_Operand_List);
Calculate_And_Get:
loop
select
-- Store this operator in the list of operators
accept Store_Operator (The_Operator : in
Halstead_Operator.Definition) do
Stored_Operator := The_Operator;
end Store_Operator;
Halstead_Operator_List.Put (This_Item => Stored_Operator,
Into => Current_Operator_List);
or
-- Store this operand in the list of operands
accept Store_Operand (The_Operand : in
Halstead_Operand.Definition) do
Stored_Operand_Pointer :=
new Halstead_Operand.Definition'(The_Operand);
end Store_Operand;
Halstead_Operand_List.Put (This_Item =>
Stored_Operand_Pointer.all,
Into => Current_Operand_List);
Free_Operand_Node (X => Stored_Operand_Pointer);
or
-- Change the count of compilation unit parameters
accept Change_Parameters_Count
(The_Amount_To_Change : in Positive := 1) do
Delta_Parameter_Count := The_Amount_To_Change;
end Change_Parameters_Count;
-- Find out the type of program unit by rendezvous with
-- Program unit task
Program_Unit.Get_Kind_Of_Program_Unit
(The_Kind_Of_Program_Unit => Current_Program_Unit);
-- Determine the Current Parameter count from the kind
-- of program unit
case Current_Program_Unit is
when Task_Specification | Task_Type_Specification |
Task_Body | Task_Body_Stub =>
Current_Parameter_Count := Delta_Parameter_Count;
when others =>
-- accumulate number of parameters
Current_Parameter_Count :=
Delta_Parameter_Count + Current_Parameter_Count;
end case;
or
-- Calculate the total Number of operators
accept Calculate_Total_Number_Of_Operators;
Calculate_Upper_Case_N1
(N1 => Total_Number_Of_Operators,
Operator_List => Current_Operator_List);
or
-- Calculate the total Number of operands
accept Calculate_Total_Number_Of_Operands;
Calculate_Upper_Case_N2 (N2 => Total_Number_Of_Operands,
Operand_List => Current_Operand_List);
or
-- Calculate the number of unique operators
accept Calculate_Number_Of_Unique_Operators;
Number_Of_Unique_Operators :=
Calculate_Lower_Case_N1
(Operator_List => Current_Operator_List);
or
-- Calculate the number of unique operands
accept Calculate_Number_Of_Unique_Operands;
Number_Of_Unique_Operands :=
Calculate_Lower_Case_N2
(Operand_List => Current_Operand_List);
or
-- Calculate the size of vocabulary for this compilation
-- unit
accept Calculate_Size_Of_Vocabulary;
Halstead_Lower_Case_N.Of_Any_Program_Unit
(N1 => Number_Of_Unique_Operators,
N2 => Number_Of_Unique_Operands,
N => Size_Of_Vocabulary);
or
-- Calculate the program length for this compilation unit
accept Calculate_Program_Length;
Halstead_Upper_Case_N.Of_Any_Program_Unit
(N1 => Total_Number_Of_Operators,
N2 => Total_Number_Of_Operands,
N => Program_Length);
or
-- Calculate the program volume for this compilation unit
accept Calculate_Program_Volume;
Halstead_V.Of_Any_Program_Unit (Lc_N => Size_Of_Vocabulary,
Uc_N => Program_Length,
V => Current_Program_Volume);
or
-- Calculate the potential operator (n1*) for this
-- compilation unit
accept Calculate_Potential_Operator;
-- Find out the type of program unit by rendezvous with
-- Program unit task
Program_Unit.Get_Kind_Of_Program_Unit
(The_Kind_Of_Program_Unit => Current_Program_Unit);
-- Determine what the value of n1* is based on the kind
-- of program unit
case Current_Program_Unit is
when Package_Specification |
Package_Body | Package_Body_Stub =>
Number_Of_Potential_Operators :=
Natural (Halstead_Potential_Operator.
Count_Of_Package);
when Generic_Procedure_Specification |
Generic_Function_Specification |
Generic_Package_Specification |
Generic_Procedure_Instantiation |
Generic_Function_Instantiation |
Generic_Package_Instantiation =>
Number_Of_Potential_Operators :=
Natural (Halstead_Potential_Operator.Count_Of_Generic
(Formal_Parameters_Count =>
Current_Parameter_Count));
when others =>
-- i.e., subprograms (body or spec.) and
-- task entries (or ACCEPT statements)
Number_Of_Potential_Operators :=
Natural (Halstead_Potential_Operator.
Count_Of_Subprogram
(Formal_Parameters_Count =>
Current_Parameter_Count));
end case;
or
-- Calculate the potential operand (n2*) for this
-- compilation unit
accept Calculate_Potential_Operand;
-- Find out the type of program unit by rendezvous with
-- Program unit task
Program_Unit.Get_Kind_Of_Program_Unit
(The_Kind_Of_Program_Unit => Current_Program_Unit);
-- Determine what the value of n2* based on the kind
-- of program unit
case Current_Program_Unit is
when Package_Specification |
Package_Body | Package_Body_Stub =>
Number_Of_Potential_Operands :=
Natural (Halstead_Potential_Operand.
Count_Of_Package);
when Generic_Procedure_Specification |
Generic_Function_Specification |
Generic_Package_Specification |
Generic_Procedure_Instantiation |
Generic_Function_Instantiation |
Generic_Package_Instantiation =>
Number_Of_Potential_Operands :=
Natural (Halstead_Potential_Operand.Count_Of_Generic
(Formal_Parameters_Count =>
Current_Parameter_Count));
when others =>
-- i.e., subprograms (body or spec.) and
-- task entries (or ACCEPT statements)
Number_Of_Potential_Operands :=
Natural (Halstead_Potential_Operand.
Count_Of_Subprogram
(Formal_Parameters_Count =>
Current_Parameter_Count));
end case;
or
-- Find the summation so far of V* plus the number
-- of entries so far
accept Calculate_Entry_Potential_Program_Volume;
Halstead_V_Star.Of_Other_Program_Unit
(N1_Star => Halstead_Potential_Operator.Count
(Number_Of_Potential_Operators),
N2_Star => Halstead_Potential_Operand.Count
(Number_Of_Potential_Operands),
V_Star => This_V_Star);
-- accumulate potential program volumes for all entries
Summation_Of_V_Star := Summation_Of_V_Star + This_V_Star;
-- increment the number of times this entry is called for
-- use when the final version of v* is determined
Number_Of_Entries := Number_Of_Entries + 1;
or
-- Calculate the potential program volume for this
-- compilation unit
accept Calculate_Potential_Program_Volume;
-- Find out the type of program unit by rendezvous with
-- Program unit task
Program_Unit.Get_Kind_Of_Program_Unit
(The_Kind_Of_Program_Unit => Current_Program_Unit);
case Current_Program_Unit is
when Task_Specification | Task_Type_Specification |
Task_Body | Task_Body_Stub =>
Halstead_V_Star.Of_Task
(V_Entry_Total => Summation_Of_V_Star,
Number_Of_Entries => Number_Of_Entries,
V_Star => Current_Potential_Program_Volume);
when others =>
Halstead_V_Star.Of_Other_Program_Unit
(N1_Star => Halstead_Potential_Operator.Count
(Number_Of_Potential_Operators),
N2_Star => Halstead_Potential_Operand.Count
(Number_Of_Potential_Operands),
V_Star => Current_Potential_Program_Volume);
end case;
or
-- Calculate the language level for this compilation unit
accept Calculate_Language_Level;
Halstead_L.Of_Any_Program_Unit
(V => Current_Program_Volume,
V_Star => Current_Potential_Program_Volume,
L => Current_Program_Level);
or
-- Calculate the Difficulty level for this compilation
-- unit
accept Calculate_Difficulty_Level;
Halstead_D.Of_Any_Program_Unit (L => Current_Program_Level,
D => Current_Difficulty_Level);
or
-- Calculate the effort to implement for this
-- compilation unit
accept Calculate_Effort_To_Implement;
Halstead_E.Of_Any_Program_Unit (V => Current_Program_Volume,
L => Current_Program_Level,
E => Current_Effort);
or
-- Calculate the delivered bugs for this compilation
-- unit
accept Calculate_Delivered_Bugs;
Halstead_B_Hat.Of_Any_Program_Unit
(E => Current_Effort,
B_Hat => Current_Number_Of_Delivered_Bugs);
or
-- Calculate the error proneness for this compilation unit
accept Calculate_Error_Proneness;
Halstead_D_Hat.Of_Any_Program_Unit
(N1 => Halstead_Potential_Operator.Count
(Number_Of_Unique_Operators),
Lc_N2 => Halstead_Potential_Operand.Count
(Number_Of_Unique_Operands),
Uc_N2 => Total_Number_Of_Operands,
D_Hat => Current_Error_Proneness);
or
-- Calculate the Time To Understand for this compilation
-- unit
accept Calculate_Time_To_Understand;
Halstead_T.Of_Any_Program_Unit
(E => Current_Effort, T => Current_Time);
or
-- Calculate the fault rate for this compilation unit
accept Calculate_Fault_Rate;
-- Rendezvous with the lines of code task to get the
-- number of physical lines of code
Loc.Get_Physical_Lines_Count
(Physical_Lines => Current_Physical_Lines);
Halstead_B_Over_P.Of_Any_Program_Unit
(P => Current_Physical_Lines,
B_Over_P => Current_Fault_Rate);
or
-- Return the Number of unique operators for this
-- compilation unit
accept Get_Number_Of_Unique_Operators
(Lower_Case_N_1 : out Natural) do
Lower_Case_N_1 := Number_Of_Unique_Operators;
end Get_Number_Of_Unique_Operators;
or
-- Return the Number of unique operands for this
-- compilation unit
accept Get_Number_Of_Unique_Operands
(Lower_Case_N_2 : out Natural) do
Lower_Case_N_2 := Number_Of_Unique_Operands;
end Get_Number_Of_Unique_Operands;
or
-- Return the total Number of operators for this
-- compilation unit
accept Get_Total_Number_Of_Operators
(Upper_Case_N_1 : out Natural) do
Upper_Case_N_1 := Total_Number_Of_Operators;
end Get_Total_Number_Of_Operators;
or
-- Return the total Number of operands for this
-- compilation unit
accept Get_Total_Number_Of_Operands
(Upper_Case_N_2 : out Natural) do
Upper_Case_N_2 := Total_Number_Of_Operands;
end Get_Total_Number_Of_Operands;
or
-- Return the size of vocabulary for this compilation unit
accept Get_Size_Of_Vocabulary
(Lower_Case_N : out Halstead_Lower_Case_N.Result) do
Lower_Case_N := Size_Of_Vocabulary;
end Get_Size_Of_Vocabulary;
or
-- Return the program length for this compilation unit
accept Get_Program_Length (Upper_Case_N : out
Halstead_Upper_Case_N.Result) do
Upper_Case_N := Program_Length;
end Get_Program_Length;
or
-- Return the program volume for this compilation unit
accept Get_Program_Volume
(The_Program_Volume : out Halstead_V.Result) do
The_Program_Volume := Current_Program_Volume;
end Get_Program_Volume;
or
-- Return the potential program volume for this
-- compilation unit
accept Get_Potential_Program_Volume
(V_Star : out Halstead_V_Star.Result) do
V_Star := Current_Potential_Program_Volume;
end Get_Potential_Program_Volume;
or
-- Return the language level for this compilation unit
accept Get_Language_Level
(The_Language_Level : out Halstead_L.Result) do
The_Language_Level := Current_Program_Level;
end Get_Language_Level;
or
-- Return the Difficulty level for this compilation unit
accept Get_Difficulty_Level
(The_Difficulty_Level : out Halstead_D.Result) do
The_Difficulty_Level := Current_Difficulty_Level;
end Get_Difficulty_Level;
or
-- Return the effort to implement for this compilation
-- unit
accept Get_Effort_To_Implement
(The_Effort : out Halstead_E.Result) do
The_Effort := Current_Effort;
end Get_Effort_To_Implement;
or
-- Return the delivered bugs for this compilation unit
accept Get_Delivered_Bugs (B_Hat : out Halstead_B_Hat.Result) do
B_Hat := Current_Number_Of_Delivered_Bugs;
end Get_Delivered_Bugs;
or
-- Return the error proneness for this compilation unit
accept Get_Error_Proneness
(D_Hat : out Halstead_D_Hat.Result) do
D_Hat := Current_Error_Proneness;
end Get_Error_Proneness;
or
-- Return the Time To Understand this compilation unit
accept Get_Time_To_Understand
(The_Time : out Halstead_T.Result) do
The_Time := Current_Time;
end Get_Time_To_Understand;
or
-- Return the fault rate for this compilation unit
accept Get_Fault_Rate (B_Over_P : out
Halstead_B_Over_P.Result) do
B_Over_P := Current_Fault_Rate;
end Get_Fault_Rate;
or
-- Return the list of unique operators
accept Get_The_Operator_List (Operator_List : in out
Halstead_Operator_List.List) do
Operator_List := Current_Operator_List;
end Get_The_Operator_List;
or
-- Return the list of unique operands
accept Get_The_Operand_List (Operand_List : in out
Halstead_Operand_List.List) do
Operand_List := Current_Operand_List;
end Get_The_Operand_List;
or
-- Terminate this task
terminate;
end select;
end loop Calculate_And_Get;
end Halstead_State_Machine;