function Actual_Subtype (Id : E) return E is
begin
pragma Assert
- (Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable
- or else Ekind (Id) = E_Generic_In_Out_Parameter
+ (Ekind_In (Id, E_Constant, E_Variable, E_Generic_In_Out_Parameter)
or else Is_Formal (Id));
return Node17 (Id);
end Actual_Subtype;
begin
pragma Assert (Is_Type (Id)
or else Is_Formal (Id)
- or else Ekind (Id) = E_Loop_Parameter
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Exception
- or else Ekind (Id) = E_Variable);
+ or else Ekind_In (Id, E_Loop_Parameter,
+ E_Constant,
+ E_Exception,
+ E_Variable));
return Uint14 (Id);
end Alignment;
function Body_Entity (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Package or else Ekind (Id) = E_Generic_Package);
+ pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
return Node19 (Id);
end Body_Entity;
function Cloned_Subtype (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Record_Subtype
- or else
- Ekind (Id) = E_Class_Wide_Subtype);
+ pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Class_Wide_Subtype));
return Node16 (Id);
end Cloned_Subtype;
function Component_Bit_Offset (Id : E) return U is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint11 (Id);
end Component_Bit_Offset;
function Component_Clause (Id : E) return N is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Node13 (Id);
end Component_Clause;
function DT_Position (Id : E) return U is
begin
- pragma Assert
- ((Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure)
- and then Present (DTC_Entity (Id)));
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ and then Present (DTC_Entity (Id)));
return Uint15 (Id);
end DT_Position;
function DTC_Entity (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Function or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Node16 (Id);
end DTC_Entity;
function Equivalent_Type (Id : E) return E is
begin
pragma Assert
- (Ekind (Id) = E_Class_Wide_Subtype or else
- Ekind (Id) = E_Access_Protected_Subprogram_Type or else
- Ekind (Id) = E_Anonymous_Access_Protected_Subprogram_Type or else
- Ekind (Id) = E_Access_Subprogram_Type or else
- Ekind (Id) = E_Exception_Type);
+ (Ekind_In (Id, E_Class_Wide_Subtype,
+ E_Access_Protected_Subprogram_Type,
+ E_Anonymous_Access_Protected_Subprogram_Type,
+ E_Access_Subprogram_Type,
+ E_Exception_Type));
return Node18 (Id);
end Equivalent_Type;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Entry_Family
- or else Ekind (Id) = E_Subprogram_Body
- or else Ekind (Id) = E_Subprogram_Type);
+ or else Ekind_In (Id, E_Entry_Family,
+ E_Subprogram_Body,
+ E_Subprogram_Type));
return Node28 (Id);
end Extra_Formals;
function First_Optional_Parameter (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Function or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Node14 (Id);
end First_Optional_Parameter;
function First_Private_Entity (Id : E) return E is
begin
- pragma Assert (Ekind (Id) = E_Package
- or else Ekind (Id) = E_Generic_Package
+ pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package)
or else Ekind (Id) in Concurrent_Kind);
return Node16 (Id);
end First_Private_Entity;
function Has_Missing_Return (Id : E) return B is
begin
- pragma Assert
- (Ekind (Id) = E_Function or else Ekind (Id) = E_Generic_Function);
+ pragma Assert (Ekind_In (Id, E_Function, E_Generic_Function));
return Flag142 (Id);
end Has_Missing_Return;
function Has_Up_Level_Access (Id : E) return B is
begin
pragma Assert
- (Ekind (Id) = E_Variable
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Loop_Parameter);
+ (Ekind_In (Id, E_Variable, E_Constant, E_Loop_Parameter));
return Flag215 (Id);
end Has_Up_Level_Access;
function Implemented_By_Entry (Id : E) return B is
begin
- pragma Assert
- (Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag232 (Id);
end Implemented_By_Entry;
function Is_Asynchronous (Id : E) return B is
begin
- pragma Assert
- (Ekind (Id) = E_Procedure or else Is_Type (Id));
+ pragma Assert (Ekind (Id) = E_Procedure or else Is_Type (Id));
return Flag81 (Id);
end Is_Asynchronous;
function Is_Called (Id : E) return B is
begin
- pragma Assert
- (Ekind (Id) = E_Procedure or else Ekind (Id) = E_Function);
+ pragma Assert (Ekind_In (Id, E_Procedure, E_Function));
return Flag102 (Id);
end Is_Called;
function Is_For_Access_Subtype (Id : E) return B is
begin
- pragma Assert
- (Ekind (Id) = E_Record_Subtype
- or else
- Ekind (Id) = E_Private_Subtype);
+ pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Private_Subtype));
return Flag118 (Id);
end Is_For_Access_Subtype;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Generic_Function
- or else Ekind (Id) = E_Generic_Procedure);
+ or else Ekind_In (Id, E_Generic_Function, E_Generic_Procedure));
return Flag218 (Id);
end Is_Primitive;
function Is_Primitive_Wrapper (Id : E) return B is
begin
- pragma Assert (Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag195 (Id);
end Is_Primitive_Wrapper;
function Is_Private_Primitive (Id : E) return B is
begin
- pragma Assert (Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag245 (Id);
end Is_Private_Primitive;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Subprogram_Type
- or else Ekind (Id) = E_Entry_Family);
+ or else Ekind_In (Id, E_Subprogram_Type, E_Entry_Family));
return Flag22 (Id);
end Needs_No_Actuals;
function Normalized_First_Bit (Id : E) return U is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint8 (Id);
end Normalized_First_Bit;
function Normalized_Position (Id : E) return U is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint14 (Id);
end Normalized_Position;
function Normalized_Position_Max (Id : E) return U is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint10 (Id);
end Normalized_Position_Max;
function Optimize_Alignment_Space (Id : E) return B is
begin
pragma Assert
- (Is_Type (Id)
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable);
+ (Is_Type (Id) or else Ekind_In (Id, E_Constant, E_Variable));
return Flag241 (Id);
end Optimize_Alignment_Space;
function Optimize_Alignment_Time (Id : E) return B is
begin
pragma Assert
- (Is_Type (Id)
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable);
+ (Is_Type (Id) or else Ekind_In (Id, E_Constant, E_Variable));
return Flag242 (Id);
end Optimize_Alignment_Time;
function Original_Record_Component (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Void
- or else Ekind (Id) = E_Component
- or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Void, E_Component, E_Discriminant));
return Node22 (Id);
end Original_Record_Component;
function Package_Instantiation (Id : E) return N is
begin
- pragma Assert
- (False
- or else Ekind (Id) = E_Generic_Package
- or else Ekind (Id) = E_Package);
+ pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
return Node26 (Id);
end Package_Instantiation;
function Prival_Link (Id : E) return E is
begin
- pragma Assert (Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable);
+ pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node20 (Id);
end Prival_Link;
function Protection_Object (Id : E) return E is
begin
- pragma Assert (Ekind (Id) = E_Entry
- or else Ekind (Id) = E_Entry_Family
- or else Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert
+ (Ekind_In (Id, E_Entry, E_Entry_Family, E_Function, E_Procedure));
return Node23 (Id);
end Protection_Object;
function Related_Expression (Id : E) return N is
begin
- pragma Assert (Ekind (Id) = E_Constant or else Ekind (Id) = E_Variable);
+ pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node24 (Id);
end Related_Expression;
function Related_Instance (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Package or else Ekind (Id) = E_Package_Body);
+ pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
return Node15 (Id);
end Related_Instance;
function Related_Type (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Constant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Constant));
return Node26 (Id);
end Related_Type;
function Shadow_Entities (Id : E) return S is
begin
- pragma Assert
- (Ekind (Id) = E_Package or else Ekind (Id) = E_Generic_Package);
+ pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
return List14 (Id);
end Shadow_Entities;
function Size_Check_Code (Id : E) return N is
begin
- pragma Assert (Ekind (Id) = E_Constant or else Ekind (Id) = E_Variable);
+ pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node19 (Id);
end Size_Check_Code;
function Spec_Entity (Id : E) return E is
begin
- pragma Assert
- (Ekind (Id) = E_Package_Body or else Is_Formal (Id));
+ pragma Assert (Ekind (Id) = E_Package_Body or else Is_Formal (Id));
return Node19 (Id);
end Spec_Entity;
function Wrapped_Entity (Id : E) return E is
begin
- pragma Assert ((Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure)
- and then Is_Primitive_Wrapper (Id));
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ and then Is_Primitive_Wrapper (Id));
return Node27 (Id);
end Wrapped_Entity;
function Is_Signed_Integer_Type (Id : E) return B is
begin
- return Ekind (Id) in
- Signed_Integer_Kind;
+ return Ekind (Id) in Signed_Integer_Kind;
end Is_Signed_Integer_Type;
function Is_Subprogram (Id : E) return B is
procedure Set_Actual_Subtype (Id : E; V : E) is
begin
pragma Assert
- (Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable
- or else Ekind (Id) = E_Generic_In_Out_Parameter
+ (Ekind_In (Id, E_Constant, E_Variable, E_Generic_In_Out_Parameter)
or else Is_Formal (Id));
Set_Node17 (Id, V);
end Set_Actual_Subtype;
procedure Set_Alignment (Id : E; V : U) is
begin
pragma Assert (Is_Type (Id)
- or else Is_Formal (Id)
- or else Ekind (Id) = E_Loop_Parameter
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Exception
- or else Ekind (Id) = E_Variable);
+ or else Is_Formal (Id)
+ or else Ekind_In (Id, E_Loop_Parameter,
+ E_Constant,
+ E_Exception,
+ E_Variable));
Set_Uint14 (Id, V);
end Set_Alignment;
procedure Set_Body_Entity (Id : E; V : E) is
begin
- pragma Assert
- (Ekind (Id) = E_Package or else Ekind (Id) = E_Generic_Package);
+ pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
Set_Node19 (Id, V);
end Set_Body_Entity;
begin
pragma Assert
(Ekind (Id) = E_Package
- or else Is_Subprogram (Id)
- or else Is_Generic_Unit (Id));
+ or else Is_Subprogram (Id)
+ or else Is_Generic_Unit (Id));
Set_Flag40 (Id, V);
end Set_Body_Needed_For_SAL;
procedure Set_Cloned_Subtype (Id : E; V : E) is
begin
- pragma Assert
- (Ekind (Id) = E_Record_Subtype
- or else Ekind (Id) = E_Class_Wide_Subtype);
+ pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Class_Wide_Subtype));
Set_Node16 (Id, V);
end Set_Cloned_Subtype;
procedure Set_Component_Bit_Offset (Id : E; V : U) is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Uint11 (Id, V);
end Set_Component_Bit_Offset;
procedure Set_Component_Clause (Id : E; V : N) is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Node13 (Id, V);
end Set_Component_Clause;
procedure Set_Delay_Subprogram_Descriptors (Id : E; V : B := True) is
begin
pragma Assert
- (Is_Subprogram (Id)
- or else Ekind (Id) = E_Package
- or else Ekind (Id) = E_Package_Body);
+ (Is_Subprogram (Id) or else Ekind_In (Id, E_Package, E_Package_Body));
Set_Flag50 (Id, V);
end Set_Delay_Subprogram_Descriptors;
procedure Set_DT_Position (Id : E; V : U) is
begin
- pragma Assert (Ekind (Id) = E_Function or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
Set_Uint15 (Id, V);
end Set_DT_Position;
procedure Set_DTC_Entity (Id : E; V : E) is
begin
- pragma Assert
- (Ekind (Id) = E_Function or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
Set_Node16 (Id, V);
end Set_DTC_Entity;
procedure Set_Equivalent_Type (Id : E; V : E) is
begin
pragma Assert
- (Ekind (Id) = E_Class_Wide_Type or else
- Ekind (Id) = E_Class_Wide_Subtype or else
- Ekind (Id) = E_Access_Protected_Subprogram_Type or else
- Ekind (Id) = E_Anonymous_Access_Protected_Subprogram_Type or else
- Ekind (Id) = E_Access_Subprogram_Type or else
- Ekind (Id) = E_Exception_Type);
+ (Ekind_In (Id, E_Class_Wide_Type,
+ E_Class_Wide_Subtype,
+ E_Access_Protected_Subprogram_Type,
+ E_Anonymous_Access_Protected_Subprogram_Type,
+ E_Access_Subprogram_Type,
+ E_Exception_Type));
Set_Node18 (Id, V);
end Set_Equivalent_Type;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Entry_Family
- or else Ekind (Id) = E_Subprogram_Body
- or else Ekind (Id) = E_Subprogram_Type);
+ or else Ekind_In (Id, E_Entry_Family,
+ E_Subprogram_Body,
+ E_Subprogram_Type));
Set_Node28 (Id, V);
end Set_Extra_Formals;
procedure Set_First_Optional_Parameter (Id : E; V : E) is
begin
- pragma Assert
- (Ekind (Id) = E_Function or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
Set_Node14 (Id, V);
end Set_First_Optional_Parameter;
procedure Set_First_Private_Entity (Id : E; V : E) is
begin
- pragma Assert (Ekind (Id) = E_Package
- or else Ekind (Id) = E_Generic_Package
- or else Ekind (Id) in Concurrent_Kind);
+ pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package)
+ or else Ekind (Id) in Concurrent_Kind);
Set_Node16 (Id, V);
end Set_First_Private_Entity;
begin
pragma Assert
(Is_Type (Id)
- or else Ekind (Id) = E_Package);
+ or else Ekind (Id) = E_Package);
Set_Flag159 (Id, V);
end Set_From_With_Type;
procedure Set_Has_Initial_Value (Id : E; V : B := True) is
begin
- pragma Assert
- (Ekind (Id) = E_Variable or else Ekind (Id) = E_Out_Parameter);
+ pragma Assert (Ekind_In (Id, E_Variable, E_Out_Parameter));
Set_Flag219 (Id, V);
end Set_Has_Initial_Value;
procedure Set_Has_Missing_Return (Id : E; V : B := True) is
begin
- pragma Assert
- (Ekind (Id) = E_Function or else Ekind (Id) = E_Generic_Function);
+ pragma Assert (Ekind_In (Id, E_Function, E_Generic_Function));
Set_Flag142 (Id, V);
end Set_Has_Missing_Return;
procedure Set_Has_Up_Level_Access (Id : E; V : B := True) is
begin
- pragma Assert
- (Ekind (Id) = E_Variable
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Loop_Parameter);
+ pragma Assert (Ekind_In (Id, E_Variable, E_Constant, E_Loop_Parameter));
Set_Flag215 (Id, V);
end Set_Has_Up_Level_Access;
procedure Set_Implemented_By_Entry (Id : E; V : B := True) is
begin
- pragma Assert
- (Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
Set_Flag232 (Id, V);
end Set_Implemented_By_Entry;
pragma Assert
(Is_Internal (Id)
and then Is_Hidden (Id)
- and then (Ekind (Id) = E_Procedure
- or else Ekind (Id) = E_Function));
+ and then (Ekind_In (Id, E_Procedure, E_Function)));
Set_Node25 (Id, V);
end Set_Interface_Alias;
procedure Set_Is_Called (Id : E; V : B := True) is
begin
- pragma Assert
- (Ekind (Id) = E_Procedure or else Ekind (Id) = E_Function);
+ pragma Assert (Ekind_In (Id, E_Procedure, E_Function));
Set_Flag102 (Id, V);
end Set_Is_Called;
procedure Set_Is_For_Access_Subtype (Id : E; V : B := True) is
begin
- pragma Assert
- (Ekind (Id) = E_Record_Subtype
- or else
- Ekind (Id) = E_Private_Subtype);
+ pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Private_Subtype));
Set_Flag118 (Id, V);
end Set_Is_For_Access_Subtype;
procedure Set_Is_Interface (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind (Id) = E_Record_Type
- or else Ekind (Id) = E_Record_Subtype
- or else Ekind (Id) = E_Record_Type_With_Private
- or else Ekind (Id) = E_Record_Subtype_With_Private
- or else Ekind (Id) = E_Class_Wide_Type
- or else Ekind (Id) = E_Class_Wide_Subtype);
+ (Ekind_In (Id, E_Record_Type,
+ E_Record_Subtype,
+ E_Record_Type_With_Private,
+ E_Record_Subtype_With_Private,
+ E_Class_Wide_Type,
+ E_Class_Wide_Subtype));
Set_Flag186 (Id, V);
end Set_Is_Interface;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Generic_Function
- or else Ekind (Id) = E_Generic_Procedure);
+ or else Ekind_In (Id, E_Generic_Function, E_Generic_Procedure));
Set_Flag218 (Id, V);
end Set_Is_Primitive;
procedure Set_Is_Primitive_Wrapper (Id : E; V : B := True) is
begin
- pragma Assert (Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
Set_Flag195 (Id, V);
end Set_Is_Primitive_Wrapper;
procedure Set_Is_Private_Primitive (Id : E; V : B := True) is
begin
- pragma Assert (Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
Set_Flag245 (Id, V);
end Set_Is_Private_Primitive;
procedure Set_Is_Statically_Allocated (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind (Id) = E_Exception
- or else Ekind (Id) = E_Variable
- or else Ekind (Id) = E_Constant
- or else Is_Type (Id)
- or else Ekind (Id) = E_Void);
+ (Is_Type (Id)
+ or else Ekind_In (Id, E_Exception,
+ E_Variable,
+ E_Constant,
+ E_Void));
Set_Flag28 (Id, V);
end Set_Is_Statically_Allocated;
procedure Set_Is_Tag (Id : E; V : B := True) is
begin
- pragma Assert
- (Ekind (Id) = E_Component
- or else Ekind (Id) = E_Constant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Constant));
Set_Flag78 (Id, V);
end Set_Is_Tag;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Subprogram_Type
- or else Ekind (Id) = E_Entry_Family);
+ or else Ekind_In (Id, E_Subprogram_Type, E_Entry_Family));
Set_Flag22 (Id, V);
end Set_Needs_No_Actuals;
procedure Set_No_Return (Id : E; V : B := True) is
begin
pragma Assert
- (V = False
- or else Ekind (Id) = E_Procedure
- or else Ekind (Id) = E_Generic_Procedure);
+ (V = False or else Ekind_In (Id, E_Procedure, E_Generic_Procedure));
Set_Flag113 (Id, V);
end Set_No_Return;
procedure Set_Normalized_First_Bit (Id : E; V : U) is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Uint8 (Id, V);
end Set_Normalized_First_Bit;
procedure Set_Normalized_Position (Id : E; V : U) is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Uint14 (Id, V);
end Set_Normalized_Position;
procedure Set_Normalized_Position_Max (Id : E; V : U) is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Uint10 (Id, V);
end Set_Normalized_Position_Max;
procedure Set_Optimize_Alignment_Space (Id : E; V : B := True) is
begin
pragma Assert
- (Is_Type (Id)
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable);
+ (Is_Type (Id) or else Ekind_In (Id, E_Constant, E_Variable));
Set_Flag241 (Id, V);
end Set_Optimize_Alignment_Space;
procedure Set_Optimize_Alignment_Time (Id : E; V : B := True) is
begin
pragma Assert
- (Is_Type (Id)
- or else Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable);
+ (Is_Type (Id) or else Ekind_In (Id, E_Constant, E_Variable));
Set_Flag242 (Id, V);
end Set_Optimize_Alignment_Time;
procedure Set_Original_Record_Component (Id : E; V : E) is
begin
- pragma Assert
- (Ekind (Id) = E_Void
- or else Ekind (Id) = E_Component
- or else Ekind (Id) = E_Discriminant);
+ pragma Assert (Ekind_In (Id, E_Void, E_Component, E_Discriminant));
Set_Node22 (Id, V);
end Set_Original_Record_Component;
procedure Set_Package_Instantiation (Id : E; V : N) is
begin
- pragma Assert
- (Ekind (Id) = E_Void
- or else Ekind (Id) = E_Generic_Package
- or else Ekind (Id) = E_Package);
+ pragma Assert (Ekind_In (Id, E_Void, E_Generic_Package, E_Package));
Set_Node26 (Id, V);
end Set_Package_Instantiation;
procedure Set_Prival_Link (Id : E; V : E) is
begin
- pragma Assert (Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable);
+ pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
Set_Node20 (Id, V);
end Set_Prival_Link;
procedure Set_Protection_Object (Id : E; V : E) is
begin
- pragma Assert (Ekind (Id) = E_Entry
- or else Ekind (Id) = E_Entry_Family
- or else Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure);
+ pragma Assert (Ekind_In (Id, E_Entry,
+ E_Entry_Family,
+ E_Function,
+ E_Procedure));
Set_Node23 (Id, V);
end Set_Protection_Object;
procedure Set_Related_Instance (Id : E; V : E) is
begin
- pragma Assert
- (Ekind (Id) = E_Package or else Ekind (Id) = E_Package_Body);
+ pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
Set_Node15 (Id, V);
end Set_Related_Instance;
procedure Set_Related_Type (Id : E; V : E) is
begin
- pragma Assert
- (Ekind (Id) = E_Component or else Ekind (Id) = E_Constant);
+ pragma Assert (Ekind_In (Id, E_Component, E_Constant));
Set_Node26 (Id, V);
end Set_Related_Type;
procedure Set_Shadow_Entities (Id : E; V : S) is
begin
- pragma Assert
- (Ekind (Id) = E_Package or else Ekind (Id) = E_Generic_Package);
+ pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
Set_List14 (Id, V);
end Set_Shadow_Entities;
procedure Set_Size_Check_Code (Id : E; V : N) is
begin
- pragma Assert (Ekind (Id) = E_Constant or else Ekind (Id) = E_Variable);
+ pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
Set_Node19 (Id, V);
end Set_Size_Check_Code;
procedure Set_Wrapped_Entity (Id : E; V : E) is
begin
- pragma Assert ((Ekind (Id) = E_Function
- or else Ekind (Id) = E_Procedure)
- and then Is_Primitive_Wrapper (Id));
+ pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ and then Is_Primitive_Wrapper (Id));
Set_Node27 (Id, V);
end Set_Wrapped_Entity;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Entry_Family
- or else Ekind (Id) = E_Subprogram_Body
- or else Ekind (Id) = E_Subprogram_Type);
+ or else Ekind_In (Id, E_Entry_Family,
+ E_Subprogram_Body,
+ E_Subprogram_Type));
if Ekind (Id) = E_Enumeration_Literal then
return Empty;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind (Id) = E_Entry_Family
- or else Ekind (Id) = E_Subprogram_Body
- or else Ekind (Id) = E_Subprogram_Type);
+ or else Ekind_In (Id, E_Entry_Family,
+ E_Subprogram_Body,
+ E_Subprogram_Type));
if Ekind (Id) = E_Enumeration_Literal then
return Empty;
function Is_Discriminal (Id : E) return B is
begin
- return
- (Ekind (Id) = E_Constant
- or else Ekind (Id) = E_In_Parameter)
- and then Present (Discriminal_Link (Id));
+ return (Ekind_In (Id, E_Constant, E_In_Parameter)
+ and then Present (Discriminal_Link (Id)));
end Is_Discriminal;
----------------------
function Is_Prival (Id : E) return B is
begin
- return
- (Ekind (Id) = E_Constant
- or else Ekind (Id) = E_Variable)
- and then Present (Prival_Link (Id));
+ return (Ekind_In (Id, E_Constant, E_Variable)
+ and then Present (Prival_Link (Id)));
end Is_Prival;
----------------------------
begin
return Ekind (Id) in String_Kind
or else (Is_Array_Type (Id)
- and then Number_Dimensions (Id) = 1
- and then Is_Character_Type (Component_Type (Id)));
+ and then Number_Dimensions (Id) = 1
+ and then Is_Character_Type (Component_Type (Id)));
end Is_String_Type;
-------------------------
function Is_Wrapper_Package (Id : E) return B is
begin
return (Ekind (Id) = E_Package
- and then Present (Related_Instance (Id)));
+ and then Present (Related_Instance (Id)));
end Is_Wrapper_Package;
--------------------
begin
Comp_Id := Next_Entity (Id);
while Present (Comp_Id) loop
- exit when Ekind (Comp_Id) = E_Component
- or else
- Ekind (Comp_Id) = E_Discriminant;
+ exit when Ekind_In (Comp_Id, E_Component, E_Discriminant);
Comp_Id := Next_Entity (Comp_Id);
end loop;
D := Next_Entity (D);
if No (D)
or else (Ekind (D) /= E_Discriminant
- and then not Is_Itype (D))
+ and then not Is_Itype (D))
then
return Empty;
end if;
begin
N := Next_Entity (N);
while Present (N) loop
- exit when Ekind (N) = E_Component
- or else
- Ekind (N) = E_Discriminant;
+ exit when Ekind_In (N, E_Component, E_Discriminant);
N := Next_Entity (N);
end loop;
end Proc_Next_Component_Or_Discriminant;