Section 14

Predefined language environment

This section describes the predefined attributes of VHDL and the packages that all VHDL implementations must provide.

14.1 Predefined Attributes

Predefined attributes denote values, functions, types, and ranges associated with various kinds of named entities. These attributes are described below. For each attribute, the following information is provided:

-- The kind of attribute: value, type, range, function, or signal.

-- The prefixes for which the attribute is defined.

-- A description of the parameter or argument, if one exists.

-- The result of evaluating the attribute, and the result type (if applicable).

-- Any further restrictions or comments that apply.

P:     process (S)
       begin 
          R <= transport S after T; 
       end process ;

instance_name ::=  package_based_path | full_instance_based_path

     package_based_path ::=
         leader library_logical_name leader package_simple_name  leader
             [ local_item_name ]

     full_instance_based_path ::=  leader full_path_to_instance [ local_item_name ]

     full_path_to_instance ::=  { full_path_instance_element leader }

     local_item_name ::=
         simple_name
         character_literal
         operator_symbol

     full_path_instance_element ::=
         [ component_instantiation_label @ ]
             entity_simple_name ( architecture_simple_name )
         | block_label
         | generate_label
         | process_label
         | loop_label
         | subprogram_simple_name

     generate_label ::=  generate_label [ ( literal ) ]

     process_label ::=  [ process_label ]

     leader ::=  :

Package-based paths identify items declared within packages. Full-instance-based paths identify items within an elaborated design hierarchy.

A library logical name denotes a library; see 11.2 . Since multiple logical names may denote the same library, the library logical name may not be unique.

There is one full path instance element for each component instantiation, block statement, generate statement, process statement, or subprogram body in the design hierarchy between the root design entity and the named entity denoted by the prefix.

In a full path instance element, the architecture simple name must denote an architecture associated with the entity interface designated by the entity simple name; furthermore, the component instantiation label (and the commercial at following it) are required unless the entity simple name and the architecture simple name together denote the root design entity.

The literal in a generate label is required if the label denotes a generate statement with a for generation scheme; the literal must denote one of the values of the generate parameter.

A process statement with no label is denoted by an empty process label.

All characters in basic identifiers appearing in the result are converted to their lowercase equivalents. Both a leading and trailing reverse solidus surround an extended identifier appearing in the result; any reverse solidus characters appearing as part of the identifier are represented with two consecutive reverse solidus characters.

E'PATH_NAME
	Kind:	Value.
	Prefix:	Any named entity other than the local ports and generics of a component declaration.
	Result Type:	Type String.
	Result:	A string describing the hierarchical path starting at the root of the design hierarchy and descending to the named entity, excluding the name of instantiated design entities. Specifically:
	The result string has the following syntax:
	path_name ::= package_based_path | instance_based_path instance_based_path ::= leader path_to_instance [ local_item_name ] path_to_instance ::= { path_instance_element leader } path_instance_element ::= component_instantiation_label | entity_simple_name | block_label | generate_label | process_label | subprogram_simple_name

Package-based paths identify items declared within packages. Full- instance - based paths identify items within an elaborated design hierarchy.

There is one path instance element for each component instantiation, block statement, generate statement, process statement, or subprogram body in the design hierarchy between the top design entity and the named entity denoted by the prefix.

Examples:

     library Lib:                             --  All design units are in this library:
     package P is                             --  P'PATH_NAME = ":lib:p:"
                                                   --P'INSTANCE_NAME = ":lib:p:"

         procedure Proc (F: inout INTEGER);   --  Proc'PATH_NAME = ":lib:p:proc"
                                                       --Proc'INSTANCE_NAME = ":lib:p:proc"

         constant C: INTEGER := 42;           --  C'PATH_NAME = ":lib:p:c"
     end package P;                           --  C'INSTANCE_NAME = ":lib:p:c"

     package body P is
         procedure Proc (F: inout INTEGER) is
             variable x: INTEGER;                      --  x'PATH_NAME = ":lib:p:proc:x"
         begin                                         --  x'INSTANCE_NAME = ":lib:p:proc:x"
             ·
             ·
             ·
         end;
     end;

     library Lib;
     use Lib.P.all;                                     --  Assume that E is in Lib and
     entity E is                                        --  E is the top-level design entity:
                                                        --  E'PATH_NAME = ":e:"
                                                        --  E'INSTANCE_NAME =  ":e(a):"
         generic (G: INTEGER);                          --  G'PATH_NAME = ":e:g"
                                                        --  G'INSTANCE_NAME =  ":e(a):g"
         port (P: in INTEGER);                          --  P'PATH_NAME = ":e:p"
     end entity E;                                      --  P'INSTANCE_NAME =  ":e(a):p"

     architecture A of E is
         signal S: BIT_VECTOR (1 to G);                  --  S'PATH_NAME = ":e:s"
                                                         --  S'INSTANCE_NAME =  ":e(a):s"
         procedure Proc1 (signal sp1: NATURAL; C: out INTEGER) is
                                                         --  Proc1'PATH_NAME =  ":e:proc1:"
                                                         --  Proc1'INSTANCE_NAME =:e(a):proc1:"
                                                         --  C'PATH_NAME =  ":e:proc1:c"
                                                         --  C'INSTANCE_NAME =  ":e(a):proc1:c"
         variable max: DELAY_LENGTH;                     --  max'PATH_NAME = ":e:proc1:max"
                                                         --  max'INSTANCE_NAME =
                                                         --  ":e(a):proc1:max"

         begin
             max := sp1 * ns;
             wait on sp1 for max;
             c := sp1;
         end procedure Proc1;

     begin
     p1: process
             variable T: INTEGER := 12;                  --  T'PATH_NAME =  ":e:p1:t"
         begin                                           --  T'INSTANCE_NAME =  ":e(a):p1:t"
             ·
             ·
             ·
         end process p1;

         process
             variable T: INTEGER := 12;                  --  T'PATH_NAME =  ":e::t"
         begin                                           --  T'INSTANCE_NAME =  ":e(a)::t"
             ·
             ·
             ·
         end process ;
     end architecture;

     entity Bottom is
         generic (GBottom : INTEGER);
         port     (PBottom : INTEGER);
     end entity Bottom;

     architecture BottomArch of Bottom is
         signal SBottom : INTEGER;
     begin
         ProcessBottom : process
             variable V : INTEGER;
         begin
             if GBottom = 4 then
                  assert V'Simple_Name = "v"
                      and V'Path_Name = ":top:b1:b2:g1(4):b3:l1:processbottom:v"
                      and V'Instance_Name =
":top(top):b1:b2:g1(4):b3:l1@bottom(bottomarch):processbottom:v";
                  assert GBottom'Simple_Name = "bottom"
                      and GBottom'Path_Name = ":top:b1:b2:g1(4):b3:l1:gbottom"
                      and GBottom'Instance_Name =
":top(top):b1:b2:g1(4):b3:l1@bottom(bottomarch):gbottom";
             elsif GBottom = -1 then
                  assert V'Simple_Name = "v"
                      and V'Path_Name = ":top:l2:processbottom:v"
                      and V'Instance_Name =
":top(top):l2@bottom(bottomarch):processbottom:v";
                  assert GBottom'Simple_Name = "gbottom"
                      and GBottom'Path_Name = "top:l2:gbottom"
                      and GBottom'Instance_Name =
                       ":top(top):l2@bottom(bottomarch):gbottom";
             end if;
         wait;
         end process ProcessBottom;
     end architecture BottomArch;

     entity Top is end Top;

     architecture Top of Top is
         component BComp is
             generic (GComp : INTEGER)
             port      (PComp : INTEGER);
         end component BComp;

         signal S : INTEGER;
     begin
         B1 : block
             signal S : INTEGER;

         begin
             B2 : block
                 signal S : INTEGER;
             begin
                 G1 : for I in 1 to 10 generate
                     B3 : block
                          signal S : INTEGER;
                          for L1 : BComp use entity Work.Bottom(BottomArch)
                               generic map    (GBottom => GComp)
                               port map       (PBottom => PComp);

                     begin
                          L1 : BComp generic map (I) port map (S);
                          P1 : process
                               variable V : INTEGER;
                          begin
                               if I = 7 then
                                     assert V'Simple_Name = "v"
                                         and V'Path_Name = ":top:b1:b2:g1(7):b3:p1:v"
                                         and V'Instance_Name = ":top(top):b1:b2:g1(7):b3:p1:v";
                                     assert P1'Simple_Name = "p1"
                                         and P1'Path_Name = ":top:b1:b2:g1(7):b3:p1:"
                                         and P1'Instance_Name = ":top(top):b1:b2:g1(7):b3:p1:";
                                     assert S'Simple_Name = "s"
                                         and S'Path_Name = ":top:b1:b2:g1(7):b3:s"
                                         and S'Instance_Name = ":top(top):b1:b2:g1(7):b3:s";
                                     assert B1.S'Simple_Name = "s"
                                         and B1.S'Path_Name = ":top:b1:s"
                                         and B1.S'Instance_Name = ":top(top):b1:s";
                               end if;
                               wait;
                          end process P1;
                     end block B3;
                 end generate;
             end block B2;
         end block B1;
         L2 : BComp generic map (-1) port map (S);
     end architecture Top;

     configuration TopConf of Top is
         for Top
             for L2 : BComp use
                 entity Work.Bottom(BottomArch)
                     generic map   (GBottom => GComp)
                     port map      (PBottom => PComp);
             end for;
         end for;
     end configuration TopConf;

NOTES

1--The relationship between the values of the LEFT, RIGHT, LOW, and HIGH attributes is expressed in the following table:

					Ascending range		Descending range
	T'LEFT		=		T'LOW		T'HIGH
	T'RIGHT		=		T'HIGH		T'LOW

2--Since the attributes S'EVENT, S'ACTIVE, S'LAST_EVENT, S'LAST_ACTIVE, and S'LAST_VALUE are functions, not signals, they cannot cause the execution of a process, even though the value returned by such a function may change dynamically. It is thus recommended that the equivalent signal-valued attributes S'STABLE and S'QUIET, or expressions involving those attributes, be used in concurrent contexts such as guard expressions or concurrent signal assignments. Similarly, function STANDARD.NOW should not be used in concurrent contexts.

3--S'DELAYED(0 ns) is not equal to S during any simulation cycle where S'EVENT is true.

4--S'STABLE(0 ns) = (S'DELAYED(0 ns) = S), and S'STABLE(0 ns) is FALSE only during a simulation cycle in which S has had a transaction.

5--For a given simulation cycle, S'QUIET(0 ns) is TRUE if and only if S is quiet for that simulation cycle.

6--If S'STABLE(T) is FALSE, then, by definition, for some t where 0 ns <= t<= T, S'DELAYED(t) /= S.

7--If T_s is the smallest value such that S'STABLE (T_s) is FALSE, then for all t where 0 ns <= t < Ts, S'DELAYED(t) = S.

8--S'EVENT should not be used within a postponed process (or a concurrent statement that has an equivalent postponed process) to determine if the prefix signal S caused the process to resume. However, S'LAST_EVENT = 0 ns can be used for this purpose.

9--The values of E'PATH_NAME and E'INSTANCE_NAME are not unique. Specifically, named entities in two different, unlabelled processes may have the same path names or instance names. Overloaded subprograms, and named entities within them, may also have the same path names or instance names.

10--If the prefix to the attributes 'SIMPLE_NAME, 'PATH_NAME, or 'INSTANCE_NAME denotes an alias, the result is respectively the simple name, path name or instance name of the alias. See 6.6 .

11--For all values V of any scalar type T except a real type, the following relation holds:

     V = T'Value(T'Image(V))

14.2 Package STANDARD

Package STANDARD predefines a number of types, subtypes, and functions. An implicit context clause naming this package is assumed to exist at the beginning of each design unit. Package STANDARD may not be modified by the user.

The operators that are predefined for the types declared for package STANDARD are given in comments since they are implicitly declared. Italics are used for pseudo-names of anonymous types (such as universal_integer), formal parameters, and undefined information (such as implementation_defined).

     package STANDARD is

        --  Predefined enumeration types:

        type BOOLEAN is (FALSE, TRUE);

        --  The predefined operators for this type are as follows:

        --  function "and"     (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "or"      (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "nand"    (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "nor"     (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "xor"     (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "xnor"    (anonymous, anonymous: BOOLEAN)return BOOLEAN;

        --  function "not"     (anonymous: BOOLEAN) return BOOLEAN;

        --  function "="       (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "/="      (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "<"       (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function "<="      (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function ">"       (anonymous, anonymous: BOOLEAN)return BOOLEAN;
        --  function ">="      (anonymous, anonymous: BOOLEAN)return BOOLEAN;


       type BIT is ('0', '1');

        --  The predefined operators for this type are as follows:

        --  function "and"     (anonymous, anonymous: BIT) return BIT;
        --  function "or"      (anonymous, anonymous: BIT) return BIT;
        --  function "nand"    (anonymous, anonymous: BIT) return BIT;
        --  function "nor"     (anonymous, anonymous: BIT) return BIT;
        --  function "xor"     (anonymous, anonymous: BIT) return BIT;
        --  function "xnor"    (anonymous, anonymous: BIT) return BIT;

        --  function "not"     (anonymous: BIT) return BIT;

        --  function "="       (anonymous, anonymous: BIT) return BOOLEAN;
        --  function "/="      (anonymous, anonymous: BIT) return BOOLEAN;
        --  function "<"       (anonymous, anonymous: BIT) return BOOLEAN;
        --  function "<="      (anonymous, anonymous: BIT) return BOOLEAN;
        --  function ">"       (anonymous, anonymous: BIT) return BOOLEAN;
        --  function ">="      (anonymous, anonymous: BIT) return BOOLEAN;

        type CHARACTER is(

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: CHARACTER) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: CHARACTER) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: CHARACTER) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: CHARACTER) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: CHARACTER) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: CHARACTER) return BOOLEAN;

        type SEVERITY_LEVEL is (NOTE, WARNING, ERROR, FAILURE);

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: SEVERITY_LEVEL)return BOOLEAN;
        --  function "/="     (anonymous, anonymous: SEVERITY_LEVEL)return BOOLEAN;
        --  function "<"      (anonymous, anonymous: SEVERITY_LEVEL) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: SEVERITY_LEVEL) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: SEVERITY_LEVEL) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: SEVERITY_LEVEL) return BOOLEAN;

        --  type universal_integer  is range implementation_defined;

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: universal_integer) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: universal_integer) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: universal_integer) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: universal_integer) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: universal_integer) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: universal_integer) return BOOLEAN;
        --  function "+"      (anonymous: universal_integer) return universal_integer;
        --  function "-"      (anonymous: universal_integer) return universal_integer;
        --  function "abs"    (anonymous: universal_integer) return universal_integer;
        --  function "+"      (anonymous,  universal_integer)
        --                                   return universal_integer;
        --  function "-"      (anonymous,  universal_integer)
        --                                   return universal_integer;
        --  function "abs"      (anonymous,  universal_integer)
        --                                   return universal_integer;
        --  function "+"      (anonymous, anonymous: universal_integer)
        --                                   return universal_integer;
        --  function "-"      (anonymous, anonymous: universal_integer)
        --                                   return universal_integer;
        --  function "*"      (anonymous, anonymous: universal_integer)
        --                                   return universal_integer;

        --  function "/"      (anonymous,anonymous:  universal_integer)
        --                                   return universal_integer;
        --  function "mod"    (anonymous, anonymous: universal_integer)
        --                                   return universal_integer;
        --  function "rem"    (anonymous, anonymous: universal_integer)
        --                                   return universal_integer;

        --  type universal_real  is range implementation_defined;

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous:universal_real) return BOOLEAN;
        --  function "/="     (anonymous, anonymous:universal_real) return BOOLEAN;
        --  function "<"      (anonymous, anonymous:universal_real) return BOOLEAN;
        --  function "<="     (anonymous, anonymous:universal_real) return BOOLEAN;
        --  function ">"      (anonymous, anonymous:universal_real) return BOOLEAN;
        --  function ">="     (anonymous, anonymous:universal_real) return BOOLEAN;

        --  function "+"      (anonymous: universal_real) return universal_real;
        --  function "-"      (anonymous: universal_real) return universal_real;
        --  function "abs"    (anonymous: universal_real) return universal_real;

        --  function "+"      (anonymous, anonymous:universal_real) return universal_real;
        --  function "-"      (anonymous, anonymous:universal_real) return universal_real;
        --  function "*"      (anonymous, anonymous:universal_real) return universal_real;
        --  function "/"      (anonymous, anonymous:universal_real) return universal_real;

        --  function "*"      (anonymous: universal_real;anonymous: universal_integer)
        --                                   return universal_real;
        --  function "*"      (anonymous: universal_integer;anonymous: universal_real)
        --                                   return universal_real;
        --  function "/"      (anonymous: universal_real;anonymous: universal_integer)
        --                                   return universal_real;


        --  Predefined numeric types:

        type INTEGER is range implementation_defined;

        --  The predefined operators for this type are as follows:

        --  function "**"     (anonymous: universal_integer; anonymous: INTEGER)
        --                                   return universal_integer;
        --  function "**"     (anonymous: universal_real; anonymous: INTEGER)
        --                                   return universal_real;

        --  function "="      (anonymous, anonymous: INTEGER) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: INTEGER) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: INTEGER) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: INTEGER) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: INTEGER) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: INTEGER) return BOOLEAN;

        --  function "+"      (anonymous: INTEGER) return INTEGER;
        --  function "-"      (anonymous: INTEGER) return INTEGER;
        --  function "abs"    (anonymous: INTEGER) return INTEGER;

        --  function "+"      (anonymous, anonymous: INTEGER) return INTEGER;
        --  function "-"      (anonymous, anonymous: INTEGER) return INTEGER;
        --  function "*"      (anonymous, anonymous: INTEGER) return INTEGER;
        --  function "/"      (anonymous, anonymous: INTEGER) return INTEGER;
        --  function "mod"    (anonymous, anonymous: INTEGER) return INTEGER;
        --  function "rem"    (anonymous, anonymous: INTEGER) return INTEGER;

        --  function "**"     (anonymous: INTEGER; anonymous: INTEGER)
        --                                   return INTEGER;

        type REAL is range implementation_defined;

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: REAL) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: REAL) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: REAL) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: REAL) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: REAL) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: REAL) return BOOLEAN;

        --  function "+"      (anonymous: REAL) return REAL;
        --  function "-       (anonymous: REAL) return REAL;
        --  function "abs"    (anonymous: REAL) return REAL;

        --  function "+"      (anonymous, anonymous: REAL) return REAL;
        --  function "-"      (anonymous, anonymous: REAL) return REAL;
        --  function "*"      (anonymous, anonymous: REAL) return REAL;
        --  function "/"      (anonymous, anonymous: REAL) return REAL;

        --  function "**"     (anonymous: REAL; anonymous: INTEGER) return REAL;


        --  Predefined type TIME:

        type TIME is range implementation_defined
            units

              fs;                       --  femtosecond
              ps     =   1000 fs;       --  picosecond
              ns     =   1000 ps;       --  nanosecond
              us     =   1000 ns;       --  microsecond
              ms     =   1000 us;       --  millisecond
              sec    =   1000 ms;       --  second
              min    =   60 sec;        --  minute
              hr     =   60 min;        --  hour
            end units;

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: TIME) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: TIME) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: TIME) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: TIME) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: TIME) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: TIME) return BOOLEAN;

        --  function "+"      (anonymous: TIME) return TIME;
        --  function "-"      (anonymous: TIME) return TIME;
        --  function "abs"    (anonymous: TIME) return TIME;

        --  function "+"      (anonymous, anonymous: TIME) return TIME;
        --  function "-"      (anonymous, anonymous: TIME) return TIME;

        --  function "*"      (anonymous: TIME;     anonymous: INTEGER)    return TIME;
        --  function "*"      (anonymous: TIME;     anonymous: REAL)       return TIME;
        --  function "*"      (anonymous: INTEGER;  anonymous: TIME)       return TIME;
        --  function "*"      (anonymous: REAL;     anonymous: TIME)       return TIME;
        --  function "/"      (anonymous: TIME;     anonymous: INTEGER)    return TIME;
        --  function "/"      (anonymous: TIME;     anonymous: REAL) return TIME;

        --  function "/"      (anonymous, anonymous: TIME) return universal_integer;


        subtype DELAY_LENGTH is TIME range 0 fs to TIME'HIGH;


        --  A function that returns the current simulation time, Tc (see    12.6.4   ):

        impure function NOW return DELAY_LENGTH;

        --  Predefined numeric subtypes:

        subtype NATURAL is INTEGER range 0 to INTEGER'HIGH;

        subtype POSITIVE is INTEGER range 1 to INTEGER'HIGH;


        --  Predefined array types:

        type STRING is array (POSITIVE range <>)of CHARACTER;

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: STRING) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: STRING) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: STRING) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: STRING) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: STRING) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: STRING) return BOOLEAN;

        --  function "&"      (anonymous: STRING;          anonymous: STRING)
        --                                              return STRING;
        --  function "&"      (anonymous: STRING;          anonymous: CHARACTER)
        --                                              return STRING;
        --  function "&"      (anonymous: CHARACTER;      anonymous: STRING)
        --                                              return STRING;
        --  function "&"      (anonymous: CHARACTER;      anonymous: CHARACTER)
        --                                              return STRING;

        type BIT_VECTOR is array (NATURAL range <>)of BIT;

        --  The predefined operators for this type are as follows:

        --  function "and"    (anonymous, anonymous: BIT_VECTOR) return BIT_VECTOR;
        --  function "or"     (anonymous, anonymous: BIT_VECTOR) return BIT_VECTOR;
        --  function "nand"   (anonymous, anonymous: BIT_VECTOR) return BIT_VECTOR;
        --  function "nor"    (anonymous, anonymous: BIT_VECTOR) return BIT_VECTOR;
        --  function "xor"    (anonymous, anonymous: BIT_VECTOR) return BIT_VECTOR;
        --  function "xnor"   (anonymous, anonymous: BIT_VECTOR) return BIT_VECTOR;

        --  function "not"    (anonymous: BIT_VECTOR) return BIT_VECTOR;

        --  function "sll"    (anonymous: BIT_VECTOR; anonymous:INTEGER)
        --                    return BIT_VECTOR;
        --  function "srl"    (anonymous: BIT_VECTOR; anonymous:INTEGER)
        --                    return BIT_VECTOR;
        --  function "sla"    (anonymous: BIT_VECTOR; anonymous:INTEGER)
        --                    return BIT_VECTOR;
        --  function "sra"    (anonymous: BIT_VECTOR; anonymous:INTEGER)
        --                    return BIT_VECTOR;
        --  function "rol"    (anonymous: BIT_VECTOR; anonymous:INTEGER)
        --                    return BIT_VECTOR;
        --  function "ror"    (anonymous: BIT_VECTOR; anonymous:INTEGER)
        --                    return BIT_VECTOR;

        --  function "="      (anonymous, anonymous: BIT_VECTOR) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: BIT_VECTOR) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: BIT_VECTOR) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: BIT_VECTOR) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: BIT_VECTOR) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: BIT_VECTOR) return BOOLEAN;

        --  function "&"      (anonymous: BIT_VECTOR;     anonymous: BIT_VECTOR)
        --                                              return BIT_VECTOR;
        --  function "&"      (anonymous: BIT_VECTOR;     anonymous: BIT)
        --                                              return BIT_VECTOR;
        --  function "&"      (anonymous: BIT;            anonymous: BIT_VECTOR)
        --                                              return BIT_VECTOR;
        --  function "&"      (anonymous: BIT;            anonymous: BIT)
        --                                              return BIT_VECTOR;


        --  The predefined types for opening files:

        type FILE_OPEN_KIND is (
           READ_MODE,                 --  Resulting access mode is read-only.
           WRITE_MODE,                --  Resulting access mode is write-only.
           APPEND_MODE);              --  Resulting access mode is write-only; information 
                                      --  is appended to the end of the existing file.

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: FILE_OPEN_KIND) return BOOLEAN;
        --  function "/="     (anonymous, anonymous: FILE_OPEN_KIND) return BOOLEAN;
        --  function "<"      (anonymous, anonymous: FILE_OPEN_KIND) return BOOLEAN;
        --  function "<="     (anonymous, anonymous: FILE_OPEN_KIND) return BOOLEAN;
        --  function ">"      (anonymous, anonymous: FILE_OPEN_KIND) return BOOLEAN;
        --  function ">="     (anonymous, anonymous: FILE_OPEN_KIND) return BOOLEAN;

        type FILE_OPEN_STATUS is (
           OPEN_OK,                   --  File open was successful.
           STATUS_ERROR,              --  File object was already open.
           NAME_ERROR,                --  External file not found or inaccessible.
           MODE_ERROR);               --  Could not open file with requested access mode.

        --  The predefined operators for this type are as follows:

        --  function "="      (anonymous, anonymous: FILE_OPEN_STATUS)
                             return BOOLEAN;
        --  function "/="     (anonymous, anonymous: FILE_OPEN_STATUS)
                             return BOOLEAN;
        --  function "<"      (anonymous, anonymous: FILE_OPEN_STATUS)
                             return BOOLEAN;-
        --  function "<="     (anonymous, anonymous: FILE_OPEN_STATUS)
                             return BOOLEAN;
        --  function ">"      (anonymous, anonymous: FILE_OPEN_STATUS)
                             return BOOLEAN;
        --  function ">="     (anonymous, anonymous: FILE_OPEN_STATUS)
                             return BOOLEAN;

        --  The 'FOREIGN attribute:

                  attribute FOREIGN: STRING;
     end STANDARD;

The 'FOREIGN attribute may be associated only with architectures (see 1.2 ) or with subprograms. In the latter case, the attribute specification must appear in the declarative part in which the subprogram is declared (see 2.1 ).

NOTES

1--The ASCII mnemonics for file separator (FS), group separator (GS), record separator (RS), and unit separator (US) are represented by FSP, GSP, RSP, and USP, respectively, in type CHARACTER in order to avoid conflict with the units of type TIME.

2--The declarative parts and statement parts of design entities whose corresponding architectures are decorated with the 'FOREIGN attribute and subprograms that are likewise decorated are subject to special elaboration rules. See 12.3 and 12.4 .

14.3 Package TEXTIO

Package TEXTIO contains declarations of types and subprograms that support formatted I/O operations on text files.

     package TEXTIO is

        --  Type definitions for text I/O:

          type LINE is access STRING;        --  A LINE is a pointer to a STRING value.

          type TEXT is file of STRING;       --  A file of variable-length ASCII records.

          type SIDE is (RIGHT, LEFT);        --  For justifying output data within fields.

          subtype WIDTH is NATURAL;          --  For specifying widths of output fields.

        --  Standard text files:

          file INPUT:     TEXT open READ_MODE     is "STD_INPUT";

          file OUTPUT:    TEXT open WRITE_MODE    is "STD_OUTPUT";

        --  Input routines for standard types:

          procedure READLINE (file F: TEXT; L: out LINE);

          procedure READ (L: inout LINE;     VALUE: out BIT;              GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out BIT);

          procedure READ (L: inout LINE;     VALUE: out BIT_VECTOR;       GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out BIT_VECTOR);

          procedure READ (L: inout LINE;     VALUE: out BOOLEAN;          GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out BOOLEAN);

          procedure READ (L: inout LINE;     VALUE: out CHARACTER;        GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out CHARACTER);

          procedure READ (L: inout LINE;     VALUE: out INTEGER;          GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out INTEGER);

          procedure READ (L: inout LINE;     VALUE: out REAL;             GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out REAL);

          procedure READ (L: inout LINE;     VALUE: out STRING;           GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out STRING);

          procedure READ (L: inout LINE;     VALUE: out TIME;             GOOD: out BOOLEAN);
          procedure READ (L: inout LINE;     VALUE: out TIME);


          --  Output routines for standard types:

          procedure WRITELINE (file F: TEXT; L: inout LINE);

          procedure WRITE (L: inout LINE;     VALUE: in BIT;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0);
          procedure WRITE (L: inout LINE;     VALUE: in BIT_VECTOR;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0);

          procedure WRITE (L: inout LINE;     VALUE: in BOOLEAN;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0);

          procedure WRITE (L: inout LINE;     VALUE: in CHARACTER;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0);

          procedure WRITE (L: inout LINE;     VALUE: in INTEGER;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0);

          procedure WRITE (L: inout LINE;     VALUE: in REAL;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0;
                               DIGITS: in NATURAL:= 0);

          procedure WRITE (L: inout LINE;     VALUE: in STRING;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0);

          procedure WRITE (L: inout LINE;     VALUE: in TIME;
                               JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0;
                               UNIT: in TIME:= ns);


          --  File position predicate: 

     --function ENDFILE (file F: TEXT) return BOOLEAN;

     end TEXTIO;

Procedures READLINE and WRITELINE declared in package TEXTIO read and write entire lines of a file of type TEXT. Procedure READLINE causes the next line to be read from the file and returns as the value of parameter L an access value that designates an object representing that line. If parameter L contains a nonnull access value at the start of the call, the object designated by that value is deallocated before the new object is created. The representation of the line does not contain the representation of the end of the line. It is an error if the file specified in a call to READLINE is not open or, if open, the file has an access mode other than read-only (see 3.4.1 ). Procedure WRITELINE causes the current line designated by parameter L to be written to the file and returns with the value of parameter L designating a null string. If parameter L contains a null access value at the start of the call, then a null string is written to the file. It is an error if the file specified in a call to WRITELINE is not open or, if open, the file has an access mode other than write-only.

The language does not define the representation of the end of a line. An implementation must allow all possible values of types CHARACTER and STRING to be written to a file. However, as an implementation is permitted to use certain values of types CHARACTER and STRING as line delimiters, it may not be possible to read these values from a TEXT file.

Each READ procedure declared in package TEXTIO extracts data from the beginning of the string value designated by parameter L and modifies the value so that it designates the remaining portion of the line on exit.

The READ procedures defined for a given type other than CHARACTER and STRING begin by skipping leading whitespace characters. A whitespace character is defined as a space, a nonbreaking space, or a horizontal tabulation character (SP, NBSP, or HT). For all READ procedures, characters are then removed from L and composed into a string representation of the value of the specified type. Character removal and string composition stops when a character is encountered that cannot be part of the value according to the lexical rules of 13.2 ; this character is not removed from L and is not added to the string representation of the value. The READ procedures for types INTEGER and REAL also accept a leading sign; additionally, there can be no space between the sign and the remainder of the literal. The READ procedures for types STRING and BIT_VECTOR also terminate acceptance when VALUE'LENGTH characters have been accepted. Again using the rules of 13.2 , the accepted characters are then interpreted as a string representation of the specified type. The READ does not succeed if the sequence of characters removed from L is not a valid string representation of a value of the specified type or, in the case of types STRING and BIT_VECTOR, if the sequence does not contain VALUE'LENGTH characters.

The definitions of the string representation of the value for each data type are as follows:

-- The representation of a BIT value is formed by a single character, either1 or 0. No leading or trailing quotation characters are present.

-- The representation of a BIT_VECTOR value is formed by a sequence of characters, either 1 or 0. No leading or trailing quotation characters are present.

-- The representation of a BOOLEAN value is formed by an identifier, either FALSE or TRUE.

-- The representation of a CHARACTER value is formed by a single character.

-- The representation of both INTEGER and REAL values is that of a decimal literal (see 13.4.1 ), with the addition of an optional leading sign. The sign is never written if the value is nonnegative, but it is accepted during a read even if the value is nonnegative. No spaces can occur between the sign and the remainder of the value. The decimal point is absent in the case of an INTEGER literal and present in the case of a REAL literal. An exponent may optionally be present; moreover, the language does not define under what conditions it is or is not present. However, if the exponent is present, the "e" is written as a lowercase character. Leading and trailing zeroes are written as necessary to meet the requirements of the FIELD and DIGITS parameters, and they are accepted during a read.

-- The representation of a STRING value is formed by a sequence of characters, one for each element of the string. No leading or trailing quotation characters are present.

-- The representation of a TIME value is formed by an optional decimal literal composed following the rules for INTEGER and REAL literals described above, one or more blanks, and an identifier that is a unit of type TIME, as defined in package STANDARD (see 14.2 ). When read, the identifier can be expressed with characters of either case; when written, the identifier is expressed in lowercase characters.

Each WRITE procedure similarly appends data to the end of the string value designated by parameter L; in this case, however, L continues to designate the entire line after the value is appended. The format of the appended data is defined by the string representations defined above for the READ procedures.

The READ and WRITE procedures for the types BIT_VECTOR and STRING respectively read and write the element values in left-to-right order.

For each predefined data type there are two READ procedures declared in package TEXTIO. The first has three parameters: L, the line to read from; VALUE, the value read from the line; and GOOD, a Boolean flag that indicates whether the read operation succeeded or not. For example, the operation READ (L, IntVal,OK) would return with OK set to FALSE, L unchanged, and IntVal undefined if IntVal is a variable of type INTEGER and L designates the line "ABC". The success indication returned via parameter GOOD allows a process to recover gracefully from unexpected discrepancies in input format. The second form of read operation has only the parameters L and VALUE. If the requested type cannot be read into VALUE from line L, then an error occurs. Thus, the operation READ (L, IntVal) would cause an error to occur if IntVal is of type INTEGER and L designates the line "ABC".

For each predefined data type there is one WRITE procedure declared in package TEXTIO. Each of these has at least two parameters: L, the line to which to write; and VALUE, the value to be written. The additional parameters JUSTIFIED, FIELD, DIGITS, and UNIT control the formatting of output data. Each write operation appends data to a line formatted within a field that is at least as long as required to represent the data value. Parameter FIELD specifies the desired field width. Since the actual field width will always beat least large enough to hold the string representation of the data value, the default value 0 for the FIELD parameter has the effect of causing the data value to be written out in a field of exactly the right width (i.e., no leading or trailing spaces). Parameter JUSTIFIED specifies whether values are to be right- or left-justified within the field; the default is right-justified. If the FIELD parameter describes a field width larger than the number of characters necessary for a given value, blanks are used to fill the remaining characters in the field.

Parameter DIGITS specifies how many digits to the right of the decimal point are to be output when writing a real number; the default value 0 indicates that the number should be output in standard form, consisting of a normalized mantissa plus exponent (e.g. 1.079236E-23). If DIGITS is nonzero, then the real number is output as an integer part followed by '.' followed by the fractional part, using the specified number of digits (e.g., 3.14159 ).

Parameter UNIT specifies how values of type TIME are to be formatted. The value of this parameter must be equal to one of the units declared as part of the declaration of type TIME; the result is that the TIME value is formatted as an integer or real literal representing the number of multiples of this unit,followed by the name of the unit itself. The name of the unit is formatted using only lowercase characters. Thus the procedure call WRITE(Line, 5 ns,UNIT=>us) would result in the string value " 0.005 us" being appended to the string value designated by Line, whereas WRITE(Line, 5 ns) would result in the string value "5 ns" being appended (since the default UNIT value is ns).

Function ENDFILE is defined for files of type TEXT by the implicit declaration of that function as part of the declaration of the file type.

NOTES

1--For a variable L of type Line, attribute L'Length gives the current length of the line, whether that line is being read or written. For a line L that is being written, the value of L'Length gives the number of characters that have already been written to the line; this is equivalent to the column number of the last character of the line. For a line L that is being read, the value of L'Length gives the number of characters on that line remaining to be read. In particular, the expression L'Length = 0 is true precisely when the end of the current line has been reached.

2--The execution of a read or write operation may modify or even deallocate the string object designated by input parameter L of type Line for that operation; thus, a dangling reference may result if the value of a variable L of type Line is assigned to another access variable and then a read or write operation is performed on L.