Appendix A Entity and Reference Kinds

prevnext

Ada Entity Kinds


This section lists the general categories of Ada entity kinds and the specific kind literal names and full kind names associated with them.

About "Local" Kinds

"Local" as part of an entity kind indicates that the entity was declared inside a package or task body, within a subroutine or block, or within the private part of a package specification or protected declaration.

Conversely, entities that do not have "local" as part of the entity kind are entities that are library units, or are declared within the visible part of a package or protected declaration, or within a task declaration.

Note: Some entity kinds do not have both a "Local" and non-local version. For example, there are no Local private types since the private declaration must appear in the visible part of a package specification.

About Derived Types and SubTypes

Derived types and subtypes are given an entity kind that corresponds to the entity kind of the root type. For example:

    type color is (red, orange, yellow, green, blue, violet); 
    type rainbow_color is new color; 
    type paint_color is new rainbow_color;
 

The kind for all three types will be Udb_adaTypeEnumeration.

Ada Component Kinds

KIND FULLName Literal Name
Ada Component Udb_adaComponent
Ada Component Local Udb_adaComponentLocal
Use "ada component" to match all Ada component kinds.

A component is a record component. It may be local or non-local. For example:

 type rec_type is record
    component : integer;   -- Udb_adaComponent
end record;

Ada Constant Kinds

KIND FULLName Literal Name
Ada Constant Udb_adaConstant
Ada Constant Local Udb_adaConstantLocal
Ada Constant Deferred Udb_adaConstantDeferred
Use "ada constant" to match all Ada constant kinds.

A constant is a constant object or named number. It may be local or non-local. For example:

 const1 : constant integer := 5;   -- Udb_adaConstant
     or
const2 : constant := 5;             -- Udb_adaConstant
 

A constant may have a deferred constant declaration.

 package some_pack is
   const : constant integer;
private
   const : constant integer := 5; -- Udb_adaConstantDeferred
end;

Ada Entry Kinds

KIND FullName Literal Name
Ada Entry Udb_adaEntry
Use "ada entry" to match all Ada entry kinds.

An entry is an entry for a task or protected unit or type.

 task some_task is
    entry e;           -- Udb_adaEntry

Ada Enumeration Literal Kinds

KIND FULlName Literal Name
Ada Enumeration Literal Udb_adaEnumerationLiteral
Use "ada enumeration Literal" to match all Ada enumeration literals.

This kind is an enumeration literal for an enumeration type.

 type light_color is (green, yellow, red);
   -- green, yellow and red are all Udb_adaEnumerationLiteral

Ada Exception Kinds

KIND FULlName Literal Name
Ada Exception Udb_adaException
Ada Exception Local Udb_adaExceptionLocal
Ada Exception Object Local Udb_adaExceptionObjectLocal
Use "ada exception" to match all Ada exception kinds.

An exception is a declared exception and may local or non-local.

 bad_value : exception;   -- Udb_adaException
 

An exception object local is a choice parameter from an exception handler.

 when the_error : bad_value => 
            -- the_error is the Udb_adaExceptionObjectLocal

Ada File Kinds

KIND FULlName Literal Name
Ada File Udb_adaFile
Use "ada file" to match all Ada file kinds.

Any file in an ada project.

Ada Function Kinds

KIND FULlName Literal Name
Ada Abstract Function Udb_adaAbstractFunction
Ada Abstract Function Local Udb_adaAbstractFunctionLocal
Ada Function Udb_adaFunction
Ada Function Local Udb_adaFunctionLocal
Ada Generic Function Udb_adaGenericFunction
Ada Generic Function Local Udb_adaGenericFunctionLocal
Use "ada function" to match all Ada function kinds.

A function may be local or non-local.

  function sum (a, b : integer) return integer; 
                   -- sum is Udb_adaFunction
 

A function may be generic.

 generic
   type t is private;
 function sum (a, b : t) return t;  -- Udb_adaFunctionGeneric
 

A function may be abstract.

 function Get return abs_type is abstract; 
                               -- Udb_adaAbstractFunction

Ada Object Kinds

KIND FULlName Literal Name
Ada Loop Object Local Udb_adaLoopObjectLocal
Ada Object Udb_adaObject
Ada Object Local Udb_adaObjectLocal
Ada Protected Object Udb_adaProtectedObject
Ada Protected Object Local Udb_adaProtectedObjectLocal
Ada Task Object Udb_adaTaskObject
Ada Task Object Local Udb_adaTaskObjectLocal
Use "ada object" to match all Ada object kinds.

An object is a non-constant object and may be local or non-local.

 size : integer range 1..10 := 1;  -- Udb_adaObject

An object may be a loop parameter and is local.

 for j in 1..10 loop  -- j is Udb_adaLoopObjectLocal
   ...
end loop;
 

A protected object is declared as an object of a protected type and may be local or non-local.

 obj : some_protected_type;    -- Udb_adaProtectedObject
 

A task object is declared as an object of a task type.

 obj : some_task_type;         -- Udb_adaTaskObject

Ada Package Kinds

KIND FULlName Literal Name
Ada Generic Package Udb_adaGenericPackage
Ada Generic Package Local Udb_adaGenericPackageLocal
Ada Package Udb_adaPackage
Ada Package Local Udb_adaPackageLocal
Use "ada package" to match all Ada package kinds.

A non-generic package may be local or non-local.

 package list_pkg is     -- Udb_adaPackage
   ...
end;
 

A local or non-local package may also be generic.

 generic
   type t is private;
package set_pack is      -- Udb_adaGenericPackage
   ...
end;

Ada Parameter Kinds

KIND FULlName Literal Name
Ada Parameter Udb_adaParameter
Use "ada parameter" to match all Ada parameter kinds.

A parameter is a subroutine or entry parameter.

 procedure some_proc (a, b : integer);
           -- a and b are both of kind Udb_adaParameter

Ada Procedure Kinds

KIND FULlName Literal Name
Ada Generic Procedure Udb_adaAbstractProcedure
Ada Generic Procedure Local Udb_adaAbstractProcedureLocal
Ada Abstract Procedure Udb_adaGenericProcedure
Ada Abstract Procedure Local Udb_adaGenericProcedureLocal
Ada Procedure Udb_adaProcedure
Ada Procedure Local Udb_adaProcedureLocal
Use "ada procedure" to match all Ada procedure kinds.

A non-generic procedure may be local or non-local.

 procedure max (a, b : in integer; m : out integer);
          -- max is of kind Udb_adaProcedure
 

A local or non-local procedure may be generic.

 generic
   type t is private;
procedure switch (a, b: in out t); 
                                    -- Udb_adaGenericProcedure
 

A local or non-local procedure may be abstract.

 procedure Put(val : in abs_type) is abstract; 
                                    --Udb_adaAbstractProcedure

Ada Protected Kinds

KIND FULlName Literal Name
Ada Protected Udb_adaProtected
Ada Protected Local Udb_adaProtectedLocal
Ada Protected Object Udb_adaProtectedObject
Ada Protected Object Local Udb_adaProtectedObjectLocal
Ada Protected Type Udb_adaProtectedType
Ada Protected Type Local Udb_adaProtectedTypeLocal
Ada Protected Type Private Udb_adaProtectedTypePrivate
Use "ada protected" to match all Ada protected kinds.

A protected kind of object is declared with a single protected unit declaration.

 protected shared_data is
    ...
private
   data : integer;        -- Udb_adaProtected
end;
 

A protected object is declared as an object of a protected type.

 obj : some_protected_type;  -- Udb_adaProtectedObject
 

A type may be a protected type, either local or non-local.

 protected type some_protected_type is  
                                   -- Udb_adaProtectedType
   ...  
private
   ...
end;
 

A protected type may be declared as private.

 package some_pack is
   type some_protected_type is private;
private
   protected type some_protected_type is
                            -- Udb_adaProtectedTypePrivate
      ...
   private
      ...
   end;
 end;

Ada Task Kinds

KIND FULlName Literal Name
Ada Task Udb_adaTask
Ada Task Local Udb_adaTaskLocal
Ada Task Object Udb_adaTaskObject
Ada Task Object Local Udb_adaTaskObjectLocal
Ada Task Type Udb_adaTaskType
Ada Task Type Local Udb_adaTaskTypeLocal
Ada Task Type Private Udb_adaTaskTypePrivate
Use "ada task" to match all Ada task kinds.

A task is a task object declared with a single task unit declaration.

 task buffer is                -- Udb_adaTask
   ...
end;
 

A task object is declared as an object of a task type.

 obj : some_task_type;           -- Udb_adaTaskObject
 

A task type.

 task type some_task_type is   -- Udb_adaTaskType
   ...
private
   ...
end;
 

A task type may be declared as private.

 package some_pack is
   type some_task_type is private;
private
   task type some_task_type is -- Udb_adaTaskTypePrivate
      ...
   private
      ...
   end;
end;

Ada Type Kinds

KIND FULlName Literal Name
Ada Abstract Tagged Type Record Udb_adaAbstractTaggedTypeRecord
Ada Abstract Tagged Type Record Local Udb_adaAbstractTaggedTypeRecordLocal
Ada Abstract Tagged Type Record Private Udb_adaAbstractTaggedTypeRecordPrivate
Ada Protected Type Udb_adaProtectedType
Ada Protected Type Local Udb_adaProtectedTypeLocal
Ada Protected Type Private Udb_adaProtectedTypePrivate
Ada Tagged Type Record Udb_adaTaggedTypeRecord
Ada Tagged Type Record Local Udb_adaTaggedTypeRecordLocal
Ada Tagged Type Record Private Udb_adaTaggedTypeRecordPrivate
Ada Task Type Udb_adaTaskType
Ada Task Type Local Udb_adaTaskTypeLocal
Ada Task Type Private Udb_adaTaskTypePrivate
Ada Type Udb_adaType
Ada Type Local Udb_adaTypeLocal
Ada Type Access Udb_adaTypeAccess
Ada Type Access Local Udb_adaTypeAccessLocal
Ada Type Access Private Udb_adaTypeAccessPrivate
Ada Type Access Subprogram Udb_adaTypeAccessSubprogram
Ada Type Access Subprogram Local Udb_adaTypeAccessSubprogramLocal
Ada Type Access Subprogram Private Udb_adaTypeAccessSubprogramPrivate
Ada Type Enumeration Udb_adaTypeEnumeration
Ada Type Enumeration Local Udb_adaTypeEnumerationLocal
Ada Type Enumeration Private Udb_adaTypeEnumerationPrivate
Ada Type Private Udb_adaTypePrivate
Ada Type Record Udb_adaTypeRecord
Ada Type Record Local Udb_adaTypeRecordLocal
Ada Type Record Private Udb_adaTypeRecordPrivate
Use "ada type" to match all Ada type kinds.

A normal ada type is any type or subtype that is not an access, enumeration, or record type. It may be local or non-local.

 type some_int is range 1 .. 2000;   -- Udb_adaType
 

A private type is any type or subtype that is not an access, enumeration, or record type and that is declared as private.

 package some_pack is
   type some_int is private;
private
   type some_int is range 1 .. 2000;  -- Udb_adaTypePrivate
end;
 

An access to an object type may be local or non-local.

 type int_access is access integer;  -- Udb_adaTypeAccess
 

An access to object type may be declared as private.

 package some_pack is
   type int_access is private;
private
   type int_access is access integer; 
                            -- Udb_adaTypeAccessPrivate
end;
 

An access to a subprogram type may be local or non-local.

 type proc_access is access procedure(a : integer);
                             -- Udb_adaTypeAccessSubprogram
 

An access to a subprogram type may be declared as private.

 package some_pack is
   type proc_access is private;
private
   type proc_access is access procedure(a : integer);
                   -- Udb_adaTypeAccessSubprogramPrivate
end;
 

A type may be an enumeration type.

 type light_color is (green, yellow, red);
      -- light_color is of kind Udb_adaTypeEnumeration
 

An enumeration type may be declared as private.

 package some_pack is
   type light_color is private; 
private
   type light_color is (green, yellow, red);
     -- light_color is of kind Udb_adaTypeEnumerationPrivate
end;
 

A record type is a non-abstract, non-tagged, record type. It may be local or non-local.

 type rec_type is record         -- Udb_adaTypeRecord
   component : integer;
end record;
 

A non-abstract, non-tagged, record type may be declared as private.

 package some_pack is
   type rec_type is private;
private
    type rec_type is record     -- Udb_adaTypeRecordPrivate
       component : integer;
   end record;
 end;
 

A record type may be a non-abstract tagged type. It may be local or non-local.

 type tagged_type is tagged null record; 
                                   -- Udb_adaTaggedTypeRecord

A tagged type may be declared as private.

 package some_pack is
   type tagged_priv_type is private; 
private
    type tagged_priv_type is tagged null record;
                      -- Udb_adaTaggedTypeRecordPrivate
 end;
 

An abstract tagged type may be local or non-local.

 type abs_type is abstract tagged null record;
                        -- Udb_adaAbstractTaggedTypeRecord

An abstract tagged type may be declared as private.

 package some_pack is
   type abs_priv_type is private;
private
   type abs_priv_type is abstract tagged null record;
                 -- Udb_adaAbstractTaggedTypeRecordPrivate
end;
 

Ada Unknown Kinds

KIND FULlName Literal Name
Ada Unknown Udb_adaUnknown
Use "ada unknown" to match all Ada unknown kinds.

An unknown entity is one that is used but not declared. Currently, "Unknown" entities are only created in cases where the missing entity is withed or renamed.

 with unknown_pack;  -- this package is not in project        
procedure some_proc is 
...
 

Ada Unresolved Kinds

KIND FULlName Literal Name
Ada Unresolved Udb_adaUnresolved
Use "ada unresolved" to match all Ada unresolved kinds.

prevnext


Scientific Toolworks, Inc.
http://www.scitools.com
Voice: (802) 763-2995
Fax: (802) 763-3066
support@scitools.com
sales@scitools.com