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 - metrics - download
Index: B T

⟦d5476d849⟧ TextFile

    Length: 12681 (0x3189)
    Types: TextFile
    Names: »B«

Derivation

└─⟦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

separate (Compilation_Unit.Produce_Metrics)
procedure Extended_Program_Unit
             (Current_Compilation_Unit : in out Ada_Compilation_Unit;
              Program_Unit : in Program_Unit_State_Machine;
              Halstead : in Halstead_State_Machine;
              Loc : in Loc_State_Machine;
              Mccabe : in Mccabe_State_Machine) is

    --=========================================================================
    -- Extended_Program_Unit ::=
    --   Procedure_Unit
    -- | Function_Unit
    -- | Package_Unit
    -- | Generic_Specification
    -- | Task_Unit

    -- SEPARATE counts as one LOC data declaration
    -- | "SEPARATE" "(" Expanded_Name ")" Proper_Body

    -- <IDENTIFIER> is program unit name
    -- Program unit kind is NAMED_BLOCK
    -- | <IDENTIFIER> ":" Named_Block

    -- Get block label "UNNAMED_BLOCK_xxx" where xxx
    -- is a unique integer.
    -- Program unit kind is UNNAMED_BLOCK
    -- | "DECLARE" Common_Body ";"

    -- Get block label "UNNAMED_BLOCK_xxx" where xxx
    -- is a unique integer.
    -- Program unit is UNNAMED_BLOCK
    -- | Begin_End_Block ";"
    --=========================================================================

    Current_Token : Token_Package.Token;  -- token being procesed
    Peek_Ahead_Token : Token_Package.Token;  -- next token in file
    Unit_Name : Program_Unit_Name;    -- Name of current unit

begin
    -- Extended_Program_Unit

    Peek_Ahead_Token := Peek (From => Current_Compilation_Unit);
    case Token_Package.Class_Of (Peek_Ahead_Token) is

        when Token_Package.Keyword =>

            case Token_Package.Value_Of (Peek_Ahead_Token) is

                when Token_Package.Procedure_Token =>

                    if Token_Package.Value_Of
                          (Peek (From => Current_Compilation_Unit,
                                 Offset => 4)) = Token_Package.New_Token then
                        Generic_Instantiation (Current_Compilation_Unit =>
                                                  Current_Compilation_Unit,
                                               Program_Unit => Program_Unit,
                                               Halstead => Halstead,
                                               Loc => Loc,
                                               Mccabe => Mccabe);
                    else
                        Procedure_Unit (Current_Compilation_Unit =>
                                           Current_Compilation_Unit,
                                        Program_Unit => Program_Unit,
                                        Halstead => Halstead,
                                        Loc => Loc,
                                        Mccabe => Mccabe);
                    end if;

                when Token_Package.Function_Token =>

                    if Token_Package.Value_Of
                          (Peek (From => Current_Compilation_Unit,
                                 Offset => 4)) = Token_Package.New_Token then
                        Generic_Instantiation (Current_Compilation_Unit =>
                                                  Current_Compilation_Unit,
                                               Program_Unit => Program_Unit,
                                               Halstead => Halstead,
                                               Loc => Loc,
                                               Mccabe => Mccabe);
                    else
                        Function_Unit (Current_Compilation_Unit =>
                                          Current_Compilation_Unit,
                                       Program_Unit => Program_Unit,
                                       Halstead => Halstead,
                                       Loc => Loc,
                                       Mccabe => Mccabe);
                    end if;

                when Token_Package.Package_Token =>

                    if Token_Package.Value_Of
                          (Peek (From => Current_Compilation_Unit,
                                 Offset => 4)) = Token_Package.New_Token then
                        Generic_Instantiation (Current_Compilation_Unit =>
                                                  Current_Compilation_Unit,
                                               Program_Unit => Program_Unit,
                                               Halstead => Halstead,
                                               Loc => Loc,
                                               Mccabe => Mccabe);
                    else
                        Package_Unit (Current_Compilation_Unit =>
                                         Current_Compilation_Unit,
                                      Program_Unit => Program_Unit,
                                      Halstead => Halstead,
                                      Loc => Loc,
                                      Mccabe => Mccabe);
                    end if;

                when Token_Package.Generic_Token =>
                    Generic_Specification
                       (Current_Compilation_Unit => Current_Compilation_Unit,
                        Program_Unit => Program_Unit,
                        Halstead => Halstead,
                        Loc => Loc,
                        Mccabe => Mccabe);

                when Token_Package.Task_Token =>
                    Task_Unit (Current_Compilation_Unit =>
                                  Current_Compilation_Unit,
                               Program_Unit => Program_Unit,
                               Halstead => Halstead,
                               Loc => Loc,
                               Mccabe => Mccabe);

                when Token_Package.Separate_Token =>
                    Get_Next_Token (Out_Token => Current_Token,
                                    From => Current_Compilation_Unit,
                                    Current_Loc => Loc);

                    -- increment LOC data declaration
                    Loc.Change_Data_Declarations_Count;

                    -- increment Halstead SEPARATE operator count
                    Halstead.Store_Operator
                       ((Kind => Halstead_Operator.Separate_Halstead));

                    Get_Next_Token (Out_Token => Current_Token,
                                    From => Current_Compilation_Unit,
                                    Current_Loc => Loc);

                    if "/=" (Token_Package.Value_Of (Current_Token),
                             Token_Package.Left_Parenthesis_Token) then
                        raise Syntax_Error;
                    end if;

                    -- increment Halstead PARENTHESES operator count
                    Halstead.Store_Operator
                       ((Kind => Halstead_Operator.Parentheses_Halstead));

                    Expanded_Name
                       (Current_Compilation_Unit => Current_Compilation_Unit,
                        Program_Unit => Program_Unit,
                        Halstead => Halstead,
                        Loc => Loc,
                        Mccabe => Mccabe);

                    Get_Next_Token (Out_Token => Current_Token,
                                    From => Current_Compilation_Unit,
                                    Current_Loc => Loc);

                    if "/=" (Token_Package.Value_Of (Current_Token),
                             Token_Package.Right_Parenthesis_Token) then
                        raise Syntax_Error;
                    end if;

                    Proper_Body
                       (Current_Compilation_Unit => Current_Compilation_Unit,
                        Program_Unit => Program_Unit,
                        Halstead => Halstead,
                        Loc => Loc,
                        Mccabe => Mccabe);

                when Token_Package.Declare_Token =>
                    Get_Next_Token (Out_Token => Current_Token,
                                    From => Current_Compilation_Unit,
                                    Current_Loc => Loc);

                    -- get UNNAMED_BLOCK_xxx label
                    Get_Block_Name (Unit_Name);
                    Program_Unit.Store_Program_Unit_Name
                       (The_Program_Unit_Name => Unit_Name);

                    -- set program unit kind to UNNAMED_BLOCK
                    Program_Unit.Store_Kind_Of_Program_Unit
                       (The_Kind_Of_Program_Unit => Unnamed_Block);

                    -- increment Halstead DECLARE operator count
                    Halstead.Store_Operator
                       ((Kind => Halstead_Operator.Declare_Halstead));

                    Common_Body
                       (Current_Compilation_Unit => Current_Compilation_Unit,
                        Program_Unit => Program_Unit,
                        Halstead => Halstead,
                        Loc => Loc,
                        Mccabe => Mccabe);

                    Get_Next_Token (Out_Token => Current_Token,
                                    From => Current_Compilation_Unit,
                                    Current_Loc => Loc);

                    if "/=" (Token_Package.Value_Of (Current_Token),
                             Token_Package.Semicolon_Token) then
                        raise Syntax_Error;
                    end if;

                    -- increment Halstead SEMICOLON operator count
                    Halstead.Store_Operator
                       ((Kind => Halstead_Operator.Semicolon_Halstead));

                when Token_Package.Begin_Token =>

                    -- get UNNAMED_BLOCK_xxx label
                    Get_Block_Name (Unit_Name);
                    Program_Unit.Store_Program_Unit_Name
                       (The_Program_Unit_Name => Unit_Name);

                    -- set program unit kind to UNNAMED_BLOCK
                    Program_Unit.Store_Kind_Of_Program_Unit
                       (The_Kind_Of_Program_Unit => Unnamed_Block);

                    Begin_End_Block
                       (Current_Compilation_Unit => Current_Compilation_Unit,
                        Program_Unit => Program_Unit,
                        Halstead => Halstead,
                        Loc => Loc,
                        Mccabe => Mccabe);

                    Get_Next_Token (Out_Token => Current_Token,
                                    From => Current_Compilation_Unit,
                                    Current_Loc => Loc);

                    if "/=" (Token_Package.Value_Of (Current_Token),
                             Token_Package.Semicolon_Token) then
                        raise Syntax_Error;
                    end if;

                    -- increment Halstead SEMICOLON operator count
                    Halstead.Store_Operator
                       ((Kind => Halstead_Operator.Semicolon_Halstead));

                when others =>
                    raise Syntax_Error;

            end case;

        when Token_Package.Identifier =>
            Get_Next_Token (Out_Token => Current_Token,
                            From => Current_Compilation_Unit,
                            Current_Loc => Loc);

            -- set program unit name
            Unit_Name := String_To_Name
                            (Token_Package.Value_Of (Current_Token));
            Program_Unit.Store_Program_Unit_Name
               (The_Program_Unit_Name => Unit_Name);

            -- set program unit kind to NAMED_BLOCK
            Program_Unit.Store_Kind_Of_Program_Unit
               (The_Kind_Of_Program_Unit => Named_Block);

            -- increment Halstead operand count
            Halstead.Store_Operand (Halstead_Operand.Definition
                                       (Token_Package.Value_Of
                                           (This_Token => Current_Token)));

            Get_Next_Token (Out_Token => Current_Token,
                            From => Current_Compilation_Unit,
                            Current_Loc => Loc);

            if "/=" (Token_Package.Value_Of (Current_Token),
                     Token_Package.Colon_Token) then
                raise Syntax_Error;
            end if;

            -- increment Halstead COLON operator count
            Halstead.Store_Operator ((Kind =>
                                         Halstead_Operator.Colon_Halstead));

            Named_Block (Current_Compilation_Unit => Current_Compilation_Unit,
                         Program_Unit => Program_Unit,
                         Halstead => Halstead,
                         Loc => Loc,
                         Mccabe => Mccabe);

        when others =>
            raise Syntax_Error;

    end case;

end Extended_Program_Unit;