____ | Up | Next | Back | Forward
TOC -- / --.-- / --.--.-- | Index | Search | Syntax | Help

3.3.1 Object Declarations

An object_declaration declares a stand-alone object with a given nominal subtype and, optionally, an explicit initial value given by an initialization expression. For an array, task, or protected object, the object_declaration may include the definition of the (anonymous) type of the object.
       object_declaration ::=
           defining_identifier_list : [aliased] [constant] subtype_indication [:= expression];
         | defining_identifier_list : [aliased] [constant] array_type_definition [:= expression];
         | single_task_declaration
         | single_protected_declaration
       defining_identifier_list ::=
         defining_identifier {, defining_identifier}
Name Resolution Rules
For an object_declaration with an expression following the compound delimiter :=, the type expected for the expression is that of the object. This expression is called the initialization expression.
Legality Rules
An object_declaration without the reserved word constant declares a variable object. If it has a subtype_indication or an array_type_definition that defines an indefinite subtype, then there shall be an initialization expression. An initialization expression shall not be given if the object is of a limited type.
Static Semantics
An object_declaration with the reserved word constant declares a constant object. If it has an initialization expression, then it is called a full constant declaration. Otherwise it is called a deferred constant declaration. The rules for deferred constant declarations are given in clause 7.4. The rules for full constant declarations are given in this subclause.
Any declaration that includes a defining_identifier_list with more than one defining_identifier is equivalent to a series of declarations each containing one defining_identifier from the list, with the rest of the text of the declaration copied for each declaration in the series, in the same order as the list. The remainder of this International Standard relies on this equivalence; explanations are given for declarations with a single defining_identifier.
The subtype_indication or full type definition of an object_declaration defines the nominal subtype of the object. The object_declaration declares an object of the type of the nominal subtype.
Dynamic Semantics
If a composite object declared by an object_declaration has an unconstrained nominal subtype, then if this subtype is indefinite or the object is constant or aliased (see 3.10) the actual subtype of this object is constrained. The constraint is determined by the bounds or discriminants (if any) of its initial value; the object is said to be constrained by its initial value. In the case of an aliased object, this initial value may be either explicit or implicit; in the other cases, an explicit initial value is required. When not constrained by its initial value, the actual and nominal subtypes of the object are the same. If its actual subtype is constrained, the object is called a constrained object.
For an object_declaration without an initialization expression, any initial values for the object or its subcomponents are determined by the implicit initial values defined for its nominal subtype, as follows:
The elaboration of an object_declaration proceeds in the following sequence of steps:
For the third step above, the object creation and any elaborations and evaluations are performed in an arbitrary order, except that if the default_expression for a discriminant is evaluated to obtain its initial value, then this evaluation is performed before that of the default_expression for any component that depends on the discriminant, and also before that of any default_expression that includes the name of the discriminant. The evaluations of the third step and the assignments of the fourth step are performed in an arbitrary order, except that each evaluation is performed before the resulting value is assigned.
There is no implicit initial value defined for a scalar subtype. In the absence of an explicit initialization, a newly created scalar object might have a value that does not belong to its subtype (see 13.9.1 and H.1).

Example of a multiple object declaration:
       --  the multiple object declaration
       John, Paul : Person_Name := new Person(Sex => M);  --  see 3.10.1
       --  is equivalent to the two single object declarations in the order given
       John : Person_Name := new Person(Sex => M);
       Paul : Person_Name := new Person(Sex => M);
Examples of variable declarations:
       Count, Sum  : Integer;
       Size        : Integer range 0 .. 10_000 := 0;
       Sorted      : Boolean := False;
       Color_Table : array(1 .. Max) of Color;
       Option      : Bit_Vector(1 .. 10) := (others => True);
       Hello       : constant String := "Hi, world.";
Examples of constant declarations:
       Limit     : constant Integer := 10_000;
       Low_Limit : constant Integer := Limit/10;
       Tolerance : constant Real := Dispersion(1.15);

____ | Up | Next | Back | Forward
TOC -- / --.-- / --.--.-- | Index | Search | Syntax | Help

Ada WWW Home -- Email comments, additions, corrections, gripes, kudos, etc. to:

Magnus Kempe -- Magnus.Kempe@di.epfl.ch
Copyright statement
Page last generated: 95-03-12