Elaboration of a declaration

Elaborating a declaration corresponds to generating the declared construct. The syntactic rules (above all those concerning the validity range) do not allow a construct to be used before the corresponding declaration has been elaborated.

A subprogram-declaration is elaborated by elaborating the corresponding interface- parameter list. By doing so the subtype of every interface element and thus also the subtype of every formal parameter in the subprogram is determined.

The elaboration of the subprogram body allows the subprogram to be used in following (not in previous!) subprogram calls.

The system at first elaborates the type definition and afterwards generates the type. With a constrained array declaration, however, at first the equally valued unconstrained array type is elaborated (i.e. the elements` subtypes are elaborated) and then the subtype which corresponds to the unconstrained array type is elaborated.

The elaboration of an enumeration type generates the corresponding type. With integer-, floating point- or physical type definitions the corresponding subtypes are determined. With physical type definitions the units are generated as well.

One data set (Record construction) is elaborated by elaborating the individual elements` declarations in the given sequence (similar to array type)

The elaboration of an element declaration consists of determining the subtype. The elaboration of an index declaration is equal to that of the corresponding subtype.

Here the subtype is determined and generated. If the subtype is unconstrained it is similar to the base type. Otherwise at first the limitation is elaborated and afterwards compatibility towards the base type is checked.

A limitation to the value range is elaborated by calculating this value range. In doing so the value limits and the counting direction of the range are defined. A limitation in size is elaborated by calculating the corresponding expression.

Here one has to distinguish between file-objects and other objects. With file-objects at first the subtype is determined and then generated. The logical file name is determined and the corresponding physical file is linked to the new object.

The following procedure is valid for all other types of objects (except for port- and generic-delcarations):

• The object`s subtype is defined.
• If the object`s declaration contains an explicit expression of initialisation the value of this expression is calculated. It is then the object`s initial value. If this is not the case the object is given an implicitly defined initial value.
• The object is generated.
• The initial value is assigned to the object.

During initialisation it is checked whether the subtype belongs to the object`s subtype.

With a array object which is signified by an object-declaration the first step is to transform the subtype until the object is a constant whose subtype is a type of an unconstrained array.

An error occurs if the name of one of the object`s subtypes is used before the corresponding declaration has been elaborated.

If a file elaborated which declaration contains no file open information, then first FILE_OPEN is called.

The subtype associated with the alias is determined and generated. After that an alternative name is generated.

The creation of an alias for an array object involves a check that the subtype associated with the alias includes a matching element for each element of the named object

A template is generated with which it is possible to define attributes for the individual elements.

The system generates a template for generating the component`s instants.

Here additional information is assigned to a previously declared program part.

Elaboration proceeds as follows:

• An entity`s specification is elaborated in order to be able to determine which individual elements are affected by the attribute specification.
• In order to determine the attribute`s value the expression is evaluated.
• A new attribute instance is generated and linked to every program element or point affected by it.
• Each new attribute instance is given the value of the expression.

The assignment described at 4. comprises a test to check whether the value belongs to the attribute`s subtype.

With a constrained array type`s attribute at first the subtype has to undergo an implicit type conversion similar to a statement of assignment. Such a conversion is not necessary for unconstrained array types.

Elaboration proceeds as follows:

• Component specification is elaborated to determine which instances are affected by the configuration.
• The binding indication is elaborated in order to identify the entity to which the component instances determined at 1. are linked.
• The binding information is associated with each component instance influenced to make sure that they can be used to generate further instances later on.

The procedure described here comprises a test to make sure that the entity declaration and the corresponding architecture implied by the binding indications exist within the specified library.

This includes the following steps:

• The guarded signal specification is elaborated in order to determine which signals are affected by the disconnection specification.
• The time-expression is evaluated in order to determine the disconnection-time for the drivers of the signals determined at 1.
• The disconnection-time is associated with every signal affected. It can be used to formulate disconnection-statements (in processes for guarded-signal seizures).