SUMMARY OF Ada LANGUAGE STRUCTURES and other information

     This summary was extracted from ANSI/ISO/IEC-8652:1995.
  It is not intended to be 100% complete. Hopefully it will be
  useful as a memory aid in writing Ada programs.

   Notation is kept as simple as possible. 
      -- DECLARATIONS  means Ada declaration(s) can be inserted

      \_ optional  means this part or section is optional
      /           ( all optional cases not necessarily shown)

      ...  means more of the same allowed, use common sense

      occasionally a statement will be shown in a structure,
      this is just a reminder of something useful or required.


COMPILATION UNITS: These are the structures that can be
compiled in a single compilation. Keep in mind that Ada
allows virtually unlimited nesting. Almost any structure
can be nested in almost any other structure. Every compilation
unit can be preceded by pragmas and context clauses.

   procedure NAME is       -- structure of a main procedure  (program)
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
              return ;  -- allowed, but not usually present
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end NAME ;



   procedure NAME ( PARAMETER :  in out TYPE ; ... ) is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
              return ;  -- allowed
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end NAME ;



   function NAME ( PARAMETER : TYPEx ; ...) return TYPEy is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
              return OBJECT ;  -- of TYPEy required
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end NAME ;


   package NAME is
        -- DECLARATIONS
   private                                   \_ optional
        -- MORE DECLARATIONS                 /
   end NAME ;


   package body NAME is
        -- DECLARATIONS                    _
   begin                                    \
        -- EXECUTABLE STATEMENTS             \_ optional
   exceptions                                /
        -- EXCEPTION HANDLERS              _/
   end NAME ;



   package MY_NAME is
        -- DECLARATIONS
        procedure PROC ;
        function FUNCT(PARAMETER:TYPEx;...) return TYPEy ;
   end MY_NAME ;


   package body MY_NAME is
        -- DECLARATIONS
        procedure PROC is
            -- PROCEDURE STUFF
        end PROC ;
        function FUNCT(PARAMETER:TYPEx;...) return TYPEy is
            -- FUNCTION STUFF
        end FUNCT ;
   end MY_NAME ;



   package P_NAME is
      task NAME is
           --DECLARATIONS
           entry LIKE_PROC(PARAMETER:TYPE;...) ;
           ...
      end NAME ;
   end P_NAME ;

   package body P_NAME is
      task body NAME is          -- task body parallels package body
           -- DECLARATIONS
      begin
           -- EXECUTABLE STATEMENTS
           accept LIKE_PROC(PARAMETER:TYPE;...) do
                -- EXECUTABLE STATEMENTS
           end LIKE_PROC ;
             -- EXECUTABLE STATEMENTS
           ...
      exception                                 \_ optional
           -- EXCEPTION HANDLERS                /
      end NAME ;
   end P_NAME ;


   package body P_NAME is    -- A more complicated body
      task body NAME is
           -- DECLARATIONS
      begin
         loop
            select
               accept LIKE_PROC(PARAMETER:TYPE;...) do
                   -- EXECUTABLE STATEMENTS
               end LIKE_PROC ;
            or
               accept ...
               end ...
            end select ;
         end loop ;
      end NAME ;
   end P_NAME ;



   separate ( SOME_PACKAGE )
   procedure SOME_PROCEDURE is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end SOME_PROCEDURE ;

   separate ( SOME_PACKAGE )
   function SOME_FUNCTION return CHARACTER is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end SOME_FUNCTION ;


   separate ( SOME_PACKAGE )
   task body SOME_TASK is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end SOME_TASK ;

   separate ( SOME_PACKAGE )
   package body SOME_BODY is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end SOME_BODY ;


   separate( SOME_PACKAGE.SOME_BODY )
   package body SUB_SUB_UNIT is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end SOME_BODY ;

   generic
        -- FORMAL GENERIC PARAMETERS
   procedure GENERIC_PROCEDURE is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end GENERIC_PROCEDURE ;


   generic
        -- FORMAL GENERIC PARAMETERS
   function GENERIC_FUNCTION is
        -- DECLARATIONS
   begin
        -- EXECUTABLE STATEMENTS
   exception                                 \_ optional
        -- EXCEPTION HANDLERS                /
   end GENERIC_FUNCTION ;


   generic
        -- FORMAL GENERIC PARAMETERS
   package GENERIC_PACKAGE is
        -- DECLARATIONS
   private                                   \_ optional
        -- PRIVATE DECLARATIONS              /
   end GENERIC_PACKAGE ;



   with GENERIC_PROCEDURE ;
   procedure ACTUAL_PROCEDURE is new GENERIC_PROCEDURE ( TYPES ) ;


   with GENERIC_FUNCTION ;
   function ACTUAL_FUNCTION is new GENERIC_FUNCTION ( TYPES ) ;


   with GENERIC_PACKAGE ;
   package ACTUAL_PACKAGE is new GENERIC_PACKAGE ( TYPES ) ;



   procedure JUST_SPECIFICATION ;

   procedure SPECIFICATION ( Parameters... ) ;

   function SPECIFICATION ( Parameters ... ) return TYPEy ;


CONTEXT CLAUSEs  any number of the following.

   with LIBRARY_UNIT_NAME ;

   with NAME_1 , NAME_2, ... ;

   with NAME_1 ; use NAME_1 ;

   use  NAME_1 , NAME_2, ... ;




  EXECUTABLE STATEMENT STRUCTURES


   declare                                     \_ optional
        -- DECLARATIONS                        /
   begin
        -- EXECUTABLE STATEMENTS
           return ;  -- allowed
   exception                                   \_ optional
        -- EXCEPTION HANDLERS                  /
   end ;


   LOOP_NAME :
   loop
        -- EXECUTABLE STATEMENTS
           exit ;                              \
           exit when A>B ;                      \_ optional in any loop
           exit ANY_LOOP_NAME ;                 /
           exit ANY_LOOP_NAME when A>B ;       /
   end loop ;



   while A>B loop
        -- EXECUTABLE STATEMENTS
   end loop ;



   for NAME in P..Q loop
        -- EXECUTABLE STATEMENTS
   end loop ;



   for NAME in reverse P..Q loop    -- P <= Q
        -- EXECUTABLE STATEMENTS
   end loop ;


   if BOOLEAN_EXPRESSION then
       -- EXECUTABLE STATEMENTS
   end if ;



   if BOOLEAN_EXPRESSION then
        -- EXECUTABLE STATEMENTS
   elsif BOOLEAN_EXPRESSION2 then                       \_ optional
        -- EXECUTABLE STATEMENTS                        /
   ...
   else                                                 \_ optional
        -- EXECUTABLE STATEMENTS                        /
   end if ;




   if BOOL_EXP1 and then BOOL_EXP2 ... then
        -- EXECUTABLE STATEMENTS
   elsif  BOOL_EXP3 or else BOOL_EXP4 ... then
        -- EXECUTABLE STATEMENTS
   else
        -- EXECUTABLE STATEMENTS
   end if ;



   case NAME is                  -- NAME is an object of a discrete type
     when VALUE1 =>                  -- VALUE's are legal for object NAME
        -- EXECUTABLE STATEMENTS
     when VALUE2 =>
        -- EXECUTABLE STATEMENTS
     when VALUE3 | VALUE5 | VALUE7 =>
        -- EXECUTABLE STATEMENTS
     when VALUE12 .. VALUE20 =>
        -- EXECUTABLE STATEMENTS
     ...
     when others =>                           \_ optional
        -- EXECUTABLE STATEMENTS              /
   end case ;
 

          Renaming declarations

  All of these must appear in a declarative region where the entity on the
  right side of the renames declaration is visible.
  The "existing" may be selected, e.g. SOME_PACKAGE.OBJECT_NAME_IN_PACKAGE
  Renaming is sometimes used to allow a short name in a localized scope.

  NEW_INENTIFIER_NAME : SOME_TYPE_MARK renames EXISTING_OBJECT_NAME ;
  NEW_EXCEPTION_NAME : exception renames EXISTING_EXCEPTION_NAME ;
  package NEW_PACKAGE_NAME renames EXISTING_PACKAGE_NAME ;
  procedure NEW_PROCEDURE_NAME ( formal ) renames EXISTING_PROCEDURE_NAME ;
  procedure NEW_TASK_ENTRY_NAME ( formal ) renames EXISTING_TASK_ENTRY_NAME ;
  function NEW_FUNCTION_NAME ( formal ) return TYPEX renames
                                                     EXISTING_FUNCTION_NAME ;


  function NEW_ENUMERATION_LITERAL return EXISTING_ENUMERATION_TYPE renames
                                          EXISTING_ENUMERATION_LITERAL ;

  subtype NEW_TYPE_NAME is EXISTING_TYPE_NAME ; -- renaming a type



  Note: The existing entity is still visible.
      Either or both the new and existing function names may be quoted
      operators, e.g. "+"

      The  ( formal ) can have different names for formal parameters but must
      have the same number of parameters of the same type in the same order
      as the existing entity.

      Some restrictions apply.