.. # This page is generated by doc/ASTReference.py when Sphinx starts. Do not edit it. Type And Subtype Definition ########################### The diagrams below draw one box per node kind, with one port per field. The edge colours say how a link is held; they are listed in full on the :ref:`INT:AST:Fields` page. .. graphviz:: digraph { rankdir="LR" nodesep=0.1 node [shape=point width=0.06 color="#888a85"] edge [fontname="monospace" fontsize=10 minlen=3] l0a -> l0b [label="owned" color="#000000"] l1a -> l1b [label="ref" color="#3465a4" style=dashed] l2a -> l2b [label="maybe ref" color="#3465a4" style=dotted] l3a -> l3b [label="of ref" color="#3465a4" style=dashed] l4a -> l4b [label="of maybe ref" color="#3465a4" style=dotted] l5a -> l5b [label="forward ref" color="#f57900" style=dashed] l6a -> l6b [label="maybe forward ref" color="#f57900" style=dotted] l7a -> l7b [label="chain" color="#4e9a06"] l8a -> l8b [label="chain next" color="#4e9a06" style=bold] } .. _INT:AST:Access_Type_Definition: Iir_Kind_Access_Type_Definition =============================== LRM08 5.4 Access types :: access_type_definition ::= ACCESS subtype_indication Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Designated_Subtype_Indication ` - ``Field5`` - ``Iir`` - owned - The subtype_indication as it appears. Can designate an incomplete_type_definition. * - :ref:`Designated_Type ` - ``Field1`` - ``Iir`` - forward ref - The resolved designated type. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Incomplete_Type_Ref_Chain ` - ``Field0`` - ``Iir`` - forward ref - Next access type that also referenced the same incomplete type when defined. * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Access_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Access_Type_Definition|{ Designated_Subtype_Indication| Designated_Type| Type_Declarator| Incomplete_Type_Ref_Chain| Resolved_Flag| Signal_Type_Flag| Type_Staticness}}"] "Access_Type_Definition__Designated_Subtype_Indication" [shape=box label="Iir"] "Access_Type_Definition":Designated_Subtype_Indication -> "Access_Type_Definition__Designated_Subtype_Indication" [color="#000000"] "Access_Type_Definition__Designated_Type" [shape=box label="Iir"] "Access_Type_Definition":Designated_Type -> "Access_Type_Definition__Designated_Type" [color="#f57900" style=dashed] "Access_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Access_Type_Definition":Type_Declarator -> "Access_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Access_Type_Definition__Incomplete_Type_Ref_Chain" [shape=box label="Iir"] "Access_Type_Definition":Incomplete_Type_Ref_Chain -> "Access_Type_Definition__Incomplete_Type_Ref_Chain" [color="#f57900" style=dashed] } .. _INT:AST:Incomplete_Type_Definition: Iir_Kind_Incomplete_Type_Definition =================================== Type definition for an incomplete type. This is created during the analysis of the incomplete type declaration. Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Incomplete_Type_Ref_Chain ` - ``Field0`` - ``Iir`` - forward ref - Chain of access_type_definition that designated this type. This is simply a forward_ref as the access type is declared after the incomplete type. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - Set to the incomplete type declaration. * - :ref:`Complete_Type_Definition ` - ``Field5`` - ``Iir`` - forward ref - Set to the complete type definition when completed. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Incomplete_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Incomplete_Type_Definition|{ Incomplete_Type_Ref_Chain| Type_Declarator| Complete_Type_Definition| Type_Staticness| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag}}"] "Incomplete_Type_Definition__Incomplete_Type_Ref_Chain" [shape=box label="Iir"] "Incomplete_Type_Definition":Incomplete_Type_Ref_Chain -> "Incomplete_Type_Definition__Incomplete_Type_Ref_Chain" [color="#f57900" style=dashed] "Incomplete_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Incomplete_Type_Definition":Type_Declarator -> "Incomplete_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Incomplete_Type_Definition__Complete_Type_Definition" [shape=box label="Iir"] "Incomplete_Type_Definition":Complete_Type_Definition -> "Incomplete_Type_Definition__Complete_Type_Definition" [color="#f57900" style=dashed] } .. _INT:AST:Interface_Type_Definition: Iir_Kind_Interface_Type_Definition ================================== Type definition for an interface type. Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - Set to interface type declaration. * - :ref:`Associated_Type ` - ``Field5`` - ``Iir`` - forward ref - Set only during analysis of association: type associated with this interface, so that references to this interface can use the actual type. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Constraint_State ` - ``State2`` - ``Iir_Constraint`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Interface_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Interface_Type_Definition|{ Type_Declarator| Associated_Type| Type_Staticness| Constraint_State| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag}}"] "Interface_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Interface_Type_Definition":Type_Declarator -> "Interface_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Interface_Type_Definition__Associated_Type" [shape=box label="Iir"] "Interface_Type_Definition":Associated_Type -> "Interface_Type_Definition__Associated_Type" [color="#f57900" style=dashed] } .. _INT:AST:File_Type_Definition: Iir_Kind_File_Type_Definition ============================= Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`File_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type of values for a type file. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Text_File_Flag ` - ``Flag4`` - ``Boolean`` - owned - True if this is the std.textio.text file type, which may require special handling. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "File_Type_Definition" [style=filled fillcolor="#eeeeec" label="{File_Type_Definition|{ File_Type_Mark| Type_Declarator| Resolved_Flag| Signal_Type_Flag| Text_File_Flag| Type_Staticness}}"] "File_Type_Definition__File_Type_Mark" [shape=box label="Iir"] "File_Type_Definition":File_Type_Mark -> "File_Type_Definition__File_Type_Mark" [color="#000000"] "File_Type_Definition__Type_Declarator" [shape=box label="Iir"] "File_Type_Definition":Type_Declarator -> "File_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] } .. _INT:AST:Protected_Type_Declaration: Iir_Kind_Protected_Type_Declaration =================================== Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Parent ` - ``Field0`` - ``Iir`` - ref - The parent of a protected type declaration is the same parent as the type declaration. * - :ref:`Declaration_Chain ` - ``Field1`` - ``Iir`` - chain - — * - :ref:`Protected_Type_Body ` - ``Field2`` - ``Iir`` - forward ref - Body of a protected type declaration. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Attribute_Value_Chain ` - ``Field5`` - ``Iir`` - ref - Chain of attribute values for declared items. To be used with Get/Set_Value_Chain. There is no order, therefore, a new attribute value may be always prepended. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Elaborated_Flag ` - ``Flag7`` - ``Boolean`` - owned - Set at end of the package or when the body is analyzed. * - :ref:`End_Has_Reserved_Id ` - ``Flag8`` - ``Boolean`` - owned - Layout flag: true if 'end' is followed by the reserved identifier. * - :ref:`End_Has_Identifier ` - ``Flag9`` - ``Boolean`` - owned - Layout flag: true if 'end' is followed by the identifier. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Protected_Type_Declaration" [style=filled fillcolor="#eeeeec" label="{Protected_Type_Declaration|{ Parent| Declaration_Chain| Protected_Type_Body| Type_Declarator| Attribute_Value_Chain| Type_Staticness| Resolved_Flag| Signal_Type_Flag| Elaborated_Flag| End_Has_Reserved_Id| End_Has_Identifier}}"] "Protected_Type_Declaration__Parent" [shape=box label="Iir"] "Protected_Type_Declaration":Parent -> "Protected_Type_Declaration__Parent" [color="#3465a4" style=dashed] "Protected_Type_Declaration__Declaration_Chain" [shape=box label="Iir"] "Protected_Type_Declaration":Declaration_Chain -> "Protected_Type_Declaration__Declaration_Chain" [color="#4e9a06"] "Protected_Type_Declaration__Protected_Type_Body" [shape=box label="Iir"] "Protected_Type_Declaration":Protected_Type_Body -> "Protected_Type_Declaration__Protected_Type_Body" [color="#f57900" style=dashed] "Protected_Type_Declaration__Type_Declarator" [shape=box label="Iir"] "Protected_Type_Declaration":Type_Declarator -> "Protected_Type_Declaration__Type_Declarator" [color="#3465a4" style=dashed] "Protected_Type_Declaration__Attribute_Value_Chain" [shape=box label="Iir"] "Protected_Type_Declaration":Attribute_Value_Chain -> "Protected_Type_Declaration__Attribute_Value_Chain" [color="#3465a4" style=dashed] } .. _INT:AST:Record_Type_Definition: Iir_Kind_Record_Type_Definition =============================== LRM08 5.3.3 Record types / LRM93 3.2.2 Record types :: record_type_definition ::= RECORD element_declaration { element_declaration } END RECORD [ /record_type/_simple_name ] Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Elements_Declaration_List ` - ``Field1`` - ``Iir_Flist`` - of maybe ref - List of elements of a record. For a record_type_definition: Is_Ref is false, as the elements declaration are owned by the type definition. For a record_subtype_definition: Is_Ref is false, as new constrained elements are owned through the Owned_Elements_Chain list. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Constraint_State ` - ``State2`` - ``Iir_Constraint`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`End_Has_Reserved_Id ` - ``Flag8`` - ``Boolean`` - owned - Layout flag: true if 'end' is followed by the reserved identifier. * - :ref:`End_Has_Identifier ` - ``Flag9`` - ``Boolean`` - owned - Layout flag: true if 'end' is followed by the identifier. * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Always false for record type: elements are owned by this node. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Record_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Record_Type_Definition|{ Elements_Declaration_List| Type_Declarator| Type_Staticness| Constraint_State| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| End_Has_Reserved_Id| End_Has_Identifier| Is_Ref}}"] "Record_Type_Definition__Elements_Declaration_List" [shape=box3d label="Iir_Flist"] "Record_Type_Definition":Elements_Declaration_List -> "Record_Type_Definition__Elements_Declaration_List" [color="#3465a4" style=dotted] "Record_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Record_Type_Definition":Type_Declarator -> "Record_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] } .. _INT:AST:Array_Type_Definition: Iir_Kind_Array_Type_Definition ============================== LRM08 5.3.2 Array types / LRM93 3.2.1 :: unbounded_array_definition ::= ARRAY ( index_subtype_definition { , index_subtype_definition } ) OF element_subtype_indication :: index_subtype_definition ::= type_mark RANGE <> Format: ``Medium`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Index_Subtype_Definition_List ` - ``Field6`` - ``Iir_Flist`` - owned - This is a list of type marks. * - :ref:`Element_Subtype_Indication ` - ``Field2`` - ``Iir`` - owned - The subtype_indication as it appears in a array type declaration. * - :ref:`Index_Subtype_List ` - ``Field9`` - ``Iir_Flist`` - ref - Same as the index_subtype_definition_list. * - :ref:`Element_Subtype ` - ``Field1`` - ``Iir`` - ref - — * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Constraint_State ` - ``State2`` - ``Iir_Constraint`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Index_Constraint_Flag ` - ``Flag4`` - ``Boolean`` - owned - Always false. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Array_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Array_Type_Definition|{ Index_Subtype_Definition_List| Element_Subtype_Indication| Index_Subtype_List| Element_Subtype| Type_Declarator| Type_Staticness| Constraint_State| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Index_Constraint_Flag}}"] "Array_Type_Definition__Index_Subtype_Definition_List" [shape=box3d label="Iir_Flist"] "Array_Type_Definition":Index_Subtype_Definition_List -> "Array_Type_Definition__Index_Subtype_Definition_List" [color="#000000"] "Array_Type_Definition__Element_Subtype_Indication" [shape=box label="Iir"] "Array_Type_Definition":Element_Subtype_Indication -> "Array_Type_Definition__Element_Subtype_Indication" [color="#000000"] "Array_Type_Definition__Index_Subtype_List" [shape=box3d label="Iir_Flist"] "Array_Type_Definition":Index_Subtype_List -> "Array_Type_Definition__Index_Subtype_List" [color="#3465a4" style=dashed] "Array_Type_Definition__Element_Subtype" [shape=box label="Iir"] "Array_Type_Definition":Element_Subtype -> "Array_Type_Definition__Element_Subtype" [color="#3465a4" style=dashed] "Array_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Array_Type_Definition":Type_Declarator -> "Array_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] } .. _INT:AST:Array_Subtype_Definition: Iir_Kind_Array_Subtype_Definition ================================= Format: ``Medium`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Resolution_Indication ` - ``Field5`` - ``Iir`` - owned - Either a resolution function name, an array_element_resolution or a record_resolution * - :ref:`Index_Constraint_List ` - ``Field6`` - ``Iir_Flist`` - owned - The index_constraint list as it appears in the subtype indication (if present). This is a list of subtype indication. Owned by this node. * - :ref:`Index_Subtype_List ` - ``Field9`` - ``Iir_Flist`` - ref - The type of the index. This is either the index_constraint list or the index subtypes of the type_mark. Not owned by this node. * - :ref:`Array_Element_Constraint ` - ``Field8`` - ``Iir`` - owned - Set when the element is re-constrained. Note that the element subtype may be different from the parent also if it is resolved. This is mostly for ownership. * - :ref:`Tolerance ` - ``Field7`` - ``Iir`` - owned - — * - :ref:`Element_Subtype ` - ``Field1`` - ``Iir`` - ref - — * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Constraint_State ` - ``State2`` - ``Iir_Constraint`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Index_Constraint_Flag ` - ``Flag4`` - ``Boolean`` - owned - True if the indexes are constrained (either by this definition or by a parent). * - :ref:`Has_Array_Constraint_Flag ` - ``Flag5`` - ``Boolean`` - owned - If True, an array constraint is lexically present (at least for the index). This can be an index constraint or 'open'. * - :ref:`Has_Element_Constraint_Flag ` - ``Flag6`` - ``Boolean`` - owned - If True, an element constraint is lexically present. It can be 'open'. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Array_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{Array_Subtype_Definition|{ Subtype_Type_Mark| Resolution_Indication| Index_Constraint_List| Index_Subtype_List| Array_Element_Constraint| Tolerance| Element_Subtype| Type_Declarator| Parent_Type| Type_Staticness| Constraint_State| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Index_Constraint_Flag| Has_Array_Constraint_Flag| Has_Element_Constraint_Flag}}"] "Array_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "Array_Subtype_Definition":Subtype_Type_Mark -> "Array_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "Array_Subtype_Definition__Resolution_Indication" [shape=box label="Iir"] "Array_Subtype_Definition":Resolution_Indication -> "Array_Subtype_Definition__Resolution_Indication" [color="#000000"] "Array_Subtype_Definition__Index_Constraint_List" [shape=box3d label="Iir_Flist"] "Array_Subtype_Definition":Index_Constraint_List -> "Array_Subtype_Definition__Index_Constraint_List" [color="#000000"] "Array_Subtype_Definition__Index_Subtype_List" [shape=box3d label="Iir_Flist"] "Array_Subtype_Definition":Index_Subtype_List -> "Array_Subtype_Definition__Index_Subtype_List" [color="#3465a4" style=dashed] "Array_Subtype_Definition__Array_Element_Constraint" [shape=box label="Iir"] "Array_Subtype_Definition":Array_Element_Constraint -> "Array_Subtype_Definition__Array_Element_Constraint" [color="#000000"] "Array_Subtype_Definition__Tolerance" [shape=box label="Iir"] "Array_Subtype_Definition":Tolerance -> "Array_Subtype_Definition__Tolerance" [color="#000000"] "Array_Subtype_Definition__Element_Subtype" [shape=box label="Iir"] "Array_Subtype_Definition":Element_Subtype -> "Array_Subtype_Definition__Element_Subtype" [color="#3465a4" style=dashed] "Array_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "Array_Subtype_Definition":Type_Declarator -> "Array_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Array_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "Array_Subtype_Definition":Parent_Type -> "Array_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] } .. _INT:AST:Record_Subtype_Definition: Iir_Kind_Record_Subtype_Definition ================================== Format: ``Medium`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Owned_Elements_Chain ` - ``Field6`` - ``Iir`` - chain - Chain of new elements constraint. Needed only for internal consistency of the tree (ownership). * - :ref:`Elements_Declaration_List ` - ``Field1`` - ``Iir_Flist`` - of maybe ref - Chain of either element_declaration or record_element_constraint. * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Resolution_Indication ` - ``Field5`` - ``Iir`` - owned - Either a resolution function name, an array_element_resolution or a record_resolution * - :ref:`Tolerance ` - ``Field7`` - ``Iir`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Constraint_State ` - ``State2`` - ``Iir_Constraint`` - owned - — * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Always true for record subtype: elements are owned through Owned_Elements_Chain .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Record_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{Record_Subtype_Definition|{ Owned_Elements_Chain| Elements_Declaration_List| Subtype_Type_Mark| Type_Declarator| Parent_Type| Resolution_Indication| Tolerance| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Type_Staticness| Constraint_State| Is_Ref}}"] "Record_Subtype_Definition__Owned_Elements_Chain" [shape=box label="Iir"] "Record_Subtype_Definition":Owned_Elements_Chain -> "Record_Subtype_Definition__Owned_Elements_Chain" [color="#4e9a06"] "Record_Subtype_Definition__Elements_Declaration_List" [shape=box3d label="Iir_Flist"] "Record_Subtype_Definition":Elements_Declaration_List -> "Record_Subtype_Definition__Elements_Declaration_List" [color="#3465a4" style=dotted] "Record_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "Record_Subtype_Definition":Subtype_Type_Mark -> "Record_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "Record_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "Record_Subtype_Definition":Type_Declarator -> "Record_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Record_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "Record_Subtype_Definition":Parent_Type -> "Record_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] "Record_Subtype_Definition__Resolution_Indication" [shape=box label="Iir"] "Record_Subtype_Definition":Resolution_Indication -> "Record_Subtype_Definition__Resolution_Indication" [color="#000000"] "Record_Subtype_Definition__Tolerance" [shape=box label="Iir"] "Record_Subtype_Definition":Tolerance -> "Record_Subtype_Definition__Tolerance" [color="#000000"] } .. _INT:AST:Access_Subtype_Definition: Iir_Kind_Access_Subtype_Definition ================================== Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Designated_Type ` - ``Field1`` - ``Iir`` - forward ref - — * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Designated_Subtype_Indication ` - ``Field5`` - ``Iir`` - owned - — * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - Note: no resolution function for access subtype. * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Access_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{Access_Subtype_Definition|{ Designated_Type| Subtype_Type_Mark| Type_Declarator| Parent_Type| Designated_Subtype_Indication| Type_Staticness| Resolved_Flag| Signal_Type_Flag}}"] "Access_Subtype_Definition__Designated_Type" [shape=box label="Iir"] "Access_Subtype_Definition":Designated_Type -> "Access_Subtype_Definition__Designated_Type" [color="#f57900" style=dashed] "Access_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "Access_Subtype_Definition":Subtype_Type_Mark -> "Access_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "Access_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "Access_Subtype_Definition":Type_Declarator -> "Access_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Access_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "Access_Subtype_Definition":Parent_Type -> "Access_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] "Access_Subtype_Definition__Designated_Subtype_Indication" [shape=box label="Iir"] "Access_Subtype_Definition":Designated_Subtype_Indication -> "Access_Subtype_Definition__Designated_Subtype_Indication" [color="#000000"] } .. _INT:AST:File_Subtype_Definition: Iir_Kind_File_Subtype_Definition ================================ Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Text_File_Flag ` - ``Flag4`` - ``Boolean`` - owned - True if this is the std.textio.text file type, which may require special handling. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "File_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{File_Subtype_Definition|{ Subtype_Type_Mark| Type_Declarator| Parent_Type| Resolved_Flag| Signal_Type_Flag| Text_File_Flag| Type_Staticness}}"] "File_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "File_Subtype_Definition":Subtype_Type_Mark -> "File_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "File_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "File_Subtype_Definition":Type_Declarator -> "File_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "File_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "File_Subtype_Definition":Parent_Type -> "File_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] } .. _INT:AST:Physical_Subtype_Definition: Iir_Kind_Physical_Subtype_Definition ==================================== Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - — * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Resolution_Indication ` - ``Field5`` - ``Iir`` - owned - Either a resolution function name, an array_element_resolution or a record_resolution * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Physical_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{Physical_Subtype_Definition|{ Range_Constraint| Subtype_Type_Mark| Type_Declarator| Parent_Type| Resolution_Indication| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Is_Ref| Type_Staticness}}"] "Physical_Subtype_Definition__Range_Constraint" [shape=box label="Iir"] "Physical_Subtype_Definition":Range_Constraint -> "Physical_Subtype_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Physical_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "Physical_Subtype_Definition":Subtype_Type_Mark -> "Physical_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "Physical_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "Physical_Subtype_Definition":Type_Declarator -> "Physical_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Physical_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "Physical_Subtype_Definition":Parent_Type -> "Physical_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] "Physical_Subtype_Definition__Resolution_Indication" [shape=box label="Iir"] "Physical_Subtype_Definition":Resolution_Indication -> "Physical_Subtype_Definition__Resolution_Indication" [color="#000000"] } .. _INT:AST:Floating_Subtype_Definition: Iir_Kind_Floating_Subtype_Definition ==================================== Format: ``Medium`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - — * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Resolution_Indication ` - ``Field5`` - ``Iir`` - owned - Either a resolution function name, an array_element_resolution or a record_resolution * - :ref:`Tolerance ` - ``Field7`` - ``Iir`` - owned - — * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Floating_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{Floating_Subtype_Definition|{ Range_Constraint| Subtype_Type_Mark| Type_Declarator| Parent_Type| Resolution_Indication| Tolerance| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Is_Ref| Type_Staticness}}"] "Floating_Subtype_Definition__Range_Constraint" [shape=box label="Iir"] "Floating_Subtype_Definition":Range_Constraint -> "Floating_Subtype_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Floating_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "Floating_Subtype_Definition":Subtype_Type_Mark -> "Floating_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "Floating_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "Floating_Subtype_Definition":Type_Declarator -> "Floating_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Floating_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "Floating_Subtype_Definition":Parent_Type -> "Floating_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] "Floating_Subtype_Definition__Resolution_Indication" [shape=box label="Iir"] "Floating_Subtype_Definition":Resolution_Indication -> "Floating_Subtype_Definition__Resolution_Indication" [color="#000000"] "Floating_Subtype_Definition__Tolerance" [shape=box label="Iir"] "Floating_Subtype_Definition":Tolerance -> "Floating_Subtype_Definition__Tolerance" [color="#000000"] } .. _INT:AST:Integer_Subtype_Definition: Iir_Kind_Integer_Subtype_Definition =================================== Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - — * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Resolution_Indication ` - ``Field5`` - ``Iir`` - owned - Either a resolution function name, an array_element_resolution or a record_resolution * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Integer_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{Integer_Subtype_Definition|{ Range_Constraint| Subtype_Type_Mark| Type_Declarator| Parent_Type| Resolution_Indication| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Is_Ref| Type_Staticness}}"] "Integer_Subtype_Definition__Range_Constraint" [shape=box label="Iir"] "Integer_Subtype_Definition":Range_Constraint -> "Integer_Subtype_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Integer_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "Integer_Subtype_Definition":Subtype_Type_Mark -> "Integer_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "Integer_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "Integer_Subtype_Definition":Type_Declarator -> "Integer_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Integer_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "Integer_Subtype_Definition":Parent_Type -> "Integer_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] "Integer_Subtype_Definition__Resolution_Indication" [shape=box label="Iir"] "Integer_Subtype_Definition":Resolution_Indication -> "Integer_Subtype_Definition__Resolution_Indication" [color="#000000"] } .. _INT:AST:Enumeration_Subtype_Definition: Iir_Kind_Enumeration_Subtype_Definition ======================================= Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - — * - :ref:`Subtype_Type_Mark ` - ``Field2`` - ``Iir`` - owned - The type_mark that appeared in the subtype indication. This is a name. May be null_iir if there is no type mark (as in an iterator). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Parent_Type ` - ``Field4`` - ``Iir`` - ref - — * - :ref:`Resolution_Indication ` - ``Field5`` - ``Iir`` - owned - Either a resolution function name, an array_element_resolution or a record_resolution * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Enumeration_Subtype_Definition" [style=filled fillcolor="#eeeeec" label="{Enumeration_Subtype_Definition|{ Range_Constraint| Subtype_Type_Mark| Type_Declarator| Parent_Type| Resolution_Indication| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Is_Ref| Type_Staticness}}"] "Enumeration_Subtype_Definition__Range_Constraint" [shape=box label="Iir"] "Enumeration_Subtype_Definition":Range_Constraint -> "Enumeration_Subtype_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Enumeration_Subtype_Definition__Subtype_Type_Mark" [shape=box label="Iir"] "Enumeration_Subtype_Definition":Subtype_Type_Mark -> "Enumeration_Subtype_Definition__Subtype_Type_Mark" [color="#000000"] "Enumeration_Subtype_Definition__Type_Declarator" [shape=box label="Iir"] "Enumeration_Subtype_Definition":Type_Declarator -> "Enumeration_Subtype_Definition__Type_Declarator" [color="#3465a4" style=dashed] "Enumeration_Subtype_Definition__Parent_Type" [shape=box label="Iir"] "Enumeration_Subtype_Definition":Parent_Type -> "Enumeration_Subtype_Definition__Parent_Type" [color="#3465a4" style=dashed] "Enumeration_Subtype_Definition__Resolution_Indication" [shape=box label="Iir"] "Enumeration_Subtype_Definition":Resolution_Indication -> "Enumeration_Subtype_Definition__Resolution_Indication" [color="#000000"] } .. _INT:AST:Enumeration_Type_Definition: Iir_Kind_Enumeration_Type_Definition ==================================== Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Enumeration_Literal_List ` - ``Field2`` - ``Iir_Flist`` - owned - Return the list of literals. This list is created when the node is created. * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - Get the range of the type (This is just an ascending range from the first literal to the last declared literal). * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Only_Characters_Flag ` - ``Flag4`` - ``Boolean`` - owned - True if enumeration type ATYPE has only character literals. * - :ref:`Is_Character_Type ` - ``Flag5`` - ``Boolean`` - owned - True if enumeration type ATYPE is a character type (at least one literal is a character). * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`Scalar_Size ` - ``Flag6`` - ``Scalar_Size`` - owned - Note: only 8 or 32. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Enumeration_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Enumeration_Type_Definition|{ Enumeration_Literal_List| Range_Constraint| Type_Declarator| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Only_Characters_Flag| Is_Character_Type| Is_Ref| Type_Staticness| Scalar_Size}}"] "Enumeration_Type_Definition__Enumeration_Literal_List" [shape=box3d label="Iir_Flist"] "Enumeration_Type_Definition":Enumeration_Literal_List -> "Enumeration_Type_Definition__Enumeration_Literal_List" [color="#000000"] "Enumeration_Type_Definition__Range_Constraint" [shape=box label="Iir"] "Enumeration_Type_Definition":Range_Constraint -> "Enumeration_Type_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Enumeration_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Enumeration_Type_Definition":Type_Declarator -> "Enumeration_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] } .. _INT:AST:Integer_Type_Definition: Iir_Kind_Integer_Type_Definition ================================ Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - The range_constraint from the type declaration. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator that has created this type. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - Type staticness is always locally. * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Scalar_Size ` - ``Flag6`` - ``Scalar_Size`` - owned - Note: only 32 or 64. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Integer_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Integer_Type_Definition|{ Range_Constraint| Type_Declarator| Type_Staticness| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Is_Ref| Scalar_Size}}"] "Integer_Type_Definition__Range_Constraint" [shape=box label="Iir"] "Integer_Type_Definition":Range_Constraint -> "Integer_Type_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Integer_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Integer_Type_Definition":Type_Declarator -> "Integer_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] } .. _INT:AST:Floating_Type_Definition: Iir_Kind_Floating_Type_Definition ================================= Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - The range_constraint from the type declaration. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator that has created this type. * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - Type staticness is always locally. * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Scalar_Size ` - ``Flag6`` - ``Scalar_Size`` - owned - Note: only 32 or 64. .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Floating_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Floating_Type_Definition|{ Range_Constraint| Type_Declarator| Type_Staticness| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Is_Ref| Scalar_Size}}"] "Floating_Type_Definition__Range_Constraint" [shape=box label="Iir"] "Floating_Type_Definition":Range_Constraint -> "Floating_Type_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Floating_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Floating_Type_Definition":Type_Declarator -> "Floating_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] } .. _INT:AST:Physical_Type_Definition: Iir_Kind_Physical_Type_Definition ================================= Format: ``Short`` .. list-table:: :header-rows: 1 :widths: 30 12 18 12 28 * - Accessor - Field - Type - Access - Description * - :ref:`Range_Constraint ` - ``Field1`` - ``Iir`` - maybe ref - The range_constraint from the type declaration. * - :ref:`Unit_Chain ` - ``Field2`` - ``Iir`` - chain - Chain of physical type units. The first unit is the primary unit. If you really need the primary unit (and not the chain), you'd better to use Get_Primary_Unit. * - :ref:`Type_Declarator ` - ``Field3`` - ``Iir`` - ref - The type declarator which declares the type definition DEF. Can also be a nature declarator for composite nature definition. * - :ref:`Resolved_Flag ` - ``Flag1`` - ``Boolean`` - owned - Get/Set the resolved flag of a subtype definition. A subtype definition may be resolved either because a resolution_indication is present in the subtype_indication, or because all elements type are resolved. * - :ref:`Signal_Type_Flag ` - ``Flag2`` - ``Boolean`` - owned - Get/Set the signal_type flag of a type/subtype definition. This flags indicates whether the type can be used as a signal type. Access types, file types and composite types whose a sub-element is an access type cannot be used as a signal type. * - :ref:`Has_Signal_Flag ` - ``Flag3`` - ``Boolean`` - owned - True if ATYPE is used to declare a signal or to handle a signal (such as slice or aliases). * - :ref:`Type_Staticness ` - ``State1`` - ``Iir_Staticness`` - owned - — * - :ref:`End_Has_Reserved_Id ` - ``Flag8`` - ``Boolean`` - owned - Layout flag: true if 'end' is followed by the reserved identifier. * - :ref:`End_Has_Identifier ` - ``Flag9`` - ``Boolean`` - owned - Layout flag: true if 'end' is followed by the identifier. * - :ref:`Is_Ref ` - ``Flag12`` - ``Boolean`` - owned - Set to True if Maybe_Ref fields are references. This cannot be shared with Has_Identifier_List as: Is_Ref is set to True on all items but the first, while Has_Identifier_List is set to True on all items but the last. Furthermore Is_Ref appears in nodes where Has_Identifier_List is not present. * - :ref:`Scalar_Size ` - ``Flag6`` - ``Scalar_Size`` - owned - — .. graphviz:: digraph { rankdir="LR" node [shape=record fontname="monospace" fontsize=10] edge [fontname="monospace" fontsize=9] "Physical_Type_Definition" [style=filled fillcolor="#eeeeec" label="{Physical_Type_Definition|{ Range_Constraint| Unit_Chain| Type_Declarator| Resolved_Flag| Signal_Type_Flag| Has_Signal_Flag| Type_Staticness| End_Has_Reserved_Id| End_Has_Identifier| Is_Ref| Scalar_Size}}"] "Physical_Type_Definition__Range_Constraint" [shape=box label="Iir"] "Physical_Type_Definition":Range_Constraint -> "Physical_Type_Definition__Range_Constraint" [color="#3465a4" style=dotted] "Physical_Type_Definition__Unit_Chain" [shape=box label="Iir"] "Physical_Type_Definition":Unit_Chain -> "Physical_Type_Definition__Unit_Chain" [color="#4e9a06"] "Physical_Type_Definition__Type_Declarator" [shape=box label="Iir"] "Physical_Type_Definition":Type_Declarator -> "Physical_Type_Definition__Type_Declarator" [color="#3465a4" style=dashed] }