-- The routine should be invoked on a body [stub] with aspects
pragma Assert (Has_Aspects (N));
- pragma Assert (Nkind (N) in N_Body_Stub
- or else Nkind_In (N, N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body));
+ pragma Assert
+ (Nkind (N) in N_Body_Stub | N_Entry_Body | N_Package_Body |
+ N_Protected_Body | N_Subprogram_Body | N_Task_Body);
-- Look through all aspects and see whether they can be applied to a
-- body [stub].
-- Note: It is better to use Is_Single_Concurrent_Type_Declaration
-- here, but Aspects and Sem_Util have incompatible licenses.
- elsif Nkind_In
- (Original_Node (From), N_Single_Protected_Declaration,
- N_Single_Task_Declaration)
+ elsif Nkind (Original_Node (From)) in
+ N_Single_Protected_Declaration | N_Single_Task_Declaration
then
Asp_Id := Get_Aspect_Id (Asp);
return N_To_E (Nodes.Table (E + 1).Nkind);
end Ekind;
- --------------
- -- Ekind_In --
- --------------
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10;
- end Ekind_In;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind;
- V11 : Entity_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10 or else
- T = V11;
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3, V4);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3, V4, V5);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8, V9);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind) return Boolean
- is
- begin
- return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8, V9, V10);
- end Ekind_In;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind;
- V11 : Entity_Kind) return Boolean
- is
- begin
- return
- Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11);
- end Ekind_In;
-
------------------
-- Error_Posted --
------------------
return Nodes.Table (N).Nkind;
end Nkind;
- --------------
- -- Nkind_In --
- --------------
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9, V10);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9, V10,
- V11);
- end Nkind_In;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind;
- V12 : Node_Kind;
- V13 : Node_Kind;
- V14 : Node_Kind;
- V15 : Node_Kind;
- V16 : Node_Kind;
- V17 : Node_Kind) return Boolean
- is
- begin
- return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9, V10,
- V11, V12, V13, V14, V15, V16, V17);
- end Nkind_In;
-
--------
-- No --
--------
function Sloc (N : Node_Id) return Source_Ptr;
pragma Inline (Sloc);
- ---------------------
- -- Node_Kind Tests --
- ---------------------
-
- -- These are like the functions in Sinfo, but the first argument is a
- -- Node_Id, and the tested field is Nkind (N).
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind) return Boolean;
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind) return Boolean;
-
- -- 12..16-parameter versions are not yet needed
-
- function Nkind_In
- (N : Node_Id;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind;
- V12 : Node_Kind;
- V13 : Node_Kind;
- V14 : Node_Kind;
- V15 : Node_Kind;
- V16 : Node_Kind;
- V17 : Node_Kind) return Boolean;
-
- pragma Inline (Nkind_In);
- -- Inline all above functions
-
- -----------------------
- -- Entity_Kind_Tests --
- -----------------------
-
- -- Utility functions to test whether an Entity_Kind value, either given
- -- directly as the first argument, or the Ekind field of an Entity given
- -- as the first argument, matches any of the given list of Entity_Kind
- -- values. Return True if any match, False if no match.
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (E : Entity_Id;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind;
- V11 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind) return Boolean;
-
- function Ekind_In
- (T : Entity_Kind;
- V1 : Entity_Kind;
- V2 : Entity_Kind;
- V3 : Entity_Kind;
- V4 : Entity_Kind;
- V5 : Entity_Kind;
- V6 : Entity_Kind;
- V7 : Entity_Kind;
- V8 : Entity_Kind;
- V9 : Entity_Kind;
- V10 : Entity_Kind;
- V11 : Entity_Kind) return Boolean;
-
- pragma Inline (Ekind_In);
- -- Inline all above functions
-
-----------------------------
-- Entity Access Functions --
-----------------------------
-- Nothing to do for Rem/Mod/Plus (overflow not possible, the check
-- for zero-divide is a divide check, not an overflow check).
- if Nkind_In (N, N_Op_Rem, N_Op_Mod, N_Op_Plus) then
+ if Nkind (N) in N_Op_Rem | N_Op_Mod | N_Op_Plus then
return;
end if;
end if;
if Ada_Version >= Ada_2012
and then not Present (Param_Ent)
and then Is_Entity_Name (N)
- and then Ekind_In (Entity (N), E_Constant, E_Variable)
+ and then Ekind (Entity (N)) in E_Constant | E_Variable
and then Present (Effective_Extra_Accessibility (Entity (N)))
then
Param_Ent := Entity (N);
-- deepest type level so as to appropriatly handle the rules for
-- RM 3.10.2 (10.1/3).
- if Ekind_In (Scope (Param_Ent), E_Function,
- E_Operator,
- E_Subprogram_Type)
+ if Ekind (Scope (Param_Ent))
+ in E_Function | E_Operator | E_Subprogram_Type
and then Present (Extra_Accessibility_Of_Result (Scope (Param_Ent)))
then
Type_Level :=
-- there is no overflow check that starts from that parent node,
-- so apply check now.
- if Nkind_In (P, N_If_Expression, N_Case_Expression)
+ if Nkind (P) in N_If_Expression | N_Case_Expression
and then not Is_Signed_Integer_Arithmetic_Op (Parent (P))
then
null;
-- mode IN OUT - Pre, Post => Formal'Valid[_Scalars]
-- mode OUT - Post => Formal'Valid[_Scalars]
- if Ekind_In (Formal, E_In_Parameter, E_In_Out_Parameter) then
+ if Ekind (Formal) in E_In_Parameter | E_In_Out_Parameter then
Add_Validity_Check (Formal, Name_Precondition, False);
end if;
- if Ekind_In (Formal, E_In_Out_Parameter, E_Out_Parameter) then
+ if Ekind (Formal) in E_In_Out_Parameter | E_Out_Parameter then
Add_Validity_Check (Formal, Name_Postcondition, False);
end if;
(Typ, New_Occurrence_Of (Entity (N), Sloc (N))));
return;
- elsif Nkind_In (N, N_Aggregate, N_Extension_Aggregate) then
+ elsif Nkind (N) in N_Aggregate | N_Extension_Aggregate then
-- If the expression is an aggregate in an assignment, apply the
-- check to the LHS after the assignment, rather than create a
function Left_Expression (Op : Node_Id) return Node_Id is
LE : Node_Id := Left_Opnd (Op);
begin
- while Nkind_In (LE, N_Qualified_Expression,
- N_Type_Conversion,
- N_Expression_With_Actions)
+ while Nkind (LE) in N_Qualified_Expression
+ | N_Type_Conversion
+ | N_Expression_With_Actions
loop
LE := Expression (LE);
end loop;
begin
pragma Assert
- (Nkind_In (Kind, N_Component_Declaration,
- N_Discriminant_Specification,
- N_Function_Specification,
- N_Object_Declaration,
- N_Parameter_Specification));
+ (Kind in N_Component_Declaration
+ | N_Discriminant_Specification
+ | N_Function_Specification
+ | N_Object_Declaration
+ | N_Parameter_Specification);
if Kind = N_Function_Specification then
Typ := Etype (Defining_Entity (N));
-- Likewise for Abs/Minus, the only case where the operation can
-- overflow is when the operand is the largest negative number.
- elsif Nkind_In (N, N_Op_Abs, N_Op_Minus) then
+ elsif Nkind (N) in N_Op_Abs | N_Op_Minus then
Determine_Range
(Right_Opnd (N), OK, Lo, Hi, Assume_Valid => True);
-- Do not set range check flag if parent is assignment statement or
-- object declaration with Suppress_Assignment_Checks flag set
- if Nkind_In (Parent (N), N_Assignment_Statement, N_Object_Declaration)
+ if Nkind (Parent (N)) in N_Assignment_Statement | N_Object_Declaration
and then Suppress_Assignment_Checks (Parent (N))
then
return;
-- If this is an indirect or dispatching call, get signature
-- from the subprogram type.
- if Nkind_In (P, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ if Nkind (P) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
E := Get_Called_Entity (P);
L := Parameter_Associations (P);
-- Integer and character literals always have valid values, where
-- appropriate these will be range checked in any case.
- elsif Nkind_In (Expr, N_Integer_Literal, N_Character_Literal) then
+ elsif Nkind (Expr) in N_Integer_Literal | N_Character_Literal then
return True;
-- If we have a type conversion or a qualification of a known valid
-- value, then the result will always be valid.
- elsif Nkind_In (Expr, N_Type_Conversion, N_Qualified_Expression) then
+ elsif Nkind (Expr) in N_Type_Conversion | N_Qualified_Expression then
return Expr_Known_Valid (Expression (Expr));
-- Case of expression is a non-floating-point operator. In this case we
begin
P := Prefix (N);
while not Is_Entity_Name (P) loop
- if not Nkind_In (P, N_Selected_Component,
- N_Indexed_Component)
- then
+ if Nkind (P) not in N_Selected_Component | N_Indexed_Component then
return Empty;
end if;
if Nkind (A_Idx) = N_Range then
A_Range := A_Idx;
- elsif Nkind_In (A_Idx, N_Identifier, N_Expanded_Name) then
+ elsif Nkind (A_Idx) in N_Identifier | N_Expanded_Name then
A_Range := Scalar_Range (Entity (A_Idx));
if Nkind (A_Range) = N_Subtype_Indication then
-- the target.
and then not
- (Nkind_In (N, N_Integer_Literal, N_Real_Literal, N_Character_Literal)
+ (Nkind (N) in
+ N_Integer_Literal | N_Real_Literal | N_Character_Literal
or else
(Is_Entity_Name (N)
and then Ekind (Entity (N)) = E_Enumeration_Literal))
-- need to be called while elaboration is taking place.
elsif Is_Controlled (Tag_Typ)
- and then Nam_In (Chars (Subp_Id), Name_Adjust,
- Name_Finalize,
- Name_Initialize)
+ and then
+ Chars (Subp_Id) in Name_Adjust | Name_Finalize | Name_Initialize
then
return;
end if;
-- Refined_Post
elsif Is_Entry_Body (Id) then
- if Nam_In (Prag_Nam, Name_Refined_Depends, Name_Refined_Global) then
+ if Prag_Nam in Name_Refined_Depends | Name_Refined_Global then
Add_Classification;
elsif Prag_Nam = Name_Refined_Post then
-- Volatile_Function
elsif Is_Entry_Declaration (Id)
- or else Ekind_In (Id, E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Procedure)
+ or else Ekind (Id) in E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Procedure
then
- if Nam_In (Prag_Nam, Name_Attach_Handler, Name_Interrupt_Handler)
- and then Ekind_In (Id, E_Generic_Procedure, E_Procedure)
+ if Prag_Nam in Name_Attach_Handler | Name_Interrupt_Handler
+ and then Ekind (Id) in E_Generic_Procedure | E_Procedure
then
Add_Classification;
- elsif Nam_In (Prag_Nam, Name_Depends,
- Name_Extensions_Visible,
- Name_Global)
+ elsif Prag_Nam in Name_Depends
+ | Name_Extensions_Visible
+ | Name_Global
then
Add_Classification;
elsif Prag_Nam = Name_Volatile_Function
- and then Ekind_In (Id, E_Function, E_Generic_Function)
+ and then Ekind (Id) in E_Function | E_Generic_Function
then
Add_Classification;
- elsif Nam_In (Prag_Nam, Name_Contract_Cases, Name_Test_Case) then
+ elsif Prag_Nam in Name_Contract_Cases | Name_Test_Case then
Add_Contract_Test_Case;
- elsif Nam_In (Prag_Nam, Name_Postcondition, Name_Precondition) then
+ elsif Prag_Nam in Name_Postcondition | Name_Precondition then
Add_Pre_Post_Condition;
-- The pragma is not a proper contract item
-- Part_Of (instantiation only)
elsif Is_Package_Or_Generic_Package (Id) then
- if Nam_In (Prag_Nam, Name_Abstract_State,
- Name_Initial_Condition,
- Name_Initializes)
+ if Prag_Nam in Name_Abstract_State
+ | Name_Initial_Condition
+ | Name_Initializes
then
Add_Classification;
elsif Is_Type (Id) then
declare
Is_OK : constant Boolean :=
- Nam_In (Prag_Nam, Name_Async_Readers,
- Name_Async_Writers,
- Name_Effective_Reads,
- Name_Effective_Writes)
+ Prag_Nam in Name_Async_Readers
+ | Name_Async_Writers
+ | Name_Effective_Reads
+ | Name_Effective_Writes
or else (Ekind (Id) = E_Task_Type
- and Nam_In (Prag_Nam, Name_Part_Of,
- Name_Depends,
- Name_Global))
+ and Prag_Nam in Name_Part_Of
+ | Name_Depends
+ | Name_Global)
or else (Ekind (Id) = E_Protected_Type
and Prag_Nam = Name_Part_Of);
begin
-- Refined_Post
elsif Ekind (Id) = E_Subprogram_Body then
- if Nam_In (Prag_Nam, Name_Refined_Depends, Name_Refined_Global) then
+ if Prag_Nam in Name_Refined_Depends | Name_Refined_Global then
Add_Classification;
- elsif Nam_In (Prag_Nam, Name_Postcondition,
- Name_Precondition,
- Name_Refined_Post)
+ elsif Prag_Nam in Name_Postcondition
+ | Name_Precondition
+ | Name_Refined_Post
then
Add_Pre_Post_Condition;
-- Refined_Global
elsif Ekind (Id) = E_Task_Body then
- if Nam_In (Prag_Nam, Name_Refined_Depends, Name_Refined_Global) then
+ if Prag_Nam in Name_Refined_Depends | Name_Refined_Global then
Add_Classification;
-- The pragma is not a proper contract item
-- Part_Of
elsif Ekind (Id) = E_Variable then
- if Nam_In (Prag_Nam, Name_Async_Readers,
- Name_Async_Writers,
- Name_Constant_After_Elaboration,
- Name_Depends,
- Name_Effective_Reads,
- Name_Effective_Writes,
- Name_Global,
- Name_No_Caching,
- Name_Part_Of)
+ if Prag_Nam in Name_Async_Readers
+ | Name_Async_Writers
+ | Name_Constant_After_Elaboration
+ | Name_Depends
+ | Name_Effective_Reads
+ | Name_Effective_Writes
+ | Name_Global
+ | Name_No_Caching
+ | Name_Part_Of
then
Add_Classification;
-- Entry or subprogram declarations
- if Nkind_In (Decl, N_Abstract_Subprogram_Declaration,
- N_Entry_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration)
+ if Nkind (Decl) in N_Abstract_Subprogram_Declaration
+ | N_Entry_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Subprogram_Declaration
then
declare
Subp_Id : constant Entity_Id := Defining_Entity (Decl);
-- Entry or subprogram bodies
- elsif Nkind_In (Decl, N_Entry_Body, N_Subprogram_Body) then
+ elsif Nkind (Decl) in N_Entry_Body | N_Subprogram_Body then
Analyze_Entry_Or_Subprogram_Body_Contract (Defining_Entity (Decl));
-- Objects
-- Protected units
- elsif Nkind_In (Decl, N_Protected_Type_Declaration,
- N_Single_Protected_Declaration)
+ elsif Nkind (Decl) in N_Protected_Type_Declaration
+ | N_Single_Protected_Declaration
then
Analyze_Protected_Contract (Defining_Entity (Decl));
-- Task units
- elsif Nkind_In (Decl, N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ elsif Nkind (Decl) in N_Single_Task_Declaration
+ | N_Task_Type_Declaration
then
Analyze_Task_Contract (Defining_Entity (Decl));
end;
end if;
- if Nkind_In (Decl, N_Full_Type_Declaration,
- N_Private_Type_Declaration,
- N_Task_Type_Declaration,
- N_Protected_Type_Declaration,
- N_Formal_Type_Declaration)
+ if Nkind (Decl) in N_Full_Type_Declaration
+ | N_Private_Type_Declaration
+ | N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
+ | N_Formal_Type_Declaration
then
Analyze_Type_Contract (Defining_Identifier (Decl));
end if;
-- subprograms.
if SPARK_Mode = On
- and then Ekind_In (Body_Id, E_Function, E_Generic_Function)
+ and then Ekind (Body_Id) in E_Function | E_Generic_Function
and then Comes_From_Source (Spec_Id)
and then not Is_Volatile_Function (Body_Id)
then
-- processed after the analysis of the related subprogram declaration.
if SPARK_Mode = On
- and then Ekind_In (Subp_Id, E_Function, E_Generic_Function)
+ and then Ekind (Subp_Id) in E_Function | E_Generic_Function
and then Comes_From_Source (Subp_Id)
and then not Is_Volatile_Function (Subp_Id)
then
function Causes_Contract_Freezing (N : Node_Id) return Boolean is
begin
- return Nkind_In (N, N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub,
- N_Task_Body);
+ return Nkind (N) in
+ N_Entry_Body | N_Package_Body | N_Protected_Body |
+ N_Subprogram_Body | N_Subprogram_Body_Stub | N_Task_Body;
end Causes_Contract_Freezing;
----------------------
-- Entry or subprogram declarations
- elsif Nkind_In (Decl, N_Abstract_Subprogram_Declaration,
- N_Entry_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration)
+ elsif Nkind (Decl) in N_Abstract_Subprogram_Declaration
+ | N_Entry_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Subprogram_Declaration
then
Analyze_Entry_Or_Subprogram_Contract
(Subp_Id => Defining_Entity (Decl),
-- Protected units
- elsif Nkind_In (Decl, N_Protected_Type_Declaration,
- N_Single_Protected_Declaration)
+ elsif Nkind (Decl) in N_Protected_Type_Declaration
+ | N_Single_Protected_Declaration
then
Analyze_Protected_Contract (Defining_Entity (Decl));
-- Task units
- elsif Nkind_In (Decl, N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ elsif Nkind (Decl) in N_Single_Task_Declaration
+ | N_Task_Type_Declaration
then
Analyze_Task_Contract (Defining_Entity (Decl));
end if;
- if Nkind_In (Decl, N_Full_Type_Declaration,
- N_Private_Type_Declaration,
- N_Task_Type_Declaration,
- N_Protected_Type_Declaration,
- N_Formal_Type_Declaration)
+ if Nkind (Decl) in N_Full_Type_Declaration
+ | N_Private_Type_Declaration
+ | N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
+ | N_Formal_Type_Declaration
then
Analyze_Type_Contract (Defining_Identifier (Decl));
end if;
function Access_Disp_Table (Id : E) return L is
begin
- pragma Assert (Ekind_In (Id, E_Record_Subtype,
- E_Record_Type,
- E_Record_Type_With_Private));
+ pragma Assert (Ekind (Id) in E_Record_Subtype
+ | E_Record_Type
+ | E_Record_Type_With_Private);
return Elist16 (Implementation_Base_Type (Id));
end Access_Disp_Table;
function Access_Disp_Table_Elab_Flag (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Record_Subtype,
- E_Record_Type,
- E_Record_Type_With_Private));
+ pragma Assert (Ekind (Id) in E_Record_Subtype
+ | E_Record_Type
+ | E_Record_Type_With_Private);
return Node30 (Implementation_Base_Type (Id));
end Access_Disp_Table_Elab_Flag;
function Activation_Record_Component (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Constant,
- E_In_Parameter,
- E_In_Out_Parameter,
- E_Loop_Parameter,
- E_Out_Parameter,
- E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant
+ | E_In_Parameter
+ | E_In_Out_Parameter
+ | E_Loop_Parameter
+ | E_Out_Parameter
+ | E_Variable);
return Node31 (Id);
end Activation_Record_Component;
function Actual_Subtype (Id : E) return E is
begin
pragma Assert
- (Ekind_In (Id, E_Constant, E_Variable, E_Generic_In_Out_Parameter)
+ (Ekind (Id) in 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_In (Id, E_Loop_Parameter,
- E_Constant,
- E_Exception,
- E_Variable));
+ or else Ekind (Id) in E_Loop_Parameter
+ | E_Constant
+ | E_Exception
+ | E_Variable);
return Uint14 (Id);
end Alignment;
function Anonymous_Masters (Id : E) return L is
begin
- pragma Assert (Ekind_In (Id, E_Function,
- E_Package,
- E_Procedure,
- E_Subprogram_Body));
+ pragma Assert (Ekind (Id) in E_Function
+ | E_Package
+ | E_Procedure
+ | E_Subprogram_Body);
return Elist29 (Id);
end Anonymous_Masters;
function Anonymous_Object (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Protected_Type, E_Task_Type));
+ pragma Assert (Ekind (Id) in E_Protected_Type | E_Task_Type);
return Node30 (Id);
end Anonymous_Object;
function BIP_Initialization_Call (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
return Node29 (Id);
end BIP_Initialization_Call;
function Cloned_Subtype (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Class_Wide_Subtype));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Component | E_Discriminant);
return Uint11 (Id);
end Component_Bit_Offset;
function Component_Clause (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Component | E_Discriminant);
return Node13 (Id);
end Component_Clause;
function Corresponding_Record_Component (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Component | E_Discriminant);
return Node21 (Id);
end Corresponding_Record_Component;
function Dispatch_Table_Wrappers (Id : E) return L is
begin
- pragma Assert (Ekind_In (Id, E_Record_Type,
- E_Record_Subtype));
+ pragma Assert (Ekind (Id) in E_Record_Type | E_Record_Subtype);
return Elist26 (Implementation_Base_Type (Id));
end Dispatch_Table_Wrappers;
function DT_Position (Id : E) return U is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Node16 (Id);
end DTC_Entity;
pragma Assert
(Is_Subprogram (Id)
or else
- Ekind_In (Id, E_Entry, E_Entry_Family, E_Package)
+ Ekind (Id) in E_Entry | E_Entry_Family | E_Package
or else
Is_Generic_Unit (Id));
return Node13 (Id);
pragma Assert
(Is_Subprogram (Id)
or else
- Ekind_In (Id, E_Entry, E_Entry_Family, E_Package)
+ Ekind (Id) in E_Entry | E_Entry_Family | E_Package
or else
Is_Generic_Unit (Id));
return Flag174 (Id);
function Encapsulating_State (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Abstract_State, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Abstract_State | E_Constant | E_Variable);
return Node32 (Id);
end Encapsulating_State;
function Contains_Ignored_Ghost_Code (Id : E) return B is
begin
pragma Assert
- (Ekind_In (Id, E_Block,
- E_Function,
- E_Generic_Function,
- E_Generic_Package,
- E_Generic_Procedure,
- E_Package,
- E_Package_Body,
- E_Procedure,
- E_Subprogram_Body));
+ (Ekind (Id) in E_Block
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Package
+ | E_Generic_Procedure
+ | E_Package
+ | E_Package_Body
+ | E_Procedure
+ | E_Subprogram_Body);
return Flag279 (Id);
end Contains_Ignored_Ghost_Code;
function Contract (Id : E) return N is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Type, -- concurrent types
- E_Task_Body,
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Type -- concurrent types
+ | E_Task_Body
+ | E_Task_Type
or else
- Ekind_In (Id, E_Constant, -- objects
- E_Variable)
+ Ekind (Id) in E_Constant -- objects
+ | E_Variable
or else
- Ekind_In (Id, E_Entry, -- overloadable
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Entry -- overloadable
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body)
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body
or else
Is_Type (Id) -- types
or else
function Equivalent_Type (Id : E) return E is
begin
pragma Assert
- (Ekind_In (Id, E_Class_Wide_Type,
- E_Class_Wide_Subtype,
- E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type,
- E_Access_Subprogram_Type,
- E_Exception_Type));
+ (Ekind (Id) in E_Class_Wide_Type
+ | E_Class_Wide_Subtype
+ | E_Access_Subprogram_Type
+ | E_Access_Protected_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
+ | E_Exception_Type);
return Node18 (Id);
end Equivalent_Type;
function Extra_Accessibility (Id : E) return E is
begin
pragma Assert
- (Is_Formal (Id) or else Ekind_In (Id, E_Variable, E_Constant));
+ (Is_Formal (Id) or else Ekind (Id) in E_Variable | E_Constant);
return Node13 (Id);
end Extra_Accessibility;
function Extra_Accessibility_Of_Result (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Operator, E_Subprogram_Type));
+ pragma Assert
+ (Ekind (Id) in E_Function | E_Operator | E_Subprogram_Type);
return Node19 (Id);
end Extra_Accessibility_Of_Result;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind_In (Id, E_Entry_Family,
- E_Subprogram_Body,
- E_Subprogram_Type));
+ or else Ekind (Id) in E_Entry_Family
+ | E_Subprogram_Body
+ | E_Subprogram_Type);
return Node28 (Id);
end Extra_Formals;
function Finalizer (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
+ pragma Assert (Ekind (Id) in E_Package | E_Package_Body);
return Node28 (Id);
end Finalizer;
function Has_Missing_Return (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Generic_Function));
+ pragma Assert (Ekind (Id) in E_Function | E_Generic_Function);
return Flag142 (Id);
end Has_Missing_Return;
function Ignore_SPARK_Mode_Pragmas (Id : E) return B is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Body, -- concurrent types
- E_Protected_Type,
- E_Task_Body,
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Body -- concurrent types
+ | E_Protected_Type
+ | E_Task_Body
+ | E_Task_Type
or else
- Ekind_In (Id, E_Entry, -- overloadable
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Entry -- overloadable
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body));
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body);
return Flag301 (Id);
end Ignore_SPARK_Mode_Pragmas;
function Initialization_Statements (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
return Node28 (Id);
end Initialization_Statements;
function Is_Called (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Procedure, E_Function, E_Package));
+ pragma Assert (Ekind (Id) in E_Procedure | E_Function | E_Package);
return Flag102 (Id);
end Is_Called;
function Is_DIC_Procedure (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag132 (Id);
end Is_DIC_Procedure;
function Is_Finalized_Transient (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Loop_Parameter, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Loop_Parameter | E_Variable);
return Flag252 (Id);
end Is_Finalized_Transient;
function Is_Generic_Actual_Subprogram (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag274 (Id);
end Is_Generic_Actual_Subprogram;
function Is_Ignored_Transient (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Loop_Parameter, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Loop_Parameter | E_Variable);
return Flag295 (Id);
end Is_Ignored_Transient;
function Is_Initial_Condition_Procedure (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag302 (Id);
end Is_Initial_Condition_Procedure;
function Is_Inlined_Always (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag1 (Id);
end Is_Inlined_Always;
function Is_Invariant_Procedure (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag257 (Id);
end Is_Invariant_Procedure;
function Is_Partial_Invariant_Procedure (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag292 (Id);
end Is_Partial_Invariant_Procedure;
function Is_Predicate_Function (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag255 (Id);
end Is_Predicate_Function;
function Is_Predicate_Function_M (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag256 (Id);
end Is_Predicate_Function_M;
function Is_Primitive_Wrapper (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag195 (Id);
end Is_Primitive_Wrapper;
function Is_Private_Primitive (Id : E) return B is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Flag245 (Id);
end Is_Private_Primitive;
function Last_Aggregate_Assignment (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
return Node30 (Id);
end Last_Aggregate_Assignment;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind_In (Id, E_Subprogram_Type, E_Entry_Family));
+ or else Ekind (Id) in 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_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Component | E_Discriminant);
return Uint8 (Id);
end Normalized_First_Bit;
function Normalized_Position (Id : E) return U is
begin
- pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Component | E_Discriminant);
return Uint14 (Id);
end Normalized_Position;
function Normalized_Position_Max (Id : E) return U is
begin
- pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Constant, E_Variable));
+ (Is_Type (Id) or else Ekind (Id) in 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_In (Id, E_Constant, E_Variable));
+ (Is_Type (Id) or else Ekind (Id) in E_Constant | E_Variable);
return Flag242 (Id);
end Optimize_Alignment_Time;
function Original_Record_Component (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Void, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Void | E_Component | E_Discriminant);
return Node22 (Id);
end Original_Record_Component;
function Part_Of_Constituents (Id : E) return L is
begin
- pragma Assert (Ekind_In (Id, E_Abstract_State, E_Variable));
+ pragma Assert (Ekind (Id) in E_Abstract_State | E_Variable);
return Elist10 (Id);
end Part_Of_Constituents;
function Postconditions_Proc (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure));
+ pragma Assert
+ (Ekind (Id) in E_Entry | E_Entry_Family | E_Function | E_Procedure);
return Node14 (Id);
end Postconditions_Proc;
function Predicated_Parent (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Array_Subtype,
- E_Record_Subtype,
- E_Record_Subtype_With_Private));
+ pragma Assert
+ (Ekind (Id) in E_Array_Subtype |
+ E_Record_Subtype |
+ E_Record_Subtype_With_Private);
return Node38 (Id);
end Predicated_Parent;
function Prival_Link (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
return Node20 (Id);
end Prival_Link;
function Protected_Subprogram (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
return Node39 (Id);
end Protected_Subprogram;
function Protection_Object (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure));
+ pragma Assert
+ (Ekind (Id) in 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) in Type_Kind
- or else Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in Type_Kind | E_Constant | E_Variable);
return Node24 (Id);
end Related_Expression;
function Related_Instance (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
+ pragma Assert (Ekind (Id) in E_Package | E_Package_Body);
return Node15 (Id);
end Related_Instance;
function Related_Type (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Component, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Component | E_Constant | E_Variable);
return Node27 (Id);
end Related_Type;
function Size_Check_Code (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
return Node19 (Id);
end Size_Check_Code;
function SPARK_Aux_Pragma (Id : E) return N is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Type, -- concurrent types
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Type -- concurrent types
+ | E_Task_Type
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body));
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body);
return Node41 (Id);
end SPARK_Aux_Pragma;
function SPARK_Aux_Pragma_Inherited (Id : E) return B is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Type, -- concurrent types
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Type -- concurrent types
+ | E_Task_Type
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body));
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body);
return Flag266 (Id);
end SPARK_Aux_Pragma_Inherited;
function SPARK_Pragma (Id : E) return N is
begin
pragma Assert
- (Ekind_In (Id, E_Constant, -- objects
- E_Variable)
+ (Ekind (Id) in E_Constant -- objects
+ | E_Variable
or else
- Ekind_In (Id, E_Abstract_State, -- overloadable
- E_Entry,
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Abstract_State -- overloadable
+ | E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body)
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body
or else
- Ekind (Id) = E_Void -- special purpose
+ Ekind (Id) = E_Void -- special purpose
or else
- Ekind_In (Id, E_Protected_Body, -- types
- E_Task_Body)
+ Ekind (Id) in E_Protected_Body -- types
+ | E_Task_Body
or else
Is_Type (Id));
return Node40 (Id);
function SPARK_Pragma_Inherited (Id : E) return B is
begin
pragma Assert
- (Ekind_In (Id, E_Constant, -- objects
- E_Variable)
+ (Ekind (Id) in E_Constant -- objects
+ | E_Variable
or else
- Ekind_In (Id, E_Abstract_State, -- overloadable
- E_Entry,
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Abstract_State -- overloadable
+ | E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body)
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body
or else
- Ekind (Id) = E_Void -- special purpose
+ Ekind (Id) = E_Void -- special purpose
or else
- Ekind_In (Id, E_Protected_Body, -- types
- E_Task_Body)
+ Ekind (Id) in E_Protected_Body -- types
+ | E_Task_Body
or else
Is_Type (Id));
return Flag265 (Id);
function Status_Flag_Or_Transient_Decl (Id : E) return N is
begin
- pragma Assert (Ekind_In (Id, E_Constant,
- E_Loop_Parameter,
- E_Variable));
+ pragma Assert
+ (Ekind (Id) in E_Constant | E_Loop_Parameter | E_Variable);
return Node15 (Id);
end Status_Flag_Or_Transient_Decl;
function Thunk_Entity (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure
and then Is_Thunk (Id));
return Node31 (Id);
end Thunk_Entity;
function Wrapped_Entity (Id : E) return E is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure
and then Is_Primitive_Wrapper (Id));
return Node27 (Id);
end Wrapped_Entity;
procedure Set_Anonymous_Masters (Id : E; V : L) is
begin
- pragma Assert (Ekind_In (Id, E_Function,
- E_Package,
- E_Procedure,
- E_Subprogram_Body));
+ pragma Assert
+ (Ekind (Id)
+ in E_Function | E_Package | E_Procedure | E_Subprogram_Body);
Set_Elist29 (Id, V);
end Set_Anonymous_Masters;
procedure Set_Anonymous_Object (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Protected_Type, E_Task_Type));
+ pragma Assert (Ekind (Id) in E_Protected_Type | E_Task_Type);
Set_Node30 (Id, V);
end Set_Anonymous_Object;
procedure Set_Activation_Record_Component (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Constant,
- E_In_Parameter,
- E_In_Out_Parameter,
- E_Loop_Parameter,
- E_Out_Parameter,
- E_Variable));
+ pragma Assert
+ (Ekind (Id) in E_Constant
+ | E_In_Parameter
+ | E_In_Out_Parameter
+ | E_Loop_Parameter
+ | E_Out_Parameter
+ | E_Variable);
Set_Node31 (Id, V);
end Set_Activation_Record_Component;
procedure Set_Actual_Subtype (Id : E; V : E) is
begin
pragma Assert
- (Ekind_In (Id, E_Constant, E_Variable, E_Generic_In_Out_Parameter)
+ (Ekind (Id) in E_Constant | E_Variable | E_Generic_In_Out_Parameter
or else Is_Formal (Id));
Set_Node17 (Id, V);
end Set_Actual_Subtype;
begin
pragma Assert (Is_Type (Id)
or else Is_Formal (Id)
- or else Ekind_In (Id, E_Loop_Parameter,
- E_Constant,
- E_Exception,
- E_Variable));
+ or else Ekind (Id) in E_Loop_Parameter
+ | E_Constant
+ | E_Exception
+ | E_Variable);
Set_Uint14 (Id, V);
end Set_Alignment;
procedure Set_BIP_Initialization_Call (Id : E; V : N) is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
Set_Node29 (Id, V);
end Set_BIP_Initialization_Call;
procedure Set_Cloned_Subtype (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Class_Wide_Subtype));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Component | E_Discriminant);
Set_Node13 (Id, V);
end Set_Component_Clause;
procedure Set_Contains_Ignored_Ghost_Code (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind_In (Id, E_Block,
- E_Function,
- E_Generic_Function,
- E_Generic_Package,
- E_Generic_Procedure,
- E_Package,
- E_Package_Body,
- E_Procedure,
- E_Subprogram_Body));
+ (Ekind (Id) in E_Block
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Package
+ | E_Generic_Procedure
+ | E_Package
+ | E_Package_Body
+ | E_Procedure
+ | E_Subprogram_Body);
Set_Flag279 (Id, V);
end Set_Contains_Ignored_Ghost_Code;
procedure Set_Contract (Id : E; V : N) is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Type, -- concurrent types
- E_Task_Body,
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Type -- concurrent types
+ | E_Task_Body
+ | E_Task_Type
or else
- Ekind_In (Id, E_Constant, -- objects
- E_Variable)
+ Ekind (Id) in E_Constant -- objects
+ | E_Variable
or else
- Ekind_In (Id, E_Entry, -- overloadable
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Entry -- overloadable
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body)
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body
or else
- Is_Type (Id) -- types
+ Is_Type (Id) -- types
or else
- Ekind (Id) = E_Void); -- special purpose
+ Ekind (Id) = E_Void); -- special purpose
Set_Node34 (Id, V);
end Set_Contract;
procedure Set_Corresponding_Protected_Entry (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Void, E_Subprogram_Body));
+ pragma Assert (Ekind (Id) in E_Void | E_Subprogram_Body);
Set_Node18 (Id, V);
end Set_Corresponding_Protected_Entry;
procedure Set_Corresponding_Record_Component (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in E_Component | E_Discriminant);
Set_Node21 (Id, V);
end Set_Corresponding_Record_Component;
procedure Set_Delay_Subprogram_Descriptors (Id : E; V : B := True) is
begin
pragma Assert
- (Is_Subprogram (Id) or else Ekind_In (Id, E_Package, E_Package_Body));
+ (Is_Subprogram (Id) or else Ekind (Id) in 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_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Node16 (Id, V);
end Set_DTC_Entity;
pragma Assert
(Is_Subprogram (Id)
or else
- Ekind_In (Id, E_Entry, E_Entry_Family, E_Package)
+ Ekind (Id) in E_Entry | E_Entry_Family | E_Package
or else
Is_Generic_Unit (Id));
Set_Node13 (Id, V);
pragma Assert
(Is_Subprogram (Id)
or else
- Ekind_In (Id, E_Entry, E_Entry_Family, E_Package)
+ Ekind (Id) in E_Entry | E_Entry_Family | E_Package
or else
Is_Generic_Unit (Id));
Set_Flag174 (Id, V);
procedure Set_Encapsulating_State (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Abstract_State, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Abstract_State | E_Constant | E_Variable);
Set_Node32 (Id, V);
end Set_Encapsulating_State;
procedure Set_Equivalent_Type (Id : E; V : E) is
begin
pragma Assert
- (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));
+ (Ekind (Id) in 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;
procedure Set_Extra_Accessibility (Id : E; V : E) is
begin
pragma Assert
- (Is_Formal (Id) or else Ekind_In (Id, E_Variable, E_Constant));
+ (Is_Formal (Id) or else Ekind (Id) in E_Variable | E_Constant);
Set_Node13 (Id, V);
end Set_Extra_Accessibility;
procedure Set_Extra_Accessibility_Of_Result (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Operator, E_Subprogram_Type));
+ pragma Assert
+ (Ekind (Id) in E_Function | E_Operator | E_Subprogram_Type);
Set_Node19 (Id, V);
end Set_Extra_Accessibility_Of_Result;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind_In (Id, E_Entry_Family,
- E_Subprogram_Body,
- E_Subprogram_Type));
+ or else Ekind (Id) in E_Entry_Family
+ | E_Subprogram_Body
+ | E_Subprogram_Type);
Set_Node28 (Id, V);
end Set_Extra_Formals;
procedure Set_Finalizer (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
+ pragma Assert (Ekind (Id) in E_Package | E_Package_Body);
Set_Node28 (Id, V);
end Set_Finalizer;
procedure Set_From_Limited_With (Id : E; V : B := True) is
begin
pragma Assert
- (Is_Type (Id) or else Ekind_In (Id, E_Abstract_State, E_Package));
+ (Is_Type (Id) or else Ekind (Id) in E_Abstract_State | E_Package);
Set_Flag159 (Id, V);
end Set_From_Limited_With;
procedure Set_Has_Expanded_Contract (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure));
+ pragma Assert
+ (Ekind (Id) in E_Entry | E_Entry_Family | E_Function | E_Procedure);
Set_Flag240 (Id, V);
end Set_Has_Expanded_Contract;
procedure Set_Has_Initial_Value (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Variable, E_Out_Parameter));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Function, E_Generic_Function));
+ pragma Assert (Ekind (Id) in E_Function | E_Generic_Function);
Set_Flag142 (Id, V);
end Set_Has_Missing_Return;
procedure Set_Has_Out_Or_In_Out_Parameter (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind_In (Id, E_Entry, E_Entry_Family)
+ (Ekind (Id) in E_Entry | E_Entry_Family
or else Is_Subprogram_Or_Generic_Subprogram (Id));
Set_Flag110 (Id, V);
end Set_Has_Out_Or_In_Out_Parameter;
procedure Set_Ignore_SPARK_Mode_Pragmas (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Body, -- concurrent types
- E_Protected_Type,
- E_Task_Body,
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Body -- concurrent types
+ | E_Protected_Type
+ | E_Task_Body
+ | E_Task_Type
or else
- Ekind_In (Id, E_Entry, -- overloadable
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Entry -- overloadable
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body));
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body);
Set_Flag301 (Id, V);
end Set_Ignore_SPARK_Mode_Pragmas;
pragma Assert
(Is_Internal (Id)
and then Is_Hidden (Id)
- and then (Ekind_In (Id, E_Procedure, E_Function)));
+ and then (Ekind (Id) in E_Procedure | E_Function));
Set_Node25 (Id, V);
end Set_Interface_Alias;
-- an aggregate used as the initialization expression for an object
-- declaration, and this occurs before the Ekind for the object is set.
- pragma Assert (Ekind_In (Id, E_Void, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Void | E_Constant | E_Variable);
Set_Node28 (Id, V);
end Set_Initialization_Statements;
procedure Set_Is_Called (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Procedure, E_Function, E_Package));
+ pragma Assert (Ekind (Id) in E_Procedure | E_Function | E_Package);
Set_Flag102 (Id, V);
end Set_Is_Called;
procedure Set_Is_Finalized_Transient (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Loop_Parameter, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Loop_Parameter | E_Variable);
Set_Flag252 (Id, V);
end Set_Is_Finalized_Transient;
procedure Set_Is_Generic_Actual_Subprogram (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Flag274 (Id, V);
end Set_Is_Generic_Actual_Subprogram;
procedure Set_Is_Hidden_Non_Overridden_Subpgm (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Flag2 (Id, V);
end Set_Is_Hidden_Non_Overridden_Subpgm;
procedure Set_Is_Ignored_Transient (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Loop_Parameter, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Loop_Parameter | E_Variable);
Set_Flag295 (Id, V);
end Set_Is_Ignored_Transient;
procedure Set_Is_Initial_Condition_Procedure (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Flag302 (Id, V);
end Set_Is_Initial_Condition_Procedure;
procedure Set_Is_Inlined_Always (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Flag1 (Id, V);
end Set_Is_Inlined_Always;
procedure Set_Is_Param_Block_Component_Type (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Void, E_General_Access_Type));
+ pragma Assert (Ekind (Id) in E_Void | E_General_Access_Type);
Set_Flag215 (Id, V);
end Set_Is_Param_Block_Component_Type;
procedure Set_Is_Predicate_Function_M (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Flag256 (Id, V);
end Set_Is_Predicate_Function_M;
procedure Set_Is_Primitive_Wrapper (Id : E; V : B := True) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Flag245 (Id, V);
end Set_Is_Private_Primitive;
begin
pragma Assert
(Is_Type (Id)
- or else Ekind_In (Id, E_Exception,
- E_Variable,
- E_Constant,
- E_Void));
+ or else
+ Ekind (Id) in 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_In (Id, E_Component, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Component | E_Constant | E_Variable);
Set_Flag78 (Id, V);
end Set_Is_Tag;
procedure Set_Is_Uplevel_Referenced_Entity (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind_In (Id, E_Constant, E_Loop_Parameter, E_Variable)
+ (Ekind (Id) in E_Constant | E_Loop_Parameter | E_Variable
or else Is_Formal (Id)
or else Is_Type (Id));
Set_Flag283 (Id, V);
procedure Set_Last_Aggregate_Assignment (Id : E; V : N) is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
Set_Node30 (Id, V);
end Set_Last_Aggregate_Assignment;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind_In (Id, E_Subprogram_Type, E_Entry_Family));
+ or else Ekind (Id) in E_Subprogram_Type | E_Entry_Family);
Set_Flag22 (Id, V);
end Set_Needs_No_Actuals;
begin
pragma Assert
(Ekind (Id) in Incomplete_Kind
- or else Ekind_In (Id, E_Abstract_State, E_Class_Wide_Type));
+ or else Ekind (Id) in E_Abstract_State | E_Class_Wide_Type);
Set_Node19 (Id, V);
end Set_Non_Limited_View;
procedure Set_Normalized_First_Bit (Id : E; V : U) is
begin
- pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Constant, E_Variable));
+ (Is_Type (Id) or else Ekind (Id) in 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_In (Id, E_Constant, E_Variable));
+ (Is_Type (Id) or else Ekind (Id) in E_Constant | E_Variable);
Set_Flag242 (Id, V);
end Set_Optimize_Alignment_Time;
procedure Set_Original_Protected_Subprogram (Id : E; V : N) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Node41 (Id, V);
end Set_Original_Protected_Subprogram;
procedure Set_Original_Record_Component (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Void, E_Component, E_Discriminant));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Void, E_Generic_Package, E_Package));
+ pragma Assert (Ekind (Id) in E_Void | E_Generic_Package | E_Package);
Set_Node26 (Id, V);
end Set_Package_Instantiation;
procedure Set_Part_Of_Constituents (Id : E; V : L) is
begin
- pragma Assert (Ekind_In (Id, E_Abstract_State, E_Variable));
+ pragma Assert (Ekind (Id) in E_Abstract_State | E_Variable);
Set_Elist10 (Id, V);
end Set_Part_Of_Constituents;
procedure Set_Postconditions_Proc (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure));
+ pragma Assert
+ (Ekind (Id) in E_Entry | E_Entry_Family | E_Function | E_Procedure);
Set_Node14 (Id, V);
end Set_Postconditions_Proc;
procedure Set_Predicated_Parent (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Array_Subtype,
- E_Record_Subtype,
- E_Record_Subtype_With_Private));
+ pragma Assert (Ekind (Id) in E_Array_Subtype
+ | E_Record_Subtype
+ | E_Record_Subtype_With_Private);
Set_Node38 (Id, V);
end Set_Predicated_Parent;
procedure Set_Prival_Link (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
Set_Node20 (Id, V);
end Set_Prival_Link;
procedure Set_Protected_Subprogram (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure);
Set_Node39 (Id, V);
end Set_Protected_Subprogram;
procedure Set_Protection_Object (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure));
+ pragma Assert (Ekind (Id) in E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Procedure);
Set_Node23 (Id, V);
end Set_Protection_Object;
procedure Set_Related_Expression (Id : E; V : N) is
begin
- pragma Assert (Ekind (Id) in Type_Kind
- or else Ekind_In (Id, E_Constant, E_Variable, E_Void));
+ pragma Assert
+ (Ekind (Id) in Type_Kind | E_Constant | E_Variable | E_Void);
Set_Node24 (Id, V);
end Set_Related_Expression;
procedure Set_Related_Instance (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
+ pragma Assert (Ekind (Id) in 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_In (Id, E_Component, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Component | E_Constant | E_Variable);
Set_Node27 (Id, V);
end Set_Related_Type;
procedure Set_Size_Check_Code (Id : E; V : N) is
begin
- pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant | E_Variable);
Set_Node19 (Id, V);
end Set_Size_Check_Code;
procedure Set_SPARK_Aux_Pragma (Id : E; V : N) is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Type, -- concurrent types
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Type -- concurrent types
+ | E_Task_Type
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body));
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body);
Set_Node41 (Id, V);
end Set_SPARK_Aux_Pragma;
procedure Set_SPARK_Aux_Pragma_Inherited (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind_In (Id, E_Protected_Type, -- concurrent types
- E_Task_Type)
+ (Ekind (Id) in E_Protected_Type -- concurrent types
+ | E_Task_Type
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body));
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body);
Set_Flag266 (Id, V);
end Set_SPARK_Aux_Pragma_Inherited;
procedure Set_SPARK_Pragma (Id : E; V : N) is
begin
pragma Assert
- (Ekind_In (Id, E_Constant, -- objects
- E_Variable)
+ (Ekind (Id) in E_Constant -- objects
+ | E_Variable
or else
- Ekind_In (Id, E_Abstract_State, -- overloadable
- E_Entry,
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Abstract_State -- overloadable
+ | E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body)
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body
or else
- Ekind (Id) = E_Void -- special purpose
+ Ekind (Id) = E_Void -- special purpose
or else
- Ekind_In (Id, E_Protected_Body, -- types
- E_Task_Body)
+ Ekind (Id) in E_Protected_Body -- types
+ | E_Task_Body
or else
Is_Type (Id));
Set_Node40 (Id, V);
procedure Set_SPARK_Pragma_Inherited (Id : E; V : B := True) is
begin
pragma Assert
- (Ekind_In (Id, E_Constant, -- objects
- E_Variable)
+ (Ekind (Id) in E_Constant -- objects
+ | E_Variable
or else
- Ekind_In (Id, E_Abstract_State, -- overloadable
- E_Entry,
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Operator,
- E_Procedure,
- E_Subprogram_Body)
+ Ekind (Id) in E_Abstract_State -- overloadable
+ | E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Operator
+ | E_Procedure
+ | E_Subprogram_Body
or else
- Ekind_In (Id, E_Generic_Package, -- packages
- E_Package,
- E_Package_Body)
+ Ekind (Id) in E_Generic_Package -- packages
+ | E_Package
+ | E_Package_Body
or else
- Ekind (Id) = E_Void -- special purpose
+ Ekind (Id) = E_Void -- special purpose
or else
- Ekind_In (Id, E_Protected_Body, -- types
- E_Task_Body)
+ Ekind (Id) in E_Protected_Body -- types
+ | E_Task_Body
or else
Is_Type (Id));
Set_Flag265 (Id, V);
procedure Set_Status_Flag_Or_Transient_Decl (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Constant,
- E_Loop_Parameter,
- E_Variable));
+ pragma Assert (Ekind (Id) in E_Constant
+ | E_Loop_Parameter
+ | E_Variable);
Set_Node15 (Id, V);
end Set_Status_Flag_Or_Transient_Decl;
procedure Set_Thunk_Entity (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure
and then Is_Thunk (Id));
Set_Node31 (Id, V);
end Set_Thunk_Entity;
procedure Set_Wrapped_Entity (Id : E; V : E) is
begin
- pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
+ pragma Assert (Ekind (Id) in E_Function | E_Procedure
and then Is_Primitive_Wrapper (Id));
Set_Node27 (Id, V);
end Set_Wrapped_Entity;
end if;
loop
- if Nkind_In (P, N_Selected_Component, N_Expanded_Name)
+ if Nkind (P) in N_Selected_Component | N_Expanded_Name
or else (Nkind (P) = N_Defining_Program_Unit_Name
and then Is_Child_Unit (Id))
then
Comp_Id := First_Entity (Id);
while Present (Comp_Id) loop
- exit when Ekind_In (Comp_Id, E_Component, E_Discriminant);
+ exit when Ekind (Comp_Id) in E_Component | E_Discriminant;
Next_Entity (Comp_Id);
end loop;
pragma Assert
(Is_Generic_Subprogram (Id)
or else Is_Overloadable (Id)
- or else Ekind_In (Id, E_Entry_Family,
- E_Subprogram_Body,
- E_Subprogram_Type));
+ or else Ekind (Id) in E_Entry_Family
+ | E_Subprogram_Body
+ | E_Subprogram_Type);
if Ekind (Id) = E_Enumeration_Literal then
return Empty;
pragma Assert
(Is_Generic_Subprogram (Id)
or else Is_Overloadable (Id)
- or else Ekind_In (Id, E_Entry_Family,
- E_Subprogram_Body,
- E_Subprogram_Type));
+ or else Ekind (Id) in E_Entry_Family
+ | E_Subprogram_Body
+ | E_Subprogram_Type);
if Ekind (Id) = E_Enumeration_Literal then
return Empty;
function Is_Constant_Object (Id : E) return B is
begin
- return Ekind_In (Id, E_Constant, E_In_Parameter, E_Loop_Parameter);
+ return Ekind (Id) in E_Constant | E_In_Parameter | E_Loop_Parameter;
end Is_Constant_Object;
-------------------
function Is_Discriminal (Id : E) return B is
begin
- return Ekind_In (Id, E_Constant, E_In_Parameter)
+ return Ekind (Id) in E_Constant | E_In_Parameter
and then Present (Discriminal_Link (Id));
end Is_Discriminal;
function Is_Elaboration_Target (Id : Entity_Id) return Boolean is
begin
return
- Ekind_In (Id, E_Constant, E_Package, E_Variable)
+ Ekind (Id) in E_Constant | E_Package | E_Variable
or else Is_Entry (Id)
or else Is_Generic_Unit (Id)
or else Is_Subprogram (Id)
function Is_Package_Or_Generic_Package (Id : E) return B is
begin
- return Ekind_In (Id, E_Generic_Package, E_Package);
+ return Ekind (Id) in E_Generic_Package | E_Package;
end Is_Package_Or_Generic_Package;
---------------------
function Is_Prival (Id : E) return B is
begin
- return Ekind_In (Id, E_Constant, E_Variable)
+ return Ekind (Id) in E_Constant | E_Variable
and then Present (Prival_Link (Id));
end Is_Prival;
begin
pragma Assert
(Is_Overloadable (Id)
- or else Ekind_In (Id, E_Entry_Family,
- E_Subprogram_Body,
- E_Subprogram_Type));
+ or else Ekind (Id) in E_Entry_Family
+ | E_Subprogram_Body
+ | E_Subprogram_Type);
if Ekind (Id) = E_Enumeration_Literal then
return Empty;
begin
Comp_Id := Next_Entity (Id);
while Present (Comp_Id) loop
- exit when Ekind_In (Comp_Id, E_Component, E_Discriminant);
+ exit when Ekind (Comp_Id) in E_Component | E_Discriminant;
Next_Entity (Comp_Id);
end loop;
then
Typ := Full_View (Id);
- elsif Ekind_In (Id, E_Array_Subtype,
- E_Record_Subtype,
- E_Record_Subtype_With_Private)
+ elsif Ekind (Id) in E_Array_Subtype
+ | E_Record_Subtype
+ | E_Record_Subtype_With_Private
and then Present (Predicated_Parent (Id))
then
Typ := Predicated_Parent (Id);
begin
N := Next_Entity (N);
while Present (N) loop
- exit when Ekind_In (N, E_Component, E_Discriminant);
+ exit when Ekind (N) in E_Component | E_Discriminant;
N := Next_Entity (N);
end loop;
end Proc_Next_Component_Or_Discriminant;
exit when Nkind (P) not in N_Subexpr;
end loop;
- if Nkind_In (P, N_Pragma_Argument_Association,
- N_Component_Association,
- N_Discriminant_Association,
- N_Generic_Association,
- N_Parameter_Association)
+ if Nkind (P) in N_Pragma_Argument_Association
+ | N_Component_Association
+ | N_Discriminant_Association
+ | N_Generic_Association
+ | N_Parameter_Association
then
Set_Error_Posted (Parent (P));
end if;
-- Strip away any conversions from the expression as they simply
-- qualify the real expression.
- while Nkind_In (Expr, N_Unchecked_Type_Conversion, N_Type_Conversion)
+ while Nkind (Expr) in N_Unchecked_Type_Conversion | N_Type_Conversion
loop
Expr := Expression (Expr);
end loop;
Expr : Node_Id := Original_Node (N);
begin
- while Nkind_In (Expr, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ while Nkind (Expr) in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
loop
Expr := Original_Node (Expression (Expr));
end loop;
-- the initialization expression denotes. An unanalyzed function
-- call may appear as an identifier or an indexed component.
- if Nkind_In (Expr, N_Function_Call,
- N_Identifier,
- N_Indexed_Component)
+ if Nkind (Expr) in N_Function_Call
+ | N_Identifier
+ | N_Indexed_Component
and then not Analyzed (Expr)
then
Preanalyze_And_Resolve (Expr, Comp_Typ);
-- default initialized components (otherwise Expr_Q is not present).
if Present (Expr_Q)
- and then Nkind_In (Expr_Q, N_Aggregate, N_Extension_Aggregate)
+ and then Nkind (Expr_Q) in N_Aggregate | N_Extension_Aggregate
then
-- At this stage the Expression may not have been analyzed yet
-- because the array aggregate code has not been updated to use
-- the initialization expression denotes. Unanalyzed function calls
-- may appear as identifiers or indexed components.
- if Nkind_In (Init_Expr, N_Function_Call,
- N_Identifier,
- N_Indexed_Component)
+ if Nkind (Init_Expr) in N_Function_Call
+ | N_Identifier
+ | N_Indexed_Component
and then not Analyzed (Init_Expr)
then
Preanalyze_And_Resolve (Init_Expr, Comp_Typ);
-- qualified).
elsif Is_Limited_Type (Etype (Ancestor))
- and then Nkind_In (Unqualify (Ancestor), N_Aggregate,
- N_Extension_Aggregate)
+ and then Nkind (Unqualify (Ancestor)) in
+ N_Aggregate | N_Extension_Aggregate
then
Ancestor_Is_Expression := True;
-- If the ancestor part is an aggregate, force its full
-- expansion, which was delayed.
- if Nkind_In (Unqualify (Ancestor), N_Aggregate,
- N_Extension_Aggregate)
+ if Nkind (Unqualify (Ancestor)) in
+ N_Aggregate | N_Extension_Aggregate
then
Set_Analyzed (Ancestor, False);
Set_Analyzed (Expression (Ancestor), False);
Parent_Node : Node_Id;
begin
- pragma Assert (Nkind_In (N, N_Aggregate, N_Extension_Aggregate));
+ pragma Assert (Nkind (N) in N_Aggregate | N_Extension_Aggregate);
pragma Assert (not Is_Static_Dispatch_Table_Aggregate (N));
pragma Assert (Is_Record_Type (Typ));
-- The check just above may have replaced the aggregate with a CE
- if Nkind_In (N, N_Aggregate, N_Extension_Aggregate) then
+ if Nkind (N) in N_Aggregate | N_Extension_Aggregate then
Target_Expr := New_Copy_Tree (Lhs);
Insert_Actions (Parent_Node,
Build_Record_Aggr_Code (N, Typ, Target_Expr));
if Is_Entity_Name (N) then
return True;
- elsif Nkind_In (N, N_Explicit_Dereference, N_Selected_Component)
+ elsif Nkind (N) in N_Explicit_Dereference | N_Selected_Component
and then Safe_Left_Hand_Side (Prefix (N))
then
return True;
if Needs_Finalization (Typ)
and then Is_Entity_Name (Target)
and then Present (Entity (Target))
- and then Ekind_In (Entity (Target), E_Constant, E_Variable)
+ and then Ekind (Entity (Target)) in E_Constant | E_Variable
then
Set_Last_Aggregate_Assignment (Entity (Target), Last (Aggr_Code));
end if;
begin
Aggr := N;
while Present (Parent (Aggr))
- and then Nkind_In (Parent (Aggr), N_Aggregate,
- N_Component_Association)
+ and then Nkind (Parent (Aggr)) in
+ N_Aggregate | N_Component_Association
loop
Aggr := Parent (Aggr);
end loop;
-- aggregates for C++ imported types must be expanded.
elsif Ada_Version >= Ada_2005 and then Is_Limited_View (Typ) then
- if not Nkind_In (Parent (N), N_Component_Association,
- N_Object_Declaration)
+ if Nkind (Parent (N)) not in
+ N_Component_Association | N_Object_Declaration
then
Convert_To_Assignments (N, Typ);
begin
R := Get_Referenced_Object (N);
- while Nkind_In (R, N_Indexed_Component, N_Selected_Component, N_Slice)
+ while Nkind (R) in N_Indexed_Component | N_Selected_Component | N_Slice
loop
R := Get_Referenced_Object (Prefix (R));
end loop;
Expr : Node_Id;
begin
- pragma Assert (Nkind_In (N, N_Aggregate, N_Extension_Aggregate));
+ pragma Assert (Nkind (N) in N_Aggregate | N_Extension_Aggregate);
if No (Comps) then
return False;
Expr := Expression (C);
if Present (Expr)
- and then Nkind_In (Expr, N_Aggregate, N_Extension_Aggregate)
+ and then Nkind (Expr) in N_Aggregate | N_Extension_Aggregate
and then Has_Default_Init_Comps (Expr)
then
return True;
Kind := Nkind (Node);
end if;
- if not Nkind_In (Kind, N_Aggregate, N_Extension_Aggregate) then
+ if Kind not in N_Aggregate | N_Extension_Aggregate then
return False;
else
return Expansion_Delayed (Node);
if Needs_Finalization (Typ)
and then Is_Entity_Name (Target)
and then Present (Entity (Target))
- and then Ekind_In (Entity (Target), E_Constant, E_Variable)
+ and then Ekind (Entity (Target)) in E_Constant | E_Variable
then
Set_Last_Aggregate_Assignment (Entity (Target), Last (Aggr_Code));
end if;
function Aggr_Context (N : Node_Id) return Node_Id is
Result : Node_Id := Parent (N);
begin
- if Nkind_In (Result, N_Qualified_Expression,
- N_Type_Conversion,
- N_Unchecked_Type_Conversion,
- N_If_Expression,
- N_Case_Expression,
- N_Component_Association,
- N_Aggregate)
+ if Nkind (Result) in N_Qualified_Expression
+ | N_Type_Conversion
+ | N_Unchecked_Type_Conversion
+ | N_If_Expression
+ | N_Case_Expression
+ | N_Component_Association
+ | N_Aggregate
then
Result := Aggr_Context (Result);
end if;
function Is_Static_Component (Nod : Node_Id) return Boolean is
begin
- if Nkind_In (Nod, N_Integer_Literal, N_Real_Literal) then
+ if Nkind (Nod) in N_Integer_Literal | N_Real_Literal then
return True;
elsif Is_Entity_Name (Nod)
-- Comes_From_Source is not correct because this will eliminate the
-- components within the corresponding record of a protected type.
- if Nam_In (Field_Nam, Name_uObject,
- Name_uParent,
- Name_uTag)
- then
+ if Field_Nam in Name_uObject | Name_uParent | Name_uTag then
null;
-- Do not process fields without any scalar components
if Is_Protected_Self_Reference (Pref)
and then not
- (Nkind_In (Parent (N), N_Index_Or_Discriminant_Constraint,
- N_Discriminant_Association)
+ (Nkind (Parent (N)) in N_Index_Or_Discriminant_Constraint
+ | N_Discriminant_Association
and then Nkind (Parent (Parent (Parent (Parent (N))))) =
N_Component_Definition)
begin
Obj_Name := N;
- while Nkind_In (Obj_Name, N_Selected_Component,
- N_Indexed_Component,
- N_Slice)
+ while Nkind (Obj_Name) in N_Selected_Component
+ | N_Indexed_Component
+ | N_Slice
loop
Obj_Name := Prefix (Obj_Name);
end loop;
begin
Subp := Current_Scope;
- while Ekind_In (Subp, E_Loop, E_Block) loop
+ while Ekind (Subp) in E_Loop | E_Block loop
Subp := Scope (Subp);
end loop;
Cnam := Name_Last;
end if;
- if not Nkind_In (P, N_Assignment_Statement, N_Object_Declaration)
+ if Nkind (P) not in N_Assignment_Statement | N_Object_Declaration
or else not Suppress_Assignment_Checks (P)
then
Insert_Action (N,
return True;
elsif not Has_Fully_Qualified_Name (E) then
- if Nam_In (Chars (E), Name_uSize, Name_uAlignment, Name_uAssign)
+ if Chars (E) in Name_uSize | Name_uAlignment | Name_uAssign
or else
(Chars (E) = Name_Op_Eq
and then Etype (First_Formal (E)) = Etype (Last_Formal (E)))
-- objects of controlled types, for example. We do not want to clean up
-- the return object.
- if not Nkind_In (Parent (N), N_Accept_Statement,
- N_Extended_Return_Statement,
- N_Package_Body)
+ if Nkind (Parent (N)) not in N_Accept_Statement
+ | N_Extended_Return_Statement
+ | N_Package_Body
and then not Delay_Cleanups (Current_Scope)
and then not Is_Thunk (Current_Scope)
then
and then not (Nkind (Parent (N)) = N_Attribute_Reference
and then
- (Nam_In (Attribute_Name (Parent (N)),
- Name_Asm_Input,
- Name_Asm_Output)
+ (Attribute_Name (Parent (N)) in Name_Asm_Input
+ | Name_Asm_Output
or else Prefix (Parent (N)) = N))
-
then
-- Case of Current_Value is a compile time known value
-- Set Atomic_Sync_Required if necessary for atomic variable. Note that
-- this processing does NOT apply to Volatile_Full_Access variables.
- if Nkind_In (N, N_Identifier, N_Expanded_Name)
+ if Nkind (N) in N_Identifier | N_Expanded_Name
and then Ekind (E) = E_Variable
and then (Is_Atomic (E) or else Is_Atomic (Etype (E)))
then
-- ??? passing a formal as actual for a mode IN formal is
-- considered as an assignment?
- if Nkind_In (Parent (N), N_Procedure_Call_Statement,
- N_Entry_Call_Statement)
+ if Nkind (Parent (N)) in
+ N_Procedure_Call_Statement | N_Entry_Call_Statement
or else (Nkind (Parent (N)) = N_Assignment_Statement
and then N = Name (Parent (N)))
then
-- which case there is an implicit dereference, and the formal itself
-- is not being assigned to).
- elsif Nkind_In (Parent (N), N_Selected_Component,
- N_Indexed_Component,
- N_Slice)
+ elsif Nkind (Parent (N)) in
+ N_Selected_Component | N_Indexed_Component | N_Slice
and then N = Prefix (Parent (N))
and then not Is_Access_Type (Etype (N))
and then In_Assignment_Context (Parent (N))
begin
-- Simple reference case
- if Nkind_In (N, N_Identifier, N_Expanded_Name) then
+ if Nkind (N) in N_Identifier | N_Expanded_Name then
if Is_Formal (Entity (N)) then
return Entity (N);
-- traversing the expression. ???
if Kind = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Default), Name_Unchecked_Access,
- Name_Unrestricted_Access)
+ and then Attribute_Name (Default) in Name_Unchecked_Access
+ | Name_Unrestricted_Access
and then Is_Entity_Name (Prefix (Default))
and then Is_Type (Entity (Prefix (Default)))
and then Entity (Prefix (Default)) = Rec_Type
end if;
if Needs_Finalization (Typ)
- and then not (Nkind_In (Kind, N_Aggregate, N_Extension_Aggregate))
+ and then Kind not in N_Aggregate | N_Extension_Aggregate
and then not Is_Build_In_Place_Function_Call (Exp)
then
Adj_Call :=
elsif Ekind (Scope (Id)) = E_Record_Type
and then Present (Corresponding_Concurrent_Type (Scope (Id)))
- and then Nam_In (Chars (Id), Name_uCPU,
- Name_uDispatching_Domain,
- Name_uPriority,
- Name_uSecondary_Stack_Size)
+ and then Chars (Id) in Name_uCPU
+ | Name_uDispatching_Domain
+ | Name_uPriority
+ | Name_uSecondary_Stack_Size
then
declare
Exp : Node_Id;
and then Building_Static_Dispatch_Tables
and then Is_Library_Level_Entity (Def_Id)
and then Is_Library_Level_Tagged_Type (Base_Typ)
- and then Ekind_In (Base_Typ, E_Record_Type,
- E_Protected_Type,
- E_Task_Type)
+ and then Ekind (Base_Typ) in E_Record_Type
+ | E_Protected_Type
+ | E_Task_Type
and then not Has_Dispatch_Table (Base_Typ)
then
declare
and then not Restriction_Active (No_Secondary_Stack)
and then (Restriction_Active (No_Implicit_Heap_Allocations)
or else Restriction_Active (No_Implicit_Task_Allocations))
- and then not (Ekind_In (Ekind (Typ), E_Array_Type, E_Array_Subtype)
+ and then not (Ekind (Typ) in E_Array_Type | E_Array_Subtype
and then (Has_Init_Expression (N)))
then
declare
-- Do not duplicate the work of Process_Range_Expr_In_Decl in Sem_Ch3
- if Nkind_In (Parent (N), N_Constrained_Array_Definition, N_Slice)
- and then Nkind (Parent (Parent (N))) /= N_Full_Type_Declaration
- and then Nkind (Parent (Parent (N))) /= N_Object_Declaration
+ if Nkind (Parent (N)) in N_Constrained_Array_Definition | N_Slice
+ and then Nkind (Parent (Parent (N))) not in
+ N_Full_Type_Declaration | N_Object_Declaration
then
Apply_Range_Check (Ran, Typ);
end if;
-- See GNAT Pool packages in the Run-Time for more details
- elsif Ekind_In (Def_Id, E_Access_Type, E_General_Access_Type) then
+ elsif Ekind (Def_Id) in E_Access_Type | E_General_Access_Type then
declare
Loc : constant Source_Ptr := Sloc (N);
Desig_Type : constant Entity_Id := Designated_Type (Def_Id);
-- If the initial value is null or an aggregate, qualify it with the
-- underlying type in order to provide a proper context.
- if Nkind_In (Expr, N_Aggregate, N_Null) then
+ if Nkind (Expr) in N_Aggregate | N_Null then
Expr :=
Make_Qualified_Expression (Loc,
Subtype_Mark => New_Occurrence_Of (Under_Typ, Loc),
-- we avoid never-ending loops expanding them, and we also ensure
-- the back end never receives nonbinary modular type expressions.
- if Nkind_In (Nkind (N), N_Op_And, N_Op_Or, N_Op_Xor) then
+ if Nkind (N) in N_Op_And | N_Op_Or | N_Op_Xor then
Set_Left_Opnd (Op_Expr,
Unchecked_Convert_To (Standard_Unsigned,
New_Copy_Tree (Left_Opnd (N))));
-- lifetime of the object must be associated with the named access
-- type. Use the finalization-related attributes of this type.
- if Nkind_In (Parent (N), N_Type_Conversion,
- N_Unchecked_Type_Conversion)
- and then Ekind_In (Etype (Parent (N)), E_Access_Subtype,
- E_Access_Type,
- E_General_Access_Type)
+ if Nkind (Parent (N)) in N_Type_Conversion
+ | N_Unchecked_Type_Conversion
+ and then Ekind (Etype (Parent (N))) in E_Access_Subtype
+ | E_Access_Type
+ | E_General_Access_Type
then
Rel_Typ := Etype (Parent (N));
else
New_Occurrence_Of
(Entity (Nam), Sloc (Nam)), T);
- elsif Nkind_In (Nam, N_Indexed_Component,
- N_Selected_Component)
+ elsif Nkind (Nam) in N_Indexed_Component
+ | N_Selected_Component
and then Is_Entity_Name (Prefix (Nam))
then
Decls :=
-- to which it applies has a static predicate aspect, do not expand,
-- because it will be converted to the proper predicate form later.
- if Ekind_In (Current_Scope, E_Function, E_Procedure)
+ if Ekind (Current_Scope) in E_Function | E_Procedure
and then Is_Predicate_Function (Current_Scope)
then
In_Predicate := True;
-- to consider???
loop
- if Nkind_In (Obj_Ref, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ if Nkind (Obj_Ref) in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
then
Obj_Ref := Expression (Obj_Ref);
else
return;
elsif Nkind (Parnt) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Parnt), Name_Address,
- Name_Bit,
- Name_Size)
+ and then Attribute_Name (Parnt) in Name_Address
+ | Name_Bit
+ | Name_Size
and then Prefix (Parnt) = Child
then
return;
-- records because there may be padding or undefined fields.
elsif Unnest_Subprogram_Mode
- and then Ekind_In (Typl, E_Class_Wide_Type,
- E_Class_Wide_Subtype,
- E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type,
- E_Access_Subprogram_Type,
- E_Exception_Type)
+ and then Ekind (Typl) in E_Class_Wide_Type
+ | E_Class_Wide_Subtype
+ | E_Access_Subprogram_Type
+ | E_Access_Protected_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
+ | E_Exception_Type
and then Present (Equivalent_Type (Typl))
and then Is_Record_Type (Equivalent_Type (Typl))
then
-- too tricky to combine the overflow check at the parent level.
if not Ovflo
- and then Nkind_In (Parent (N), N_Op_Divide, N_Op_Multiply)
+ and then Nkind (Parent (N)) in N_Op_Divide | N_Op_Multiply
then
declare
P : constant Node_Id := Parent (N);
if Is_Elementary_Type (Typ)
and then Sloc (Entity (N)) = Standard_Location
- and then not (Ekind_In (Typ, E_Class_Wide_Type,
- E_Class_Wide_Subtype,
- E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type,
- E_Access_Subprogram_Type,
- E_Exception_Type)
+ and then not (Ekind (Typ) in E_Class_Wide_Type
+ | E_Class_Wide_Subtype
+ | E_Access_Subprogram_Type
+ | E_Access_Protected_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
+ | E_Exception_Type
and then Present (Equivalent_Type (Typ))
and then Is_Record_Type (Equivalent_Type (Typ)))
then
-- Special case the negation of a binary operation
- elsif Nkind_In (Opnd, N_Op_And, N_Op_Or, N_Op_Xor)
+ elsif Nkind (Opnd) in N_Op_And | N_Op_Or | N_Op_Xor
and then Safe_In_Place_Array_Op
(Name (Parent (N)), Left_Opnd (Opnd), Right_Opnd (Opnd))
then
-- since these are additional cases that do can appear on
-- procedure actuals.
- elsif Nkind_In (Par, N_Type_Conversion,
- N_Parameter_Association,
- N_Qualified_Expression)
+ elsif Nkind (Par) in N_Type_Conversion
+ | N_Parameter_Association
+ | N_Qualified_Expression
then
Par := Parent (Par);
function Has_Extra_Accessibility (Id : Entity_Id) return Boolean is
begin
- if Is_Formal (Id) or else Ekind_In (Id, E_Constant, E_Variable) then
+ if Is_Formal (Id) or else Ekind (Id) in E_Constant | E_Variable then
return Present (Effective_Extra_Accessibility (Id));
else
return False;
or else Attribute_Name (Original_Node (N)) = Name_Access)
then
if not Comes_From_Source (N)
- and then Nkind_In (Parent (N), N_Function_Call,
- N_Parameter_Association,
- N_Procedure_Call_Statement)
+ and then Nkind (Parent (N)) in N_Function_Call
+ | N_Parameter_Association
+ | N_Procedure_Call_Statement
and then Is_Interface (Designated_Type (Target_Type))
and then Is_Class_Wide_Type (Designated_Type (Target_Type))
then
exit when No (Comp);
- exit when Ekind_In (Comp, E_Discriminant, E_Component)
+ exit when Ekind (Comp) in E_Discriminant | E_Component
and then not (
-- Skip inherited components
-- value and unary negation. Unary "+" is omitted since it is a
-- no-op and thus can't overflow.
- and then Nkind_In (Operand, N_Op_Abs,
- N_Op_Add,
- N_Op_Divide,
- N_Op_Expon,
- N_Op_Minus,
- N_Op_Multiply,
- N_Op_Subtract);
+ and then Nkind (Operand) in
+ N_Op_Abs | N_Op_Add | N_Op_Divide | N_Op_Expon |
+ N_Op_Minus | N_Op_Multiply | N_Op_Subtract;
end Integer_Promotion_Possible;
------------------------------
-- transient object.
begin
- pragma Assert (Nkind_In (Expr, N_Case_Expression,
- N_Expression_With_Actions,
- N_If_Expression));
+ pragma Assert (Nkind (Expr) in N_Case_Expression
+ | N_Expression_With_Actions
+ | N_If_Expression);
-- When the context is a Boolean evaluation, all three nodes capture the
-- result of their computation in a local temporary:
-- <or>
-- Hook := Obj_Id'Unrestricted_Access;
- if Ekind_In (Obj_Id, E_Constant, E_Variable)
+ if Ekind (Obj_Id) in E_Constant | E_Variable
and then Present (Last_Aggregate_Assignment (Obj_Id))
then
Hook_Insert := Last_Aggregate_Assignment (Obj_Id);
elsif Is_Entity_Name (Op) then
return Is_Unaliased (Op);
- elsif Nkind_In (Op, N_Indexed_Component, N_Selected_Component) then
+ elsif Nkind (Op) in N_Indexed_Component | N_Selected_Component then
return Is_Unaliased (Prefix (Op));
elsif Nkind (Op) = N_Slice then
L_Prefix_Comp : constant Boolean :=
-- True if the left-hand side is a slice of a component or slice
Nkind (Name (N)) = N_Slice
- and then Nkind_In (Prefix (Name (N)),
- N_Selected_Component,
- N_Indexed_Component,
- N_Slice);
+ and then Nkind (Prefix (Name (N))) in
+ N_Selected_Component | N_Indexed_Component | N_Slice;
R_Prefix_Comp : constant Boolean :=
-- Likewise for the right-hand side
Nkind (Expression (N)) = N_Slice
- and then Nkind_In (Prefix (Expression (N)),
- N_Selected_Component,
- N_Indexed_Component,
- N_Slice);
+ and then Nkind (Prefix (Expression (N))) in
+ N_Selected_Component | N_Indexed_Component | N_Slice;
+
begin
-- Determine whether Copy_Bitfield is appropriate (will work, and will
-- be more efficient than component-by-component copy). Copy_Bitfield
-- We know the underlying type is a record, but its current view
-- may be private. We must retrieve the usable record declaration.
- if Nkind_In (Decl, N_Private_Type_Declaration,
- N_Private_Extension_Declaration)
+ if Nkind (Decl) in N_Private_Type_Declaration
+ | N_Private_Extension_Declaration
and then Present (Full_View (R_Typ))
then
RDef := Type_Definition (Declaration_Node (Full_View (R_Typ)));
-- Since P is going to be evaluated more than once, any subscripts
-- in P must have their evaluation forced.
- if Nkind_In (Lhs, N_Indexed_Component, N_Selected_Component)
+ if Nkind (Lhs) in N_Indexed_Component | N_Selected_Component
and then Is_Ref_To_Bit_Packed_Array (Prefix (Lhs))
then
declare
loop
Set_Analyzed (Exp, False);
- if Nkind_In (Exp, N_Indexed_Component,
- N_Selected_Component)
+ if Nkind (Exp) in N_Indexed_Component | N_Selected_Component
then
Exp := Prefix (Exp);
else
Actual_Rhs : Node_Id := Rhs;
begin
- while Nkind_In (Actual_Rhs, N_Type_Conversion,
- N_Qualified_Expression)
+ while Nkind (Actual_Rhs) in
+ N_Type_Conversion | N_Qualified_Expression
loop
Actual_Rhs := Expression (Actual_Rhs);
end loop;
-- Skip this if left-hand side is an array or record component
-- and elementary component validity checks are suppressed.
- if Nkind_In (Lhs, N_Selected_Component, N_Indexed_Component)
+ if Nkind (Lhs) in N_Selected_Component | N_Indexed_Component
and then not Validity_Check_Components
then
null;
Else_Expr : constant Node_Id := Expression (Else_Stm);
begin
- if Nkind_In (Then_Expr, N_Expanded_Name, N_Identifier)
+ if Nkind (Then_Expr) in N_Expanded_Name | N_Identifier
and then
- Nkind_In (Else_Expr, N_Expanded_Name, N_Identifier)
+ Nkind (Else_Expr) in N_Expanded_Name | N_Identifier
then
if Entity (Then_Expr) = Standard_True
and then Entity (Else_Expr) = Standard_False
and then not Scope_Suppress.Suppress (Accessibility_Check)
and then
(Is_Class_Wide_Type (Etype (Exp))
- or else Nkind_In (Exp, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ or else Nkind (Exp) in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
or else (Is_Entity_Name (Exp)
and then Is_Formal (Entity (Exp)))
or else Scope_Depth (Enclosing_Dynamic_Scope (Etype (Exp))) >
Actual : Node_Id;
begin
- pragma Assert (Nkind_In (Subp_Call, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement));
+ pragma Assert (Nkind (Subp_Call) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement);
Formal := First_Formal_With_Extras (Subp_Id);
Actual := First_Actual (Subp_Call);
Actual : Node_Id;
begin
- pragma Assert (Nkind_In (Subp_Call, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement));
+ pragma Assert (Nkind (Subp_Call) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement);
Formal := First_Formal_With_Extras (Subp_Id);
Actual := First_Actual (Subp_Call);
loop
Set_Analyzed (Pfx, False);
exit when
- not Nkind_In (Pfx, N_Selected_Component, N_Indexed_Component);
+ Nkind (Pfx) not in N_Selected_Component | N_Indexed_Component;
Pfx := Prefix (Pfx);
end loop;
end Reset_Packed_Prefix;
-- root type.
elsif
- Nkind_In (Parent (Subp), N_Private_Extension_Declaration,
- N_Full_Type_Declaration)
+ Nkind (Parent (Subp)) in N_Private_Extension_Declaration
+ | N_Full_Type_Declaration
then
Subp_Decl := Parent (Subp);
(Access_Subprogram_Wrapper (Etype (Name (N))));
begin
- pragma Assert (Nkind_In (N, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement));
+ pragma Assert (Nkind (N) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement);
-- Check that this is not the call in the body of the wrapper.
if Ada_Version >= Ada_2012
and then
- Nkind_In (Call_Node, N_Procedure_Call_Statement, N_Function_Call)
+ Nkind (Call_Node) in N_Procedure_Call_Statement | N_Function_Call
and then Present (Parameter_Associations (Call_Node))
then
Expand_Put_Call_With_Symbol (Call_Node);
-- as out parameter actuals on calls to stream procedures.
Act_Prev := Prev;
- while Nkind_In (Act_Prev, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ while Nkind (Act_Prev) in N_Type_Conversion
+ | N_Unchecked_Type_Conversion
loop
Act_Prev := Expression (Act_Prev);
end loop;
-- constant declaration defines the accessibility level of X'Old".
elsif Nkind (Prev_Orig) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Prev_Orig),
- Name_Old,
- Name_Loop_Entry)
+ and then Attribute_Name (Prev_Orig) in Name_Old | Name_Loop_Entry
and then Is_Entity_Name (Prev)
and then Present (Entity (Prev))
and then Is_Object (Entity (Prev))
when others =>
if Nkind (Prev) = N_Expression_With_Actions
- and then Nkind_In (Original_Node (Prev),
- N_If_Expression,
- N_Case_Expression)
+ and then Nkind (Original_Node (Prev)) in
+ N_If_Expression | N_Case_Expression
then
declare
Decl : Node_Id;
if Nkind (Expression (Assn)) =
N_Expression_With_Actions
and then
- Nkind_In
- (Original_Node (Expression (Assn)),
- N_Case_Expression,
- N_If_Expression)
+ Nkind
+ (Original_Node (Expression (Assn))) in
+ N_Case_Expression | N_If_Expression
then
Insert_Level_Assign (Expression (Assn));
Cond := First (Actions (Branch));
loop
- exit when Nkind_In (Cond, N_Case_Statement,
- N_If_Statement);
+ exit when Nkind (Cond) in
+ N_Case_Statement | N_If_Statement;
Next (Cond);
then
null;
- elsif Nkind_In (Prev, N_Allocator, N_Attribute_Reference) then
+ elsif Nkind (Prev) in N_Allocator | N_Attribute_Reference then
null;
else
begin
Nod := Actual;
- while Nkind_In (Nod, N_Indexed_Component,
- N_Selected_Component)
+ while Nkind (Nod) in
+ N_Indexed_Component | N_Selected_Component
loop
Set_Analyzed (Nod, False);
Nod := Prefix (Nod);
-- "accessibility level determined by the point of call" (AI05-0234)
-- passed in to it, then pass it in.
- if Ekind_In (Subp, E_Function, E_Operator, E_Subprogram_Type)
+ if Ekind (Subp) in E_Function | E_Operator | E_Subprogram_Type
and then
Present (Extra_Accessibility_Of_Result (Ultimate_Alias (Subp)))
then
-- and reanalyzed (see Expand_Protected_Subprogram_Call).
elsif Is_Protected_Type (Scope (Subp))
- and then Ekind_In (Subp, E_Procedure, E_Function)
+ and then Ekind (Subp) in E_Procedure | E_Function
then
null;
return;
end if;
- if Ekind_In (Subp, E_Function, E_Procedure) then
+ if Ekind (Subp) in E_Function | E_Procedure then
-- We perform a simple optimization on calls for To_Address by
-- replacing them with an unchecked conversion. Not only is this
-- intermediate result after its use.
elsif Is_Build_In_Place_Function_Call (Call_Node)
- and then Nkind_In (Parent (Unqual_Conv (Call_Node)),
- N_Attribute_Reference,
- N_Function_Call,
- N_Indexed_Component,
- N_Object_Renaming_Declaration,
- N_Procedure_Call_Statement,
- N_Selected_Component,
- N_Slice)
+ and then Nkind (Parent (Unqual_Conv (Call_Node))) in
+ N_Attribute_Reference
+ | N_Function_Call
+ | N_Indexed_Component
+ | N_Object_Renaming_Declaration
+ | N_Procedure_Call_Statement
+ | N_Selected_Component
+ | N_Slice
and then
(Ekind (Current_Scope) /= E_Loop
or else Nkind (Parent (Call_Node)) /= N_Function_Call
-- For a procedure, we add a return for all possible syntactic ends of
-- the subprogram.
- if Ekind_In (Spec_Id, E_Procedure, E_Generic_Procedure) then
+ if Ekind (Spec_Id) in E_Procedure | E_Generic_Procedure then
Add_Return (Spec_Id, Statements (HSS));
if Present (Exception_Handlers (HSS)) then
-- Call the _Postconditions procedure if the related subprogram has
-- contract assertions that need to be verified on exit.
- if Ekind_In (Scope_Id, E_Entry, E_Entry_Family, E_Procedure)
+ if Ekind (Scope_Id) in E_Entry | E_Entry_Family | E_Procedure
and then Present (Postconditions_Proc (Scope_Id))
then
Insert_Action (N,
if Present (Utyp)
and then Is_Tagged_Type (Utyp)
and then not Is_Class_Wide_Type (Utyp)
- and then (Nkind_In (Exp, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ and then (Nkind (Exp) in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
or else (Is_Entity_Name (Exp)
and then Is_Formal (Entity (Exp))))
then
end if;
elsif Nkind (Discrim_Source) = N_Identifier
- and then Nkind_In (Original_Node (Discrim_Source),
- N_Aggregate, N_Extension_Aggregate)
+ and then Nkind (Original_Node (Discrim_Source)) in
+ N_Aggregate | N_Extension_Aggregate
then
Discrim_Source := Original_Node (Discrim_Source);
-- in an expression context.
if not Is_List_Member (N)
- or else Nkind_In (Context, N_Function_Call,
- N_If_Expression,
- N_Indexed_Component)
+ or else Nkind (Context) in N_Function_Call
+ | N_If_Expression
+ | N_Indexed_Component
then
-- In Ada 2012 the call may be a function call in an expression
-- (since OUT and IN OUT parameters are now allowed for such calls).
-- corresponding statement list.
else
- pragma Assert (Nkind_In (Context, N_Entry_Call_Alternative,
- N_Triggering_Alternative));
+ pragma Assert (Nkind (Context) in N_Entry_Call_Alternative
+ | N_Triggering_Alternative);
if Is_Non_Empty_List (Statements (Context)) then
Insert_List_Before_And_Analyze
-- type whose result subtype is inherently limited. Later this test
-- may be revised to allow composite nonlimited types.
- if Ekind_In (E, E_Function, E_Generic_Function)
+ if Ekind (E) in E_Function | E_Generic_Function
or else (Ekind (E) = E_Subprogram_Type
and then Etype (E) /= Standard_Void_Type)
then
-- Step past qualification or unchecked conversion (the latter can occur
-- in cases of calls to 'Input).
- if Nkind_In (Func_Call, N_Qualified_Expression,
- N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ if Nkind (Func_Call) in N_Qualified_Expression
+ | N_Type_Conversion
+ | N_Unchecked_Type_Conversion
then
Func_Call := Expression (Func_Call);
end if;
Temp_Init := Relocate_Node (Allocator);
- if Nkind_In (Function_Call, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ if Nkind (Function_Call) in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
then
Temp_Init := Unchecked_Convert_To (Acc_Type, Temp_Init);
end if;
-- that the full types will be compatible, but the types not visibly
-- compatible.
- elsif Nkind_In (Function_Call, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ elsif Nkind (Function_Call)
+ in N_Type_Conversion | N_Unchecked_Type_Conversion
then
Ref_Func_Call := Unchecked_Convert_To (Acc_Type, Ref_Func_Call);
end if;
begin
while Present (N)
- and then Nkind_In (N, N_Attribute_Reference, N_Pragma)
+ and then Nkind (N) in N_Attribute_Reference | N_Pragma
loop
Analyze (N);
D := N;
Set_Etype (Def_Id, Ptr_Typ);
Set_Is_Known_Non_Null (Def_Id);
- if Nkind_In (Function_Call, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ if Nkind (Function_Call) in N_Type_Conversion
+ | N_Unchecked_Type_Conversion
then
Res_Decl :=
Make_Object_Declaration (Loc,
-- Mark the label of a source or internally generated block or
-- loop.
- if Nkind_In (P, N_Block_Statement, N_Loop_Statement) then
+ if Nkind (P) in N_Block_Statement | N_Loop_Statement then
Set_Sec_Stack_Needed_For_Return (Entity (Identifier (P)));
-- Mark the enclosing function
-- Recurse to handle case of multiple levels of qualification and/or
-- conversion.
- if Nkind_In (Expr, N_Qualified_Expression,
- N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ if Nkind (Expr) in N_Qualified_Expression
+ | N_Type_Conversion
+ | N_Unchecked_Type_Conversion
then
return Unqual_BIP_Function_Call (Expression (Expr));
-- Recurse to handle case of multiple levels of references and
-- explicit dereferences.
- elsif Nkind_In (Expr, N_Attribute_Reference,
- N_Explicit_Dereference,
- N_Reference)
+ elsif Nkind (Expr) in N_Attribute_Reference
+ | N_Explicit_Dereference
+ | N_Reference
then
return Unqual_BIP_Function_Call (Prefix (Expr));
elsif Nkind (Expr) = N_Identifier
and then Present (Entity (Expr))
- and then Ekind_In (Entity (Expr), E_Constant, E_Variable)
+ and then Ekind (Entity (Expr)) in E_Constant | E_Variable
and then Nkind (Parent (Entity (Expr))) =
N_Object_Renaming_Declaration
and then Present (Renamed_Object (Entity (Expr)))
elsif not On_Object_Declaration
and then Nkind (Expr) = N_Identifier
and then Present (Entity (Expr))
- and then Ekind_In (Entity (Expr), E_Constant, E_Variable)
+ and then Ekind (Entity (Expr)) in E_Constant | E_Variable
and then Nkind (Parent (Entity (Expr))) = N_Object_Declaration
and then Present (Expression (Parent (Entity (Expr))))
then
-- Treat use clauses as declarations and insert directly in front
-- of them.
- if Nkind_In (Insertion_Node, N_Use_Package_Clause,
- N_Use_Type_Clause)
+ if Nkind (Insertion_Node) in
+ N_Use_Package_Clause | N_Use_Type_Clause
then
Insert_List_Before_And_Analyze (Insertion_Node, Actions);
else
-- freeze node, the body must be inserted directly after the
-- construct.
- if Nkind_In (Last_Top_Level_Ctrl_Construct,
- N_Freeze_Entity,
- N_Package_Declaration,
- N_Package_Body)
+ if Nkind (Last_Top_Level_Ctrl_Construct) in
+ N_Freeze_Entity | N_Package_Declaration | N_Package_Body
then
Finalizer_Insert_Nod := Last_Top_Level_Ctrl_Construct;
end if;
Result := Next (Stmt);
while Present (Result) loop
- if not Nkind_In (Result, N_Call_Marker,
- N_Raise_Program_Error)
- then
- exit;
- end if;
+ exit when Nkind (Result) not in
+ N_Call_Marker | N_Raise_Program_Error;
Next (Result);
end loop;
-- Insert the counter after all initialization has been done. The
-- place of insertion depends on the context.
- if Ekind_In (Obj_Id, E_Constant, E_Variable) then
+ if Ekind (Obj_Id) in E_Constant | E_Variable then
-- The object is initialized by a build-in-place function call.
-- The counter insertion point is after the function call.
end;
end if;
- if Ekind_In (Obj_Id, E_Constant, E_Variable)
+ if Ekind (Obj_Id) in E_Constant | E_Variable
and then Present (Status_Flag_Or_Transient_Decl (Obj_Id))
then
-- Temporaries created for the purpose of "exporting" a
if Is_Subprogram (E) then
return True;
- elsif Ekind_In (E, E_Block, E_Loop)
+ elsif Ekind (E) in E_Block | E_Loop
and then Contains_Subprogram (E)
then
return True;
Ftyp := Etype (Fent);
- if Nkind_In (Arg, N_Type_Conversion, N_Unchecked_Type_Conversion) then
+ if Nkind (Arg) in N_Type_Conversion | N_Unchecked_Type_Conversion then
Atyp := Entity (Subtype_Mark (Arg));
else
Atyp := Etype (Arg);
-- Make_Init_Call, set the target type to the type of the formal
-- directly, to avoid spurious typing problems.
- elsif Nkind_In (Arg, N_Unchecked_Type_Conversion, N_Type_Conversion)
+ elsif Nkind (Arg) in N_Unchecked_Type_Conversion | N_Type_Conversion
and then not Is_Class_Wide_Type (Atyp)
then
Set_Subtype_Mark (Arg, New_Occurrence_Of (Ftyp, Sloc (Arg)));
function Is_Package_Or_Subprogram (Id : Entity_Id) return Boolean is
begin
- return Ekind_In (Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Package,
- E_Procedure,
- E_Subprogram_Body);
+ return Ekind (Id) in E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Package
+ | E_Procedure
+ | E_Subprogram_Body;
end Is_Package_Or_Subprogram;
-- Local variables
----------------------------
procedure Expand_Cleanup_Actions (N : Node_Id) is
- pragma Assert (Nkind_In (N, N_Block_Statement,
- N_Entry_Body,
- N_Extended_Return_Statement,
- N_Subprogram_Body,
- N_Task_Body));
+ pragma Assert
+ (Nkind (N) in N_Block_Statement
+ | N_Entry_Body
+ | N_Extended_Return_Statement
+ | N_Subprogram_Body
+ | N_Task_Body);
Scop : constant Entity_Id := Current_Scope;
-- of the alternative.
if Nkind (Parent (Curr)) = N_Entry_Call_Alternative
- and then Nkind_In (Parent (Parent (Curr)),
- N_Conditional_Entry_Call,
- N_Timed_Entry_Call)
+ and then Nkind (Parent (Parent (Curr))) in
+ N_Conditional_Entry_Call | N_Timed_Entry_Call
then
return Parent (Parent (Curr));
-- <or>
-- Hook := Obj_Id'Unrestricted_Access;
- if Ekind_In (Obj_Id, E_Constant, E_Variable)
+ if Ekind (Obj_Id) in E_Constant | E_Variable
and then Present (Last_Aggregate_Assignment (Obj_Id))
then
Hook_Insert := Last_Aggregate_Assignment (Obj_Id);
Par : Node_Id := Parent (N);
begin
- while not (Nkind_In (Par, N_Handled_Sequence_Of_Statements,
- N_Loop_Statement,
- N_Package_Specification)
- or else Nkind (Par) in N_Proper_Body)
+ while Nkind (Par) not in
+ N_Handled_Sequence_Of_Statements | N_Loop_Statement |
+ N_Package_Specification | N_Proper_Body
loop
pragma Assert (Present (Par));
Par := Parent (Par);
-- Prevent the search from going too far because transient blocks
-- are bounded by packages and subprogram scopes.
- elsif Ekind_In (Scop, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Package,
- E_Procedure,
- E_Subprogram_Body)
+ elsif Ekind (Scop) in E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Package
+ | E_Procedure
+ | E_Subprogram_Body
then
exit;
end if;
Manage_SS =>
Uses_Sec_Stack (Curr_S)
and then Nkind (N) = N_Object_Declaration
- and then Ekind_In (Encl_S, E_Package, E_Package_Body)
+ and then Ekind (Encl_S) in E_Package | E_Package_Body
and then Is_Library_Level_Entity (Encl_S));
Pop_Scope;
if Modify_Tree_For_C then
return True;
- elsif Nkind_In (Nam, N_Indexed_Component, N_Slice) then
+ elsif Nkind (Nam) in N_Indexed_Component | N_Slice then
if Is_Packed (Etype (Prefix (Nam))) then
return True;
-- and the environment task is our effective master,
-- so nothing to mark.
- if Nkind_In (Par, N_Block_Statement,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (Par) in
+ N_Block_Statement | N_Subprogram_Body | N_Task_Body
then
Set_Is_Task_Master (Par);
exit;
Prag := Pre_Post_Conditions (Items);
while Present (Prag) loop
- if Nam_In (Pragma_Name_Unmapped (Prag),
- Name_Postcondition, Name_Precondition)
+ if Pragma_Name_Unmapped (Prag) in Name_Postcondition
+ | Name_Precondition
and then Is_Checked (Prag)
then
Has_Pragma := True;
and then ((Nkind (N) = N_Simple_Return_Statement
and then N /= Last (Stmts))
or else Nkind (N) = N_Extended_Return_Statement
- or else (Nkind_In (N, N_Raise_Constraint_Error,
- N_Raise_Program_Error,
- N_Raise_Statement,
- N_Raise_Storage_Error)
+ or else (Nkind (N) in
+ N_Raise_xxx_Error | N_Raise_Statement
and then Comes_From_Source (N)))
then
Wrap_Statement (N);
while Present (Context)
and then Nkind (Context) /= N_Compilation_Unit
loop
- if Nkind_In (Context, N_Block_Statement,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (Context) in
+ N_Block_Statement | N_Subprogram_Body | N_Task_Body
then
Set_Is_Task_Master (Context);
exit;
if Nkind (Context) = N_Discriminant_Specification then
Ctx := Parent (Ctx);
else
- while Nkind_In (Ctx, N_Component_Declaration,
- N_Component_List)
+ while Nkind (Ctx) in
+ N_Component_Declaration | N_Component_List
loop
Ctx := Parent (Ctx);
end loop;
end if;
- if Nkind_In (Ctx, N_Private_Type_Declaration,
- N_Private_Extension_Declaration)
+ if Nkind (Ctx) in N_Private_Type_Declaration
+ | N_Private_Extension_Declaration
then
Context := Parent (Full_View (Defining_Identifier (Ctx)));
end if;
-- _object : prot_typVP := prot_typV (_O);
-- subtype Jnn is <Type of Index> range Low .. High;
- if Nkind_In (Decl, N_Full_Type_Declaration, N_Object_Declaration) then
+ if Nkind (Decl) in N_Full_Type_Declaration | N_Object_Declaration then
Set_Debug_Info_Needed (Defining_Identifier (Decl));
-- Declaration for the Protection object, discriminals, privals, and
if Is_Static_Expression (N) then
return True;
elsif Ada_Version >= Ada_2020
- and then Nkind_In (N, N_Selected_Component, N_Indexed_Component)
+ and then Nkind (N) in N_Selected_Component | N_Indexed_Component
and then Statically_Names_Object (N)
then
-- Restriction relaxed in Ada2020 to allow statically named
if Nkind (Ecall) = N_Block_Statement then
Ecall := First (Statements (Handled_Statement_Sequence (Ecall)));
- while not Nkind_In (Ecall, N_Procedure_Call_Statement,
- N_Entry_Call_Statement)
+ while Nkind (Ecall) not in
+ N_Procedure_Call_Statement | N_Entry_Call_Statement
loop
Next (Ecall);
end loop;
if Ada_Version >= Ada_2005
and then
(No (Original_Node (Ecall))
- or else not Nkind_In (Original_Node (Ecall),
- N_Delay_Relative_Statement,
- N_Delay_Until_Statement))
+ or else Nkind (Original_Node (Ecall)) not in
+ N_Delay_Relative_Statement | N_Delay_Until_Statement)
then
Extract_Dispatching_Call (Ecall, Call_Ent, Obj, Actuals, Formals);
Acc_Ent := N;
while Present (Acc_Ent)
- and then not Nkind_In (Acc_Ent, N_Accept_Statement,
- N_Entry_Body)
+ and then Nkind (Acc_Ent) not in N_Accept_Statement | N_Entry_Body
loop
Acc_Ent := Parent (Acc_Ent);
end loop;
begin
Ent := First_Entity (Tasktyp);
while Present (Ent) loop
- if Ekind_In (Ent, E_Entry, E_Entry_Family) then
+ if Ekind (Ent) in E_Entry | E_Entry_Family then
Build_Contract_Wrapper (Ent, N);
end if;
if Nkind (E_Call) = N_Block_Statement then
E_Call := First (Statements (Handled_Statement_Sequence (E_Call)));
- while not Nkind_In (E_Call, N_Procedure_Call_Statement,
- N_Entry_Call_Statement)
+ while Nkind (E_Call) not in
+ N_Procedure_Call_Statement | N_Entry_Call_Statement
loop
Next (E_Call);
end loop;
Context := Parent (N);
while Present (Context) loop
- if Nkind_In (Context, N_Entry_Body,
- N_Extended_Return_Statement,
- N_Package_Body,
- N_Package_Declaration,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (Context) in N_Entry_Body
+ | N_Extended_Return_Statement
+ | N_Package_Body
+ | N_Package_Declaration
+ | N_Subprogram_Body
+ | N_Task_Body
then
exit;
begin
First_Op := First (D);
while Present (First_Op)
- and then not Nkind_In (First_Op, N_Subprogram_Body, N_Entry_Body)
+ and then Nkind (First_Op) not in N_Subprogram_Body | N_Entry_Body
loop
Next (First_Op);
end loop;
-- of this type should have been removed during semantic analysis.
Pdec := Parent (Ptyp);
- while not Nkind_In (Pdec, N_Protected_Type_Declaration,
- N_Single_Protected_Declaration)
+ while Nkind (Pdec) not in
+ N_Protected_Type_Declaration | N_Single_Protected_Declaration
loop
Next (Pdec);
end loop;
-- this type should have been removed during semantic analysis.
Tdec := Parent (Ttyp);
- while not Nkind_In (Tdec, N_Task_Type_Declaration,
- N_Single_Task_Declaration)
+ while Nkind (Tdec) not in
+ N_Task_Type_Declaration | N_Single_Task_Declaration
loop
Next (Tdec);
end loop;
Next_Op := Next (N);
while Present (Next_Op)
- and then not Nkind_In (Next_Op,
- N_Subprogram_Body, N_Entry_Body, N_Expression_Function)
+ and then Nkind (Next_Op) not in
+ N_Subprogram_Body | N_Entry_Body | N_Expression_Function
loop
Next (Next_Op);
end loop;
begin
Stmt := First (Stats);
while Nkind (Stmt) /= N_Empty
- and then (Nkind_In (Stmt, N_Null_Statement, N_Label)
+ and then (Nkind (Stmt) in N_Null_Statement | N_Label
or else
(Nkind (Stmt) = N_Pragma
and then
- Nam_In (Pragma_Name_Unmapped (Stmt),
- Name_Unreferenced,
- Name_Unmodified,
- Name_Warnings)))
+ Pragma_Name_Unmapped (Stmt) in Name_Unreferenced
+ | Name_Unmodified
+ | Name_Warnings))
loop
Next (Stmt);
end loop;
-- anyway, so the renaming entity will be available in
-- debuggers.
- exit when not Ekind_In (Sel_Id, E_Component, E_Discriminant);
+ exit when Ekind (Sel_Id) not in E_Component | E_Discriminant;
First_Bit := Normalized_First_Bit (Sel_Id);
Enable :=
-- Case of interface name being used
- if Ekind_In (E, E_Constant,
- E_Exception,
- E_Function,
- E_Procedure,
- E_Variable)
+ if Ekind (E) in E_Constant
+ | E_Exception
+ | E_Function
+ | E_Procedure
+ | E_Variable
and then Present (Interface_Name (E))
and then No (Address_Clause (E))
and then not Has_Suffix
if Is_Generic_Instance (E)
and then Is_Subprogram (E)
and then not Is_Compilation_Unit (Scope (E))
- and then Ekind_In (Scope (E), E_Package, E_Package_Body)
+ and then Ekind (Scope (E)) in E_Package | E_Package_Body
and then Present (Related_Instance (Scope (E)))
then
E := Related_Instance (Scope (E));
-- Handle full type declarations and derivations of library level
-- tagged types
- elsif Nkind_In (D, N_Full_Type_Declaration,
- N_Derived_Type_Definition)
+ elsif Nkind (D) in
+ N_Full_Type_Declaration | N_Derived_Type_Definition
and then Is_Library_Level_Tagged_Type (Defining_Entity (D))
and then Ekind (Defining_Entity (D)) /= E_Record_Subtype
and then not Is_Private_Type (Defining_Entity (D))
-- the corresponding object or parameter declaration
elsif Nkind (Controlling_Tag) = N_Identifier
- and then Nkind_In (Parent (Entity (Controlling_Tag)),
- N_Object_Declaration,
- N_Parameter_Specification)
+ and then Nkind (Parent (Entity (Controlling_Tag))) in
+ N_Object_Declaration | N_Parameter_Specification
then
Set_SCIL_Controlling_Tag (SCIL_Node,
Parent (Entity (Controlling_Tag)));
elsif Nkind (Controlling_Tag) = N_Explicit_Dereference
and then Nkind (Prefix (Controlling_Tag)) = N_Identifier
- and then Nkind_In (Parent (Entity (Prefix (Controlling_Tag))),
- N_Object_Declaration,
- N_Parameter_Specification)
+ and then Nkind (Parent (Entity (Prefix (Controlling_Tag)))) in
+ N_Object_Declaration | N_Parameter_Specification
then
Set_SCIL_Controlling_Tag (SCIL_Node,
Parent (Entity (Prefix (Controlling_Tag))));
-- Propagate the value to the wrapped subprogram (if one is present)
- if Ekind_In (Prim, E_Function, E_Procedure)
+ if Ekind (Prim) in E_Function | E_Procedure
and then Is_Primitive_Wrapper (Prim)
and then Present (Wrapped_Entity (Prim))
and then Is_Dispatching_Operation (Wrapped_Entity (Prim))
-- Propagate the value to the wrapped subprogram (if one is present)
- if Ekind_In (Prim, E_Function, E_Procedure)
+ if Ekind (Prim) in E_Function | E_Procedure
and then Is_Primitive_Wrapper (Prim)
and then Present (Wrapped_Entity (Prim))
and then Is_Dispatching_Operation (Wrapped_Entity (Prim))
-- If the DTC_Entity attribute is already set we can also output
-- the name of the interface covered by this primitive (if any).
- if Ekind_In (Alias (Prim), E_Function, E_Procedure)
+ if Ekind (Alias (Prim)) in E_Function | E_Procedure
and then Present (DTC_Entity (Alias (Prim)))
and then Is_Interface (Scope (DTC_Entity (Alias (Prim))))
then
Ent : Entity_Id := Current_Scope;
begin
while Present (Ent) loop
- exit when not Ekind_In (Ent, E_Block, E_Loop);
+ exit when Ekind (Ent) not in E_Block | E_Loop;
Ent := Scope (Ent);
end loop;
elsif Nam = Name_Generic_Dispatching_Constructor then
Expand_Dispatching_Constructor_Call (N);
- elsif Nam_In (Nam, Name_Import_Address,
- Name_Import_Largest_Value,
- Name_Import_Value)
+ elsif Nam in Name_Import_Address
+ | Name_Import_Largest_Value
+ | Name_Import_Value
then
Expand_Import_Call (N);
elsif Nam = Name_To_Pointer then
Expand_To_Pointer (N);
- elsif Nam_In (Nam, Name_File,
- Name_Line,
- Name_Source_Location,
- Name_Enclosing_Entity,
- Name_Compilation_ISO_Date,
- Name_Compilation_Date,
- Name_Compilation_Time)
+ elsif Nam in Name_File
+ | Name_Line
+ | Name_Source_Location
+ | Name_Enclosing_Entity
+ | Name_Compilation_ISO_Date
+ | Name_Compilation_Date
+ | Name_Compilation_Time
then
Expand_Source_Info (N, Nam);
- -- If we have a renaming, expand the call to the original operation,
- -- which must itself be intrinsic, since renaming requires matching
- -- conventions and this has already been checked.
+ -- If we have a renaming, expand the call to the original operation,
+ -- which must itself be intrinsic, since renaming requires matching
+ -- conventions and this has already been checked.
elsif Present (Alias (E)) then
Expand_Intrinsic_Call (N, Alias (E));
elsif Nkind (N) in N_Binary_Op then
Expand_Binary_Operator_Call (N);
- -- The only other case is where an external name was specified, since
- -- this is the only way that an otherwise unrecognized name could
- -- escape the checking in Sem_Prag. Nothing needs to be done in such
- -- a case, since we pass such a call to the back end unchanged.
+ -- The only other case is where an external name was specified, since
+ -- this is the only way that an otherwise unrecognized name could
+ -- escape the checking in Sem_Prag. Nothing needs to be done in such
+ -- a case, since we pass such a call to the back end unchanged.
else
null;
or else
(Nkind (Aexp) = N_Indexed_Component
and then Is_Entity_Name (Prefix (Aexp)))
- or else Nkind_In (Aexp, N_Explicit_Dereference, N_Function_Call)
+ or else Nkind (Aexp) in N_Explicit_Dereference | N_Function_Call
then
Set_Analyzed (Aexp);
end if;
-- that the failure is not at the point of occurrence of the
-- pragma, unlike the other Check cases.
- elsif Nam_In (Nam, Name_Precondition, Name_Postcondition) then
+ elsif Nam in Name_Precondition | Name_Postcondition then
Get_Name_String (Nam);
Insert_Str_In_Name_Buffer ("failed ", 1);
Add_Str_To_Name_Buffer (" from ");
-- with no components there is no need to handle it.
while Present (Item) loop
- if Nkind_In (Item, N_Component_Declaration,
- N_Discriminant_Specification)
+ if Nkind (Item) in
+ N_Component_Declaration | N_Discriminant_Specification
and then
((Chars (Defining_Identifier (Item)) = Name_uParent
and then not Is_Interface
return False;
else
- if Ekind_In (Formal, E_Out_Parameter, E_In_Out_Parameter) then
+ if Ekind (Formal) in E_Out_Parameter | E_In_Out_Parameter then
Insert_Node := Call;
return True;
else
return False;
end if;
- elsif Nkind_In (P, N_Indexed_Component, N_Selected_Component)
+ elsif Nkind (P) in N_Indexed_Component | N_Selected_Component
and then N = Prefix (P)
then
return On_Lhs_Of_Assignment (P);
then
exit;
- elsif Ekind_In (Etype (E1),
- E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type)
- and then Ekind_In (Etype (E2),
- E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type)
+ elsif Ekind (Etype (E1)) in
+ E_Anonymous_Access_Subprogram_Type |
+ E_Anonymous_Access_Protected_Subprogram_Type
+ and then Ekind (Etype (E2)) in
+ E_Anonymous_Access_Subprogram_Type |
+ E_Anonymous_Access_Protected_Subprogram_Type
and then not Conforming_Types
(Etype (E1), Etype (E2), Fully_Conformant)
then
-- Attribute or indexed component case
- elsif Nkind_In (N, N_Attribute_Reference,
- N_Indexed_Component)
+ elsif Nkind (N) in
+ N_Attribute_Reference | N_Indexed_Component
then
Note_Uplevel_Bound (Prefix (N), Ref);
-- Explicit dereference and selected component case
- elsif Nkind_In (N, N_Explicit_Dereference,
- N_Selected_Component)
+ elsif Nkind (N) in
+ N_Explicit_Dereference | N_Selected_Component
then
Note_Uplevel_Bound (Prefix (N), Ref);
then
return;
- elsif Ekind_In (Callee, E_Entry, E_Entry_Family) then
+ elsif Ekind (Callee) in E_Entry | E_Entry_Family then
return;
end if;
-- references to global declarations.
and then
- (Ekind_In (Ent, E_Constant,
- E_Loop_Parameter,
- E_Variable)
+ (Ekind (Ent) in E_Constant
+ | E_Loop_Parameter
+ | E_Variable
-- Formals are interesting, but not if being used
-- as mere names of parameters for name notation
-- N_Loop_Parameter_Specification or to
-- an N_Iterator_Specification.
- if Nkind_In
- (Ins, N_Iterator_Specification,
- N_Loop_Parameter_Specification)
+ if Nkind (Ins) in
+ N_Iterator_Specification |
+ N_Loop_Parameter_Specification
then
-- Quantified expression are rewritten as
-- loops during expansion.
-- processing this dereference
if Opt.Modify_Tree_For_C
- and then Nkind_In (Parent (UPJ.Ref),
- N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ and then Nkind (Parent (UPJ.Ref)) in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
then
Force_Evaluation (UPJ.Ref, Mode => Strict);
end if;
function Search_Subprograms (N : Node_Id) return Traverse_Result is
begin
- if Nkind_In (N, N_Subprogram_Body, N_Subprogram_Body_Stub) then
+ if Nkind (N) in N_Subprogram_Body | N_Subprogram_Body_Stub then
declare
Spec_Id : constant Entity_Id := Unique_Defining_Entity (N);
-----------------------------------------
procedure Expand_Static_Predicates_In_Choices (N : Node_Id) is
- pragma Assert (Nkind_In (N, N_Case_Statement_Alternative, N_Variant));
+ pragma Assert (Nkind (N) in N_Case_Statement_Alternative | N_Variant);
Choices : constant List_Id := Discrete_Choices (N);
begin
S := Scop;
while Present (S) loop
- if Ekind_In (S, E_Entry, E_Entry_Family, E_Function, E_Procedure)
+ if Ekind (S) in E_Entry | E_Entry_Family | E_Function | E_Procedure
and then Present (Protection_Object (S))
then
return Protection_Object (S);
Par := N;
Top := N;
while Present (Par) loop
- if Nkind_In (Original_Node (Par), N_Case_Expression,
- N_If_Expression)
+ if Nkind (Original_Node (Par)) in
+ N_Case_Expression | N_If_Expression
then
Top := Par;
Par := Top;
while Present (Par) loop
if Is_List_Member (Par)
- and then not Nkind_In (Par, N_Component_Association,
- N_Discriminant_Association,
- N_Parameter_Association,
- N_Pragma_Argument_Association)
- and then not Nkind_In (Parent (Par), N_Function_Call,
- N_Procedure_Call_Statement,
- N_Entry_Call_Statement)
+ and then Nkind (Par) not in N_Component_Association
+ | N_Discriminant_Association
+ | N_Parameter_Association
+ | N_Pragma_Argument_Association
+ and then Nkind (Parent (Par)) not in N_Function_Call
+ | N_Procedure_Call_Statement
+ | N_Entry_Call_Statement
then
return Par;
-- Keep climbing past various operators
if Nkind (Parent (Par)) in N_Op
- or else Nkind_In (Parent (Par), N_And_Then, N_Or_Else)
+ or else Nkind (Parent (Par)) in N_And_Then | N_Or_Else
then
Par := Parent (Par);
else
while Present (Par) loop
if Par = Wrapped_Node
- or else Nkind_In (Par, N_Assignment_Statement,
- N_Object_Declaration,
- N_Pragma,
- N_Procedure_Call_Statement,
- N_Simple_Return_Statement)
+ or else Nkind (Par) in N_Assignment_Statement
+ | N_Object_Declaration
+ | N_Pragma
+ | N_Procedure_Call_Statement
+ | N_Simple_Return_Statement
then
return Par;
-- Deal with conversions, qualifications, and expressions with
-- actions.
- while Nkind_In (Cond,
- N_Type_Conversion,
- N_Qualified_Expression,
- N_Expression_With_Actions)
+ while Nkind (Cond) in N_Type_Conversion
+ | N_Qualified_Expression
+ | N_Expression_With_Actions
loop
Cond := Expression (Cond);
end loop;
-- Deal with AND THEN and AND cases
- if Nkind_In (Cond, N_And_Then, N_Op_And) then
+ if Nkind (Cond) in N_And_Then | N_Op_And then
-- Don't ever try to invert a condition that is of the form of an
-- AND or AND THEN (since we are not doing sufficiently general
return;
- elsif Nkind_In (Cond,
- N_Type_Conversion,
- N_Qualified_Expression,
- N_Expression_With_Actions)
+ elsif Nkind (Cond) in N_Type_Conversion
+ | N_Qualified_Expression
+ | N_Expression_With_Actions
then
Cond := Expression (Cond);
-- actions should be inserted outside the complete record
-- declaration.
- elsif Nkind_In (Parent (P), N_Variant, N_Record_Definition) then
+ elsif Nkind (Parent (P)) in N_Variant | N_Record_Definition then
null;
-- Do not insert freeze nodes within the loop generated for
P := Parent (P);
if Is_List_Member (P) then
- exit when Nkind_In (Parent (P), N_Package_Specification,
- N_Subprogram_Body);
+ exit when Nkind (Parent (P)) in
+ N_Package_Specification | N_Subprogram_Body;
-- Special handling for handled sequence of statements, we must
-- insert in the statements not the exception handlers!
if Nkind (Result) = N_Explicit_Dereference then
Result := Prefix (Result);
- elsif Nkind_In (Result, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ elsif Nkind (Result) in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
then
Result := Expression (Result);
if Nkind (N) = N_Identifier
and then Present (Entity (N))
- and then Ekind_In (Entity (N), E_Constant, E_Variable)
+ and then Ekind (Entity (N)) in E_Constant | E_Variable
then
Ren_Obj := Entity (N);
return Abandon;
end if;
return
- Ekind_In (Obj_Id, E_Constant, E_Variable)
+ Ekind (Obj_Id) in E_Constant | E_Variable
and then Needs_Finalization (Desig)
and then Requires_Transient_Scope (Desig)
and then Nkind (Rel_Node) /= N_Simple_Return_Statement
return Is_Ref_To_Bit_Packed_Array (Renamed_Object (Entity (N)));
end if;
- if Nkind_In (N, N_Indexed_Component, N_Selected_Component) then
+ if Nkind (N) in N_Indexed_Component | N_Selected_Component then
if Is_Bit_Packed_Array (Etype (Prefix (N))) then
Result := True;
else
then
return True;
- elsif Nkind_In (N, N_Indexed_Component, N_Selected_Component) then
+ elsif Nkind (N) in N_Indexed_Component | N_Selected_Component then
return Is_Ref_To_Bit_Packed_Slice (Prefix (N));
else
begin
if Kind = N_Object_Renaming_Declaration then
return True;
- elsif Nkind_In (Kind, N_Indexed_Component, N_Selected_Component) then
+ elsif Kind in N_Indexed_Component | N_Selected_Component then
return Is_Renamed_Object (Pnod);
else
return False;
-- True if volatile component
- elsif Nkind_In (N, N_Indexed_Component, N_Selected_Component) then
+ elsif Nkind (N) in N_Indexed_Component | N_Selected_Component then
if (Is_Entity_Name (Prefix (N))
and then Has_Volatile_Components (Entity (Prefix (N))))
or else (Present (Etype (Prefix (N)))
=>
-- Check the "then statements" for elsif parts and if statements
- if Nkind_In (N, N_Elsif_Part, N_If_Statement)
+ if Nkind (N) in N_Elsif_Part | N_If_Statement
and then not Is_Empty_List (Then_Statements (N))
and then not Are_Wrapped (Then_Statements (N))
and then Requires_Cleanup_Actions
-- Check the "else statements" for conditional entry calls, if
-- statements and selective accepts.
- if Nkind_In (N, N_Conditional_Entry_Call,
- N_If_Statement,
- N_Selective_Accept)
+ if Nkind (N) in
+ N_Conditional_Entry_Call | N_If_Statement | N_Selective_Accept
and then not Is_Empty_List (Else_Statements (N))
and then not Are_Wrapped (Else_Statements (N))
and then Requires_Cleanup_Actions
-- by the expression it renames, which would defeat the purpose of
-- removing the side effect.
- if Nkind_In (Exp, N_Selected_Component, N_Indexed_Component)
+ if Nkind (Exp) in N_Selected_Component | N_Indexed_Component
and then Has_Non_Standard_Rep (Etype (Prefix (Exp)))
then
null;
-- and view swaps, the parent type is taken from the formal
-- parameter of the subprogram being called.
- if Nkind_In (Context, N_Function_Call,
- N_Procedure_Call_Statement)
+ if Nkind (Context) in
+ N_Function_Call | N_Procedure_Call_Statement
and then No (Type_Map.Get (Entity (Name (Context))))
then
New_Ref :=
Lib_Level : Boolean) return Boolean
is
At_Lib_Level : constant Boolean :=
- Lib_Level
- and then Nkind_In (N, N_Package_Body,
- N_Package_Specification);
+ Lib_Level
+ and then Nkind (N) in N_Package_Body | N_Package_Specification;
-- N is at the library level if the top-most context is a package and
-- the path taken to reach N does not include nonpackage constructs.
if (Nkind (Pexp) = N_Assignment_Statement
and then Expression (Pexp) = Exp)
- or else Nkind_In (Pexp, N_Object_Declaration,
- N_Object_Renaming_Declaration)
+ or else Nkind (Pexp)
+ in N_Object_Declaration | N_Object_Renaming_Declaration
then
return True;
Set_Entity_Current_Value (Right_Opnd (Cond));
end if;
- elsif Nkind_In (Cond,
- N_Type_Conversion,
- N_Qualified_Expression,
- N_Expression_With_Actions)
+ elsif Nkind (Cond) in N_Type_Conversion
+ | N_Qualified_Expression
+ | N_Expression_With_Actions
then
Set_Expression_Current_Value (Expression (Cond));
if Nkind (N) = N_Subprogram_Body
and then Address_Taken (Spec_Id)
and then
- Ekind_In (Scope (Spec_Id), E_Block, E_Procedure, E_Function)
+ Ekind (Scope (Spec_Id)) in E_Block | E_Procedure | E_Function
then
declare
Loc : constant Source_Ptr := Sloc (N);
elsif Is_Entity_Name (N) then
return Ekind (Entity (N)) = E_In_Parameter;
- elsif Nkind_In (N, N_Indexed_Component, N_Selected_Component) then
+ elsif Nkind (N) in N_Indexed_Component | N_Selected_Component then
return Within_In_Parameter (Prefix (N));
else
-- explicit dereference, then the designated object could
-- be modified by an assignment.
- if Nkind_In (RO, N_Indexed_Component,
- N_Explicit_Dereference)
- then
+ if Nkind (RO) in N_Indexed_Component | N_Explicit_Dereference then
return False;
-- A selected component must have a safe prefix
Par := Parent (N);
while Present (Par) loop
- if Nkind_In (Original_Node (Par), N_Case_Expression,
- N_If_Expression)
+ if Nkind (Original_Node (Par)) in N_Case_Expression | N_If_Expression
then
return True;
and then
(Present (Interface_Name (Renamed_Subp))
- or else Nam_In (Chars (Renamed_Subp), Name_Rotate_Left,
- Name_Rotate_Right,
- Name_Shift_Left,
- Name_Shift_Right,
- Name_Shift_Right_Arithmetic))
+ or else Chars (Renamed_Subp) in Name_Rotate_Left
+ | Name_Rotate_Right
+ | Name_Shift_Left
+ | Name_Shift_Right
+ | Name_Shift_Right_Arithmetic)
then
Set_Interface_Name (Ent, Interface_Name (Renamed_Subp));
-- as we need to check other conditions for creating a body to inline
-- in that case, which are controlled in Analyze_Subprogram_Body_Helper.
- if Ekind_In (Old_S, E_Function, E_Procedure)
+ if Ekind (Old_S) in E_Function | E_Procedure
and then Nkind (Decl) = N_Subprogram_Declaration
and then not Is_Generic_Instance (Old_S)
and then not GNATprove_Mode
end if;
elsif Ekind (E) in Task_Kind
- and then Nkind_In (Parent (E), N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ and then Nkind (Parent (E)) in
+ N_Single_Task_Declaration | N_Task_Type_Declaration
then
Push_Scope (E);
Freeze_All (First_Entity (E), After);
-- current package, but this body does not freeze incomplete
-- types that may be declared in this private part.
- if (Nkind_In (Bod, N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body)
- or else Nkind (Bod) in N_Body_Stub)
+ if Comes_From_Source (Bod)
+ and then Nkind (Bod) in N_Entry_Body
+ | N_Package_Body
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
+ | N_Body_Stub
and then
List_Containing (After) = List_Containing (Parent (E))
- and then Comes_From_Source (Bod)
then
Error_Msg_Sloc := Sloc (Next (After));
Error_Msg_NE
begin
case Nkind (N) is
when N_Attribute_Reference =>
- if Nam_In (Attribute_Name (N), Name_Access,
- Name_Unchecked_Access)
+ if Attribute_Name (N) in Name_Access | Name_Unchecked_Access
and then Is_Entity_Name (Prefix (N))
and then Is_Type (Entity (Prefix (N)))
and then Entity (Prefix (N)) = E
-- Handle the component and discriminant case
- if Ekind_In (Comp, E_Component, E_Discriminant) then
+ if Ekind (Comp) in E_Component | E_Discriminant then
declare
CC : constant Node_Id := Component_Clause (Comp);
-- case, both the body and imported function utilize the same
-- type.
- if Ekind_In (E, E_Function, E_Generic_Function) then
+ if Ekind (E) in E_Function | E_Generic_Function then
Stmt :=
Make_Simple_Return_Statement (Loc,
Expression =>
begin
while Present (Prag) loop
- if Nam_In (Pragma_Name_Unmapped (Prag),
- Name_Post,
- Name_Postcondition,
- Name_Refined_Post)
+ if Pragma_Name_Unmapped (Prag) in Name_Post
+ | Name_Postcondition
+ | Name_Refined_Post
then
Exp :=
Expression
-- Remaining step is to layout objects
- if Ekind_In (E, E_Variable, E_Constant, E_Loop_Parameter)
+ if Ekind (E) in E_Variable | E_Constant | E_Loop_Parameter
or else Is_Formal (E)
then
Layout_Object (E);
-- statement, move them back now directly within the enclosing
-- statement sequence.
- if Ekind_In (E, E_Constant, E_Variable)
+ if Ekind (E) in E_Constant | E_Variable
and then not Has_Delayed_Freeze (E)
then
Explode_Initialization_Compound_Statement (E);
-- for the case of a private type with record extension (we will do
-- that later when the full type is frozen).
- elsif Ekind_In (E, E_Record_Type, E_Record_Subtype) then
+ elsif Ekind (E) in E_Record_Type | E_Record_Subtype then
if not In_Generic_Scope (E) then
Freeze_Record_Type (E);
end if;
begin
pragma Assert
- (Nam_In (Op_Name, Name_Allocate,
- Name_Deallocate,
- Name_Storage_Size));
+ (Op_Name in Name_Allocate
+ | Name_Deallocate
+ | Name_Storage_Size);
Error_Msg_Name_1 := Op_Name;
Op := Get_Name_Entity_Id (Op_Name);
while Present (Op) loop
- if Ekind_In (Op, E_Function, E_Procedure)
+ if Ekind (Op) in E_Function | E_Procedure
and then Scope (Op) = Current_Scope
then
Formal := First_Entity (Op);
Check_Strict_Alignment (E);
end if;
- if Ekind_In (E, E_Record_Type, E_Record_Subtype) then
+ if Ekind (E) in E_Record_Type | E_Record_Subtype then
declare
RC : constant Node_Id := Get_Record_Representation_Clause (E);
begin
-- The case we are looking for is an enumeration literal
- if Nkind_In (N, N_Identifier, N_Character_Literal)
+ if Nkind (N) in N_Identifier | N_Character_Literal
and then Is_Enumeration_Type (Etype (N))
then
-- If enumeration literal appears directly as the choice,
function Clone_Id (Node : Node_Id) return Traverse_Result is
begin
- if Nkind_In (Node, N_Iterator_Specification,
- N_Loop_Parameter_Specification)
+ if Nkind (Node) in
+ N_Iterator_Specification | N_Loop_Parameter_Specification
then
Set_Defining_Identifier
(Node, New_Copy (Defining_Identifier (Node)));
-- Check that the enclosing record type can be frozen
- if Ekind_In (Entity (Node), E_Component, E_Discriminant) then
+ if Ekind (Entity (Node)) in E_Component | E_Discriminant then
Check_And_Freeze_Type (Scope (Entity (Node)));
end if;
-- Check attribute Extra_Accessibility_Of_Result
- if Ekind_In (E, E_Function, E_Subprogram_Type)
+ if Ekind (E) in E_Function | E_Subprogram_Type
and then Needs_Result_Accessibility_Level (E)
and then No (Extra_Accessibility_Of_Result (E))
then
-- directly.
if Nkind (Dcopy) = N_Identifier
- or else Nkind_In (Dcopy, N_Expanded_Name,
- N_Integer_Literal,
- N_Character_Literal,
- N_String_Literal,
- N_Real_Literal)
+ or else Nkind (Dcopy) in N_Expanded_Name
+ | N_Integer_Literal
+ | N_Character_Literal
+ | N_String_Literal
+ | N_Real_Literal
or else (Nkind (Dcopy) = N_Attribute_Reference
and then Attribute_Name (Dcopy) = Name_Null_Parameter)
or else Known_Null (Dcopy)
-- treated as Ghost when they contain a reference to a Ghost
-- entity (SPARK RM 6.9(11)).
- elsif Nam_In (Prag_Nam, Name_Global,
- Name_Depends,
- Name_Initializes,
- Name_Refined_Global,
- Name_Refined_Depends,
- Name_Refined_State)
+ elsif Prag_Nam in Name_Global
+ | Name_Depends
+ | Name_Initializes
+ | Name_Refined_Global
+ | Name_Refined_Depends
+ | Name_Refined_State
then
return True;
end if;
-- When the context is a [generic] package declaration, pragma Ghost
-- resides in the visible declarations.
- if Nkind_In (N, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (N) in N_Generic_Package_Declaration | N_Package_Declaration
then
Decl := First (Visible_Declarations (Specification (N)));
-- When the context is a package or a subprogram body, pragma Ghost
-- resides in the declarative part.
- elsif Nkind_In (N, N_Package_Body, N_Subprogram_Body) then
+ elsif Nkind (N) in N_Package_Body | N_Subprogram_Body then
Decl := First (Declarations (N));
-- Otherwise pragma Ghost appears in the declarations following N
-- A child package or subprogram declaration becomes Ghost when its
-- parent is Ghost (SPARK RM 6.9(2)).
- elsif Nkind_In (N, N_Generic_Function_Renaming_Declaration,
- N_Generic_Package_Declaration,
- N_Generic_Package_Renaming_Declaration,
- N_Generic_Procedure_Renaming_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Declaration,
- N_Package_Renaming_Declaration,
- N_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration)
+ elsif Nkind (N) in N_Generic_Function_Renaming_Declaration
+ | N_Generic_Package_Declaration
+ | N_Generic_Package_Renaming_Declaration
+ | N_Generic_Procedure_Renaming_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Package_Declaration
+ | N_Package_Renaming_Declaration
+ | N_Subprogram_Declaration
+ | N_Subprogram_Renaming_Declaration
and then Present (Parent_Spec (N))
then
Par_Id := Defining_Entity (Unit (Parent_Spec (N)));
-- ??? could extra formal parameters cause a Ghost leak?
if Mark_Formals
- and then Nkind_In (N, N_Abstract_Subprogram_Declaration,
- N_Formal_Abstract_Subprogram_Declaration,
- N_Formal_Concrete_Subprogram_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub,
- N_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration)
+ and then Nkind (N) in N_Abstract_Subprogram_Declaration
+ | N_Formal_Abstract_Subprogram_Declaration
+ | N_Formal_Concrete_Subprogram_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
+ | N_Subprogram_Declaration
+ | N_Subprogram_Renaming_Declaration
then
Param := First (Parameter_Specifications (Specification (N)));
while Present (Param) loop
-- subject to any Ghost annotation.
else
- pragma Assert (Nam_In (Mode, Name_Disable, Name_None, No_Name));
+ pragma Assert (Mode in Name_Disable | Name_None | No_Name);
return None;
end if;
end Name_To_Ghost_Mode;
if Is_Body (N)
or else Is_Declaration (N)
or else Nkind (N) in N_Generic_Instantiation
- or else Nkind (N) in N_Push_Pop_xxx_Label
- or else Nkind (N) in N_Raise_xxx_Error
- or else Nkind (N) in N_Representation_Clause
- or else Nkind (N) in N_Statement_Other_Than_Procedure_Call
- or else Nkind_In (N, N_Call_Marker,
- N_Freeze_Entity,
- N_Freeze_Generic_Entity,
- N_Itype_Reference,
- N_Pragma,
- N_Procedure_Call_Statement,
- N_Use_Package_Clause,
- N_Use_Type_Clause,
- N_Variable_Reference_Marker,
- N_With_Clause)
+ | N_Push_Pop_xxx_Label
+ | N_Raise_xxx_Error
+ | N_Representation_Clause
+ | N_Statement_Other_Than_Procedure_Call
+ | N_Call_Marker
+ | N_Freeze_Entity
+ | N_Freeze_Generic_Entity
+ | N_Itype_Reference
+ | N_Pragma
+ | N_Procedure_Call_Statement
+ | N_Use_Package_Clause
+ | N_Use_Type_Clause
+ | N_Variable_Reference_Marker
+ | N_With_Clause
then
-- Only ignored Ghost nodes must be recorded in the table
-- The Ghost mode of a [generic] freeze node depends on the Ghost mode
-- of the entity being frozen.
- elsif Nkind_In (N, N_Freeze_Entity, N_Freeze_Generic_Entity) then
+ elsif Nkind (N) in N_Freeze_Entity | N_Freeze_Generic_Entity then
Set_Ghost_Mode_From_Entity (Entity (N));
-- The Ghost mode of a pragma depends on the associated entity. The
-- We can generate code for a package declaration or a subprogram
-- declaration only if it does not required a body.
- elsif Nkind_In (Main_Unit_Kind, N_Package_Declaration,
- N_Subprogram_Declaration)
+ elsif Main_Unit_Kind in N_Package_Declaration | N_Subprogram_Declaration
and then
(not Body_Required (Main_Unit_Node)
or else Distribution_Stub_Mode = Generate_Caller_Stub_Body)
-- We can generate code for a generic package declaration of a generic
-- subprogram declaration only if does not require a body.
- elsif Nkind_In (Main_Unit_Kind, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration)
+ elsif Main_Unit_Kind in
+ N_Generic_Package_Declaration | N_Generic_Subprogram_Declaration
and then not Body_Required (Main_Unit_Node)
then
Back_End_Mode := Generate_Object;
-- Compilation units that are renamings do not require bodies, so we can
-- generate code for them.
- elsif Nkind_In (Main_Unit_Kind, N_Package_Renaming_Declaration,
- N_Subprogram_Renaming_Declaration)
+ elsif Main_Unit_Kind in N_Package_Renaming_Declaration |
+ N_Subprogram_Renaming_Declaration
then
Back_End_Mode := Generate_Object;
else
Decl := Unit_Declaration_Node (Scop);
- if Nkind_In (Decl, N_Subprogram_Declaration,
- N_Task_Type_Declaration,
- N_Subprogram_Body_Stub)
+ if Nkind (Decl) in N_Subprogram_Declaration
+ | N_Task_Type_Declaration
+ | N_Subprogram_Body_Stub
then
Decl := Unit_Declaration_Node (Corresponding_Body (Decl));
end if;
and then not GNATprove_Mode)
or else
- (Nkind_In (A, N_Real_Literal,
- N_Integer_Literal,
- N_Character_Literal)
+ (Nkind (A) in
+ N_Real_Literal | N_Integer_Literal | N_Character_Literal
and then not Address_Taken (F))
then
if Etype (F) /= Etype (A) then
-- and string literals, and attributes that yield a universal
-- type, because those must be resolved to a specific type.
- if Nkind_In (Expression (N), N_Aggregate,
- N_Character_Literal,
- N_Null,
- N_String_Literal)
+ if Nkind (Expression (N)) in N_Aggregate
+ | N_Character_Literal
+ | N_Null
+ | N_String_Literal
or else Yields_Universal_Type (Expression (N))
then
Ret :=
then
Conv := Current_Entity (Id);
- elsif Nkind_In (Id, N_Selected_Component, N_Expanded_Name)
+ elsif Nkind (Id) in N_Selected_Component | N_Expanded_Name
and then Chars (Selector_Name (Id)) = Name_Unchecked_Conversion
then
Conv := Current_Entity (Selector_Name (Id));
S := First (Stats);
while Present (S) loop
- if Nkind_In (S, N_Abort_Statement,
- N_Asynchronous_Select,
- N_Conditional_Entry_Call,
- N_Delay_Relative_Statement,
- N_Delay_Until_Statement,
- N_Selective_Accept,
- N_Timed_Entry_Call)
+ if Nkind (S) in N_Abort_Statement
+ | N_Asynchronous_Select
+ | N_Conditional_Entry_Call
+ | N_Delay_Relative_Statement
+ | N_Delay_Until_Statement
+ | N_Selective_Accept
+ | N_Timed_Entry_Call
then
Cannot_Inline
("cannot inline & (non-allowed statement)?", S, Subp);
end if;
if Present (Item_Id)
- and then Nam_In (Chars (Item_Id), Name_Contract_Cases,
- Name_Global,
- Name_Depends,
- Name_Postcondition,
- Name_Precondition,
- Name_Refined_Global,
- Name_Refined_Depends,
- Name_Refined_Post,
- Name_Test_Case,
- Name_Unmodified,
- Name_Unreferenced,
- Name_Unused)
+ and then Chars (Item_Id) in Name_Contract_Cases
+ | Name_Global
+ | Name_Depends
+ | Name_Postcondition
+ | Name_Precondition
+ | Name_Refined_Global
+ | Name_Refined_Depends
+ | Name_Refined_Post
+ | Name_Test_Case
+ | Name_Unmodified
+ | Name_Unreferenced
+ | Name_Unused
then
Remove (Item);
end if;
Write_Info_Str (" O");
Write_Info_Char (OA_Setting (Unit_Num));
- if Ekind_In (Uent, E_Package, E_Package_Body)
+ if Ekind (Uent) in E_Package | E_Package_Body
and then Present (Finalizer (Uent))
then
Write_Info_Str (" PF");
if Nkind (U) = N_Subprogram_Body
and then Present (Corresponding_Spec (U))
and then
- Ekind_In (Corresponding_Spec (U), E_Generic_Procedure,
- E_Generic_Function)
+ Ekind (Corresponding_Spec (U)) in E_Generic_Procedure
+ | E_Generic_Function
then
null;
-- If N is the defining identifier for a subprogram, then return the
-- enclosing subprogram or package, not this subprogram.
- if Nkind_In (N, N_Defining_Identifier, N_Defining_Operator_Symbol)
- and then (Ekind (N) in Entry_Kind
- or else Ekind (N) = E_Subprogram_Body
- or else Ekind (N) in Generic_Subprogram_Kind
- or else Ekind (N) in Subprogram_Kind)
+ if Nkind (N) in N_Defining_Identifier | N_Defining_Operator_Symbol
+ and then Ekind (N) in Entry_Kind
+ | E_Subprogram_Body
+ | Generic_Subprogram_Kind
+ | Subprogram_Kind
then
Context := Parent (Unit_Declaration_Node (N));
P := Parent (P);
if Nkind (P) = N_Pragma then
- if Nam_In (Pragma_Name_Unmapped (P),
- Name_Warnings,
- Name_Unmodified,
- Name_Unreferenced)
+ if Pragma_Name_Unmapped (P) in Name_Warnings
+ | Name_Unmodified
+ | Name_Unreferenced
then
return False;
end if;
-- since the attribute acts as an anonymous alias of the function
-- result and not as a real reference to the function.
- elsif Ekind_In (E, E_Function, E_Generic_Function)
+ elsif Ekind (E) in E_Function | E_Generic_Function
and then Is_Entity_Name (N)
and then Is_Attribute_Result (Parent (N))
then
and then Typ /= ' '
then
- if Nkind_In (N, N_Identifier,
- N_Defining_Identifier,
- N_Defining_Operator_Symbol,
- N_Operator_Symbol,
- N_Defining_Character_Literal)
- or else Nkind (N) in N_Op
+ if Nkind (N) in N_Identifier
+ | N_Defining_Identifier
+ | N_Defining_Operator_Symbol
+ | N_Operator_Symbol
+ | N_Defining_Character_Literal
+ | N_Op
or else (Nkind (N) = N_Character_Literal
and then Sloc (Entity (N)) /= Standard_Location)
then
Nod := N;
- elsif Nkind_In (N, N_Expanded_Name, N_Selected_Component) then
+ elsif Nkind (N) in N_Expanded_Name | N_Selected_Component then
Nod := Selector_Name (N);
else
-- reads/writes of private protected components) and not worth the
-- effort.
- if Ekind_In (Ent, E_Abstract_State, E_Constant, E_Variable)
+ if Ekind (Ent) in E_Abstract_State | E_Constant | E_Variable
and then Present (Encapsulating_State (Ent))
and then Is_Single_Concurrent_Object (Encapsulating_State (Ent))
then
-- Special handling for access parameters and objects and
-- components of an anonymous access type.
- if Ekind_In (Etype (XE.Key.Ent),
- E_Anonymous_Access_Type,
- E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type)
+ if Ekind (Etype (XE.Key.Ent)) in
+ E_Anonymous_Access_Type
+ | E_Anonymous_Access_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
then
if Is_Formal (XE.Key.Ent)
or else
- Ekind_In
- (XE.Key.Ent, E_Variable, E_Constant, E_Component)
+ Ekind (XE.Key.Ent) in
+ E_Variable | E_Constant | E_Component
then
Ctyp := 'p';
end if;
return Name_Find (Buf);
end Name_Find;
- -------------
- -- Nam_In --
- -------------
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id;
- V10 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id;
- V10 : Name_Id;
- V11 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10 or else
- T = V11;
- end Nam_In;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id;
- V10 : Name_Id;
- V11 : Name_Id;
- V12 : Name_Id) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10 or else
- T = V11 or else
- T = V12;
- end Nam_In;
-
-----------------
-- Name_Equals --
-----------------
pragma Inline (Present);
-- Determine whether name Nam exists
- ------------------------------
- -- Name_Id Membership Tests --
- ------------------------------
-
- -- The following functions allow a convenient notation for testing whether
- -- a Name_Id value matches any one of a list of possible values. In each
- -- case True is returned if the given T argument is equal to any of the V
- -- arguments. These essentially duplicate the Ada 2012 membership tests,
- -- but we cannot use the latter (yet) in the compiler front end, because
- -- of bootstrap considerations
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id;
- V10 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id;
- V10 : Name_Id;
- V11 : Name_Id) return Boolean;
-
- function Nam_In
- (T : Name_Id;
- V1 : Name_Id;
- V2 : Name_Id;
- V3 : Name_Id;
- V4 : Name_Id;
- V5 : Name_Id;
- V6 : Name_Id;
- V7 : Name_Id;
- V8 : Name_Id;
- V9 : Name_Id;
- V10 : Name_Id;
- V11 : Name_Id;
- V12 : Name_Id) return Boolean;
-
- pragma Inline (Nam_In);
- -- Inline all above functions
-
-----------------
-- Subprograms --
-----------------
N := Node;
loop
Next (N);
- exit when not Nkind_In (N, N_Pragma, N_Null_Statement);
+ exit when Nkind (N) not in N_Pragma | N_Null_Statement;
end loop;
return N;
-- Another error from which it is hard to recover
- if Nkind_In (Unit_Node, N_Subprogram_Body_Stub, N_Package_Body_Stub) then
+ if Nkind (Unit_Node) in N_Subprogram_Body_Stub | N_Package_Body_Stub then
Cunit_Error_Flag := True;
return Error;
end if;
Unit_Node := Specification (Unit_Node);
end if;
- if Nkind_In (Unit_Node, N_Package_Declaration,
- N_Subprogram_Declaration,
- N_Subprogram_Body,
- N_Subprogram_Renaming_Declaration)
+ if Nkind (Unit_Node) in N_Package_Declaration
+ | N_Subprogram_Declaration
+ | N_Subprogram_Body
+ | N_Subprogram_Renaming_Declaration
then
Unit_Node := Specification (Unit_Node);
end if;
end if;
- if Nkind_In (Unit_Node, N_Task_Body,
- N_Protected_Body,
- N_Task_Type_Declaration,
- N_Protected_Type_Declaration,
- N_Single_Task_Declaration,
- N_Single_Protected_Declaration)
+ if Nkind (Unit_Node) in N_Task_Body
+ | N_Protected_Body
+ | N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
+ | N_Single_Task_Declaration
+ | N_Single_Protected_Declaration
then
Name_Node := Defining_Identifier (Unit_Node);
- elsif Nkind_In (Unit_Node, N_Function_Instantiation,
- N_Function_Specification,
- N_Generic_Function_Renaming_Declaration,
- N_Generic_Package_Renaming_Declaration,
- N_Generic_Procedure_Renaming_Declaration)
- or else
- Nkind_In (Unit_Node, N_Package_Body,
- N_Package_Instantiation,
- N_Package_Renaming_Declaration,
- N_Package_Specification,
- N_Procedure_Instantiation,
- N_Procedure_Specification)
+ elsif Nkind (Unit_Node) in N_Function_Instantiation
+ | N_Function_Specification
+ | N_Generic_Function_Renaming_Declaration
+ | N_Generic_Package_Renaming_Declaration
+ | N_Generic_Procedure_Renaming_Declaration
+ or else Nkind (Unit_Node) in N_Package_Body
+ | N_Package_Instantiation
+ | N_Package_Renaming_Declaration
+ | N_Package_Specification
+ | N_Procedure_Instantiation
+ | N_Procedure_Specification
then
Name_Node := Defining_Unit_Name (Unit_Node);
(Identifier_Seen => Identifier_Seen,
Association => Assoc_Node,
Reserved_Words_OK =>
- Nam_In (Prag_Name, Name_Restriction_Warnings,
- Name_Restrictions));
+ Prag_Name in Name_Restriction_Warnings | Name_Restrictions);
if Arg_Count = 2 and then Import_Check_Required then
-- Here is where we cancel the SIS active status if this pragma
P := P_Pragma;
if Nkind (P) /= N_Error
- and then Nam_In (Pragma_Name_Unmapped (P), Name_Assert, Name_Debug)
+ and then Pragma_Name_Unmapped (P) in Name_Assert | Name_Debug
then
Error_Msg_Name_1 := Pragma_Name_Unmapped (P);
Error_Msg_N
procedure Check_Restricted_Expression (N : Node_Id) is
begin
- if Nkind_In (N, N_Op_And, N_Op_Or, N_Op_Xor, N_And_Then, N_Or_Else) then
+ if Nkind (N) in N_Op_And | N_Op_Or | N_Op_Xor | N_And_Then | N_Or_Else
+ then
Check_Restricted_Expression (Left_Opnd (N));
Check_Restricted_Expression (Right_Opnd (N));
- elsif Nkind_In (N, N_In, N_Not_In)
+ elsif Nkind (N) in N_In | N_Not_In
and then Paren_Count (N) = 0
then
Error_Msg_N ("|this expression must be parenthesized!", N);
-- Complete declaration of mangled subprogram body, for better
-- recovery if analysis is attempted.
- if Nkind_In (Decl, N_Subprogram_Body, N_Package_Body, N_Task_Body)
+ if Nkind (Decl) in N_Subprogram_Body | N_Package_Body | N_Task_Body
and then No (Handled_Statement_Sequence (Decl))
then
Set_Handled_Statement_Sequence (Decl,
Logop := P_Logical_Operator;
Restore_Scan_State (Scan_State); -- to comma/semicolon
- if Nkind_In (Logop, N_And_Then, N_Or_Else) then
+ if Logop in N_And_Then | N_Or_Else then
Scan; -- past comma/semicolon
if Com then
else
if Style_Check and then Paren_Count (Cond) > 0 then
- if not Nkind_In (Cond, N_If_Expression,
- N_Case_Expression,
- N_Quantified_Expression)
+ if Nkind (Cond) not in N_If_Expression
+ | N_Case_Expression
+ | N_Quantified_Expression
or else Paren_Count (Cond) > 1
then
Style.Check_Xtra_Parens (First_Sloc (Cond));
-- with syntactic parentheses.
if not (Paren_Count (Expr) /= 0
- or else Nkind_In (Expr, N_Aggregate,
- N_Extension_Aggregate,
- N_Quantified_Expression))
+ or else Nkind (Expr) in N_Aggregate
+ | N_Extension_Aggregate
+ | N_Quantified_Expression)
then
Error_Msg
("expression function must be enclosed in "
begin
if Nkind (Expression (Arg)) /= N_Identifier
- or else not Nam_In (Chars (Argx), Name_On, Name_Off)
+ or else Chars (Argx) not in Name_On | Name_Off
then
Error_Msg_Name_2 := Name_On;
Error_Msg_Name_3 := Name_Off;
if Ada_Version = Ada_95
and then Warn_On_Ada_2005_Compatibility
then
- if Nam_In (Token_Name, Name_Overriding, Name_Synchronized)
+ if Token_Name in Name_Overriding | Name_Synchronized
or else (Token_Name = Name_Interface
and then Prev_Token /= Tok_Pragma)
then
function Is_Logical_Operator (N : Node_Id) return Tristate is
begin
- if Nkind_In (N, N_And_Then, N_Op_Not, N_Or_Else) then
+ if Nkind (N) in N_And_Then | N_Op_Not | N_Or_Else then
return True;
- elsif Nkind_In (N, N_Op_And, N_Op_Or) then
+ elsif Nkind (N) in N_Op_And | N_Op_Or then
return Unknown;
else
return False;
else
L := Left_Opnd (N);
- if Nkind_In (N, N_Op_Or, N_Or_Else) then
+ if Nkind (N) in N_Op_Or | N_Or_Else then
C1 := '|';
- else pragma Assert (Nkind_In (N, N_Op_And, N_And_Then));
+ else pragma Assert (Nkind (N) in N_Op_And | N_And_Then);
C1 := '&';
end if;
end if;
-- Doesn't this requirement of using First_Sloc need to be
-- documented in the spec ???
- if Nkind_In (Parent (N), N_Accept_Alternative,
- N_Delay_Alternative,
- N_Terminate_Alternative)
+ if Nkind (Parent (N)) in N_Accept_Alternative
+ | N_Delay_Alternative
+ | N_Terminate_Alternative
then
Loc := First_Sloc (N);
else
(Constraint (Subtype_Indication (N)));
if List_Length (Ranges) = 1
- and then
- Nkind_In
- (First (Ranges),
- N_Range,
- N_Real_Range_Specification,
- N_Signed_Integer_Type_Definition)
+ and then Nkind (First (Ranges)) in
+ N_Range |
+ N_Real_Range_Specification |
+ N_Signed_Integer_Type_Definition
then
if Id = Attribute_First then
return
-- If argument does not already account for a closing
-- parenthesis, count one here.
- if not Nkind_In (Right, N_Aggregate,
- N_Quantified_Expression)
+ if Nkind (Right) not in N_Aggregate | N_Quantified_Expression
then
Append_Paren := Append_Paren + 1;
end if;
List_Entities (E, Bytes_Big_Endian, True);
- elsif Ekind_In (E, E_Entry,
- E_Entry_Family,
- E_Subprogram_Type)
+ elsif Ekind (E) in E_Entry
+ | E_Entry_Family
+ | E_Subprogram_Type
then
if List_Representation_Info_Mechanisms then
List_Subprogram_Info (E);
-- Note that formals are not annotated so we skip them here
- elsif Ekind_In (E, E_Constant,
- E_Loop_Parameter,
- E_Variable)
+ elsif Ekind (E) in E_Constant
+ | E_Loop_Parameter
+ | E_Variable
then
if List_Representation_Info >= 2 then
List_Object_Info (E);
-- Recurse into bodies
- elsif Ekind_In (E, E_Package_Body,
- E_Protected_Body,
- E_Protected_Type,
- E_Subprogram_Body,
- E_Task_Body,
- E_Task_Type)
+ elsif Ekind (E) in E_Package_Body
+ | E_Protected_Body
+ | E_Protected_Type
+ | E_Subprogram_Body
+ | E_Task_Body
+ | E_Task_Type
then
List_Entities (E, Bytes_Big_Endian);
-- For type conversion, check converted expression
- elsif Nkind_In (Obj, N_Unchecked_Type_Conversion, N_Type_Conversion) then
+ elsif Nkind (Obj) in N_Unchecked_Type_Conversion | N_Type_Conversion then
Check_No_Implicit_Aliasing (Expression (Obj));
return;
and then Chars (Scope (Ent)) = Name_Ada
and then Scope (Scope (Ent)) = Standard_Standard)
then
- if Nkind_In (Expr, N_Identifier, N_Operator_Symbol)
+ if Nkind (Expr) in N_Identifier | N_Operator_Symbol
and then Chars (Ent) = Chars (Expr)
then
Error_Msg_Node_1 := N;
-- Here if at outer level of entity name in table
- elsif Nkind_In (Expr, N_Identifier, N_Operator_Symbol) then
+ elsif Nkind (Expr) in N_Identifier | N_Operator_Symbol then
exit;
-- Here if neither at the outer level
and then
OK_No_Use_Of_Entity_Name (Selector_Name (N));
- elsif Nkind_In (N, N_Identifier, N_Operator_Symbol) then
+ elsif Nkind (N) in N_Identifier | N_Operator_Symbol then
return True;
else
function Same_Entity (E1, E2 : Node_Id) return Boolean is
begin
- if Nkind_In (E1, N_Identifier, N_Operator_Symbol)
+ if Nkind (E1) in N_Identifier | N_Operator_Symbol
and then
- Nkind_In (E2, N_Identifier, N_Operator_Symbol)
+ Nkind (E2) in N_Identifier | N_Operator_Symbol
then
return Chars (E1) = Chars (E2);
- elsif Nkind_In (E1, N_Selected_Component, N_Expanded_Name)
+ elsif Nkind (E1) in N_Selected_Component | N_Expanded_Name
and then
- Nkind_In (E2, N_Selected_Component, N_Expanded_Name)
+ Nkind (E2) in N_Selected_Component | N_Expanded_Name
then
return Same_Unit (Prefix (E1), Prefix (E2))
and then
if Nkind (U1) = N_Identifier and then Nkind (U2) = N_Identifier then
return Chars (U1) = Chars (U2);
- elsif Nkind_In (U1, N_Selected_Component, N_Expanded_Name)
+ elsif Nkind (U1) in N_Selected_Component | N_Expanded_Name
and then
- Nkind_In (U2, N_Selected_Component, N_Expanded_Name)
+ Nkind (U2) in N_Selected_Component | N_Expanded_Name
then
return Same_Unit (Prefix (U1), Prefix (U2))
and then
-- Now we need to find the direct name and set Boolean2 flag
- if Nkind_In (Entity, N_Identifier, N_Operator_Symbol) then
+ if Nkind (Entity) in N_Identifier | N_Operator_Symbol then
Nam := Entity;
else
pragma Assert (Nkind (Entity) = N_Selected_Component);
Nam := Selector_Name (Entity);
- pragma Assert (Nkind_In (Nam, N_Identifier, N_Operator_Symbol));
+ pragma Assert (Nkind (Nam) in N_Identifier | N_Operator_Symbol);
end if;
Set_Name_Table_Boolean2 (Chars (Nam), True);
return
Nkind (Prf) = N_Identifier
and then
- Nam_In (Chars (Prf), Name_Text_IO,
- Name_Wide_Text_IO,
- Name_Wide_Wide_Text_IO)
+ Chars (Prf) in Name_Text_IO
+ | Name_Wide_Text_IO
+ | Name_Wide_Wide_Text_IO
and then Nkind (Sel) = N_Identifier
and then Chars (Sel) in Text_IO_Package_Name;
end Is_Text_IO_Special_Unit;
null;
when N_SCIL_Membership_Test =>
- pragma Assert (Nkind_In (N, N_Identifier,
- N_And_Then,
- N_Or_Else,
- N_Expression_With_Actions));
+ pragma Assert
+ (Nkind (N) in N_Identifier | N_And_Then | N_Or_Else |
+ N_Expression_With_Actions);
null;
when others =>
-- and because the reference may become overloaded in the instance.
elsif GNATprove_Mode
- and then Nkind_In (N, N_Expanded_Name, N_Identifier)
+ and then Nkind (N) in N_Expanded_Name | N_Identifier
and then not Is_Overloaded (N)
and then not Inside_A_Generic
then
begin
-- Problem does not arise with main subprograms
- if not Nkind_In (MCU, N_Package_Body, N_Package_Declaration) then
+ if Nkind (MCU) not in N_Package_Body | N_Package_Declaration then
return False;
end if;
-- N_Null_Statement will happen in case of a ghost unit
-- which gets rewritten.
- if not Nkind_In
- (Unit (Withed_Unit),
- N_Generic_Package_Declaration,
- N_Package_Body,
- N_Package_Renaming_Declaration,
- N_Subprogram_Body,
- N_Null_Statement)
+ if Nkind (Unit (Withed_Unit)) not in
+ N_Generic_Package_Declaration |
+ N_Package_Body |
+ N_Package_Renaming_Declaration |
+ N_Subprogram_Body |
+ N_Null_Statement
then
Write_Unit_Name
(Unit_Name (Get_Cunit_Unit_Number (Withed_Unit)));
-- Process the unit if it is a spec or the main unit, if it
-- has no previous spec or we have done all other units.
- if not Nkind_In (Item, N_Package_Body, N_Subprogram_Body)
+ if Nkind (Item) not in N_Package_Body | N_Subprogram_Body
or else Acts_As_Spec (CU)
then
if CU = Main_CU and then not Do_Main then
if Nkind (Parent (N)) = N_Assignment_Statement
or else Inside_Init_Proc
or else (Is_Constrained (Typ)
- and then Nkind_In (Parent (N),
- N_Parameter_Association,
- N_Function_Call,
- N_Procedure_Call_Statement,
- N_Generic_Association,
- N_Formal_Object_Declaration,
- N_Simple_Return_Statement,
- N_Object_Declaration,
- N_Component_Declaration,
- N_Parameter_Specification,
- N_Qualified_Expression,
- N_Reference,
- N_Aggregate,
- N_Extension_Aggregate,
- N_Component_Association,
- N_Case_Expression_Alternative,
- N_If_Expression,
- N_Expression_With_Actions))
+ and then Nkind (Parent (N)) in
+ N_Parameter_Association
+ | N_Function_Call
+ | N_Procedure_Call_Statement
+ | N_Generic_Association
+ | N_Formal_Object_Declaration
+ | N_Simple_Return_Statement
+ | N_Object_Declaration
+ | N_Component_Declaration
+ | N_Parameter_Specification
+ | N_Qualified_Expression
+ | N_Reference
+ | N_Aggregate
+ | N_Extension_Aggregate
+ | N_Component_Association
+ | N_Case_Expression_Alternative
+ | N_If_Expression
+ | N_Expression_With_Actions)
then
Aggr_Resolved :=
Resolve_Array_Aggregate
if Is_Character_Type (Component_Typ)
and then No (Next_Index (Nxt_Ind))
- and then Nkind_In (Expr, N_String_Literal, N_Operator_Symbol)
+ and then Nkind (Expr) in N_String_Literal | N_Operator_Symbol
then
-- A string literal used in a multidimensional array
-- aggregate in place of the final one-dimensional
if Ada_Version = Ada_83
and then Assoc /= First (Component_Associations (N))
- and then Nkind_In (Parent (N), N_Assignment_Statement,
- N_Object_Declaration)
+ and then Nkind (Parent (N)) in
+ N_Assignment_Statement | N_Object_Declaration
then
Error_Msg_N
("(Ada 83) illegal context for OTHERS choice", N);
-- The ancestor must be a call or an aggregate, but a call may
-- have been expanded into a temporary, so check original node.
- elsif Nkind_In (Anc, N_Aggregate,
- N_Extension_Aggregate,
- N_Function_Call)
+ elsif Nkind (Anc) in N_Aggregate
+ | N_Extension_Aggregate
+ | N_Function_Call
then
return True;
function Has_Expansion_Delayed (Expr : Node_Id) return Boolean is
begin
return
- (Nkind_In (Expr, N_Aggregate, N_Extension_Aggregate)
+ (Nkind (Expr) in N_Aggregate | N_Extension_Aggregate
and then Present (Etype (Expr))
and then Is_Record_Type (Etype (Expr))
and then Expansion_Delayed (Expr))
(Nkind (Par) = N_Component_Association
or else Nkind (Par) in N_Subexpr)
loop
- if Nkind_In (Par, N_Aggregate, N_Extension_Aggregate) then
+ if Nkind (Par) in N_Aggregate | N_Extension_Aggregate then
if Etype (Par) = Typ then
Set_Has_Self_Reference (Par);
if not In_Spec_Expression
and then not Has_Completion (Scop)
- and then not
- Nkind_In (Parent (N), N_Discriminant_Association,
- N_Index_Or_Discriminant_Constraint)
+ and then
+ Nkind (Parent (N)) not in
+ N_Discriminant_Association |
+ N_Index_Or_Discriminant_Constraint
then
Error_Msg_N
("current instance attribute must appear alone", N);
Kill_Current_Values (Ent);
exit;
- elsif Nkind_In (PP, N_Selected_Component,
- N_Indexed_Component)
+ elsif Nkind (PP) in N_Selected_Component | N_Indexed_Component
then
PP := Prefix (PP);
begin
-- The "Name" argument of pragma Check denotes a postcondition
- if Nam_In (Nam, Name_Post,
- Name_Post_Class,
- Name_Postcondition,
- Name_Refined_Post)
+ if Nam in Name_Post
+ | Name_Post_Class
+ | Name_Postcondition
+ | Name_Refined_Post
then
null;
Prag := N;
while Present (Prag) loop
- if Nkind_In (Prag, N_Aspect_Specification, N_Pragma) then
+ if Nkind (Prag) in N_Aspect_Specification | N_Pragma then
exit;
-- Prevent the search from going too far
-- The attribute is allowed to appear only in postcondition-like
-- aspects or pragmas.
- if Nkind_In (Prag, N_Aspect_Specification, N_Pragma) then
+ if Nkind (Prag) in N_Aspect_Specification | N_Pragma then
if Nkind (Prag) = N_Aspect_Specification then
Prag_Nam := Chars (Identifier (Prag));
else
-- Attribute 'Result is allowed to appear in aspect or pragma
-- [Refined_]Depends (SPARK RM 6.1.5(11)).
- elsif Nam_In (Prag_Nam, Name_Depends, Name_Refined_Depends)
+ elsif Prag_Nam in Name_Depends | Name_Refined_Depends
and then Aname = Name_Result
then
null;
then
null;
- elsif Nam_In (Prag_Nam, Name_Post,
- Name_Post_Class,
- Name_Postcondition,
- Name_Refined_Post)
+ elsif Prag_Nam in Name_Post
+ | Name_Post_Class
+ | Name_Postcondition
+ | Name_Refined_Post
then
null;
then
null;
- elsif not Nkind_In (Subp_Decl, N_Abstract_Subprogram_Declaration,
- N_Entry_Declaration,
- N_Expression_Function,
- N_Generic_Subprogram_Declaration,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub,
- N_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration)
+ elsif Nkind (Subp_Decl) not in N_Abstract_Subprogram_Declaration
+ | N_Entry_Declaration
+ | N_Expression_Function
+ | N_Generic_Subprogram_Declaration
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
+ | N_Subprogram_Declaration
+ | N_Subprogram_Renaming_Declaration
then
return;
end if;
-- the prefix of another attribute. Error is posted on parent.
if Nkind (Parent (N)) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Parent (N)), Name_Address,
- Name_Code_Address,
- Name_Access)
+ and then Attribute_Name (Parent (N)) in Name_Address
+ | Name_Code_Address
+ | Name_Access
then
Error_Msg_Name_1 := Attribute_Name (Parent (N));
Error_Msg_N ("illegal prefix for % attribute", Parent (N));
-- parameter or component association, which is wrong.
if Is_List_Member (N)
- and then not Nkind_In (Parent (N), N_Procedure_Call_Statement,
- N_Aggregate)
+ and then Nkind (Parent (N)) not in
+ N_Procedure_Call_Statement | N_Aggregate
then
null;
else
null;
elsif Is_List_Member (N)
- and then not Nkind_In (Parent (N), N_Procedure_Call_Statement,
- N_Aggregate)
+ and then Nkind (Parent (N)) not in
+ N_Procedure_Call_Statement | N_Aggregate
then
null;
if Nkind (Nod) = N_Identifier then
return;
- elsif Nkind_In (Nod, N_Selected_Component, N_Expanded_Name) then
+ elsif Nkind (Nod) in N_Selected_Component | N_Expanded_Name then
Check_Unit_Name (Prefix (Nod));
if Nkind (Selector_Name (Nod)) = N_Identifier then
-- parameterless call. Entry attributes are handled specially below.
if Is_Entity_Name (P)
- and then not Nam_In (Aname, Name_Count, Name_Caller)
+ and then Aname not in Name_Count | Name_Caller
then
Check_Parameterless_Call (P);
end if;
-- primitive entry wrappers, the attributes Count, and Caller
-- require a context check
- if Nam_In (Aname, Name_Count, Name_Caller) then
+ if Aname in Name_Count | Name_Caller then
declare
Count : Natural := 0;
I : Interp_Index;
begin
Check_E0;
- if Nkind_In (P, N_Identifier, N_Expanded_Name) then
+ if Nkind (P) in N_Identifier | N_Expanded_Name then
Ent := Entity (P);
if not Is_Entry (Ent) then
Check_E0;
if Nkind (P) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (P), Name_Elab_Body, Name_Elab_Spec)
+ and then Attribute_Name (P) in Name_Elab_Body | Name_Elab_Spec
then
null;
begin
Check_E0;
- if Nkind_In (P, N_Identifier, N_Expanded_Name) then
+ if Nkind (P) in N_Identifier | N_Expanded_Name then
Ent := Entity (P);
if Ekind (Ent) /= E_Entry then
exit;
elsif Ekind (Scope (Ent)) in Task_Kind
- and then not Ekind_In (S, E_Block,
- E_Entry,
- E_Entry_Family,
- E_Loop)
+ and then Ekind (S) not in E_Block
+ | E_Entry
+ | E_Entry_Family
+ | E_Loop
then
Error_Attr ("Attribute % cannot appear in inner unit", N);
-- that the pragma appears in an appropriate loop location.
if Nkind (Original_Node (Stmt)) = N_Pragma
- and then Nam_In (Pragma_Name_Unmapped (Original_Node (Stmt)),
- Name_Loop_Invariant,
- Name_Loop_Variant,
- Name_Assert,
- Name_Assert_And_Cut,
- Name_Assume)
+ and then
+ Pragma_Name_Unmapped (Original_Node (Stmt))
+ in Name_Loop_Invariant
+ | Name_Loop_Variant
+ | Name_Assert
+ | Name_Assert_And_Cut
+ | Name_Assume
then
Encl_Prag := Original_Node (Stmt);
if Ekind (Scop) = E_Loop and then Scop = Loop_Id then
exit;
- elsif Ekind_In (Scop, E_Block, E_Loop, E_Return_Statement) then
+ elsif Ekind (Scop) in E_Block | E_Loop | E_Return_Statement then
null;
else
Error_Attr
-- another attribute 'Old.
if Nkind (Nod) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Nod), Name_Old,
- Name_Result)
+ and then Attribute_Name (Nod) in Name_Old | Name_Result
then
Error_Msg_Name_1 := Attribute_Name (Nod);
Error_Msg_Name_2 := Name_Old;
then
Pref_Id := Entity (Name (P));
- if Ekind_In (Spec_Id, E_Function, E_Generic_Function)
+ if Ekind (Spec_Id) in E_Function | E_Generic_Function
and then Pref_Id = Spec_Id
then
Error_Msg_Warn := SPARK_Mode /= On;
elsif Nkind (Subp_Spec) = N_Function_Specification
and then Present (Generic_Parent (Subp_Spec))
- and then Ekind_In (Pref_Id, E_Generic_Function, E_Function)
+ and then Ekind (Pref_Id) in E_Generic_Function | E_Function
then
if Generic_Parent (Subp_Spec) = Pref_Id then
return True;
-- functions, or the prefix must be generic and the spec
-- must be nongeneric (i.e. it must denote an instance).
- if (Ekind_In (Pref_Id, E_Function, E_Generic_Function)
+ if (Ekind (Pref_Id) in E_Function | E_Generic_Function
and then Ekind (Pref_Id) = Ekind (Spec_Id))
or else
(Ekind (Pref_Id) = E_Generic_Function
Negative := False;
end if;
- if not Nkind_In (Expr, N_Integer_Literal, N_Real_Literal) then
+ if Nkind (Expr) not in N_Integer_Literal | N_Real_Literal then
Error_Attr
("named number for % attribute must be simple literal", N);
end if;
begin
-- P'Enum_Rep case
- if Ekind_In (Entity (P), E_Constant,
- E_Enumeration_Literal)
+ if Ekind (Entity (P)) in E_Constant | E_Enumeration_Literal
then
Enum_Expr := P;
-- Second foldable possibility is an array object (RM 4.9(8))
- elsif Ekind_In (P_Entity, E_Variable, E_Constant)
+ elsif Ekind (P_Entity) in E_Variable | E_Constant
and then Is_Array_Type (Etype (P_Entity))
and then (not Is_Generic_Type (Etype (P_Entity)))
then
-- An exception is the GNAT attribute Constrained_Array which is
-- defined to be a static attribute in all cases.
- if Nkind_In (N, N_Integer_Literal,
- N_Real_Literal,
- N_Character_Literal,
- N_String_Literal)
+ if Nkind (N) in N_Integer_Literal
+ | N_Real_Literal
+ | N_Character_Literal
+ | N_String_Literal
or else (Is_Entity_Name (N)
and then Ekind (Entity (N)) = E_Enumeration_Literal)
then
if Is_Record_Type (Current_Scope)
and then
- Nkind_In (Parent (N), N_Discriminant_Association,
- N_Index_Or_Discriminant_Constraint)
+ Nkind (Parent (N)) in N_Discriminant_Association
+ | N_Index_Or_Discriminant_Constraint
then
Indic := Parent (Parent (N));
while Present (Indic)
begin
loop
- if Nkind_In (PP, N_Selected_Component,
- N_Indexed_Component)
- then
+ if Nkind (PP) in N_Selected_Component | N_Indexed_Component then
PP := Prefix (PP);
elsif Comes_From_Source (PP)
- and then Nkind_In (PP, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ and then Nkind (PP) in N_Type_Conversion
+ | N_Unchecked_Type_Conversion
and then Is_Array_Type (Etype (PP))
then
return False;
elsif Comes_From_Source (PP)
and then Nkind (PP) = N_Qualified_Expression
and then Is_Array_Type (Etype (PP))
- and then Nkind_In (Original_Node (Expression (PP)),
- N_Aggregate,
- N_Extension_Aggregate)
+ and then Nkind (Original_Node (Expression (PP))) in
+ N_Aggregate | N_Extension_Aggregate
then
return False;
-- test, which breaks several filed tests???
if Ekind (Typ) = E_Anonymous_Access_Type
- and then Nkind_In (Parent (N), N_Op_Eq, N_Op_Ne)
+ and then Nkind (Parent (N)) in N_Op_Eq | N_Op_Ne
and then False
then
Error_Msg_N ("need unique type to resolve 'Access", N);
-- also be accessibility checks on those, this is where the
-- checks can eventually be centralized ???
- if Ekind_In (Btyp, E_Access_Protected_Subprogram_Type,
- E_Access_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type,
- E_Anonymous_Access_Subprogram_Type)
+ if Ekind (Btyp) in E_Access_Protected_Subprogram_Type
+ | E_Access_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
+ | E_Anonymous_Access_Subprogram_Type
then
-- Deal with convention mismatch
end if;
end if;
- if Ekind_In (Btyp, E_Access_Protected_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type)
+ if Ekind (Btyp) in E_Access_Protected_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
then
if Is_Entity_Name (P)
and then not Is_Protected_Type (Scope (Entity (P)))
Check_Internal_Protected_Use (N, Entity (P));
end if;
- elsif Ekind_In (Btyp, E_Access_Subprogram_Type,
- E_Anonymous_Access_Subprogram_Type)
+ elsif Ekind (Btyp) in E_Access_Subprogram_Type
+ | E_Anonymous_Access_Subprogram_Type
and then Ekind (Etype (N)) = E_Access_Protected_Subprogram_Type
then
Error_Msg_F ("context requires a non-protected subprogram", P);
and then Comes_From_Source (Subp_Id)
and then Comes_From_Source (N)
and then In_Open_Scopes (Scop)
- and then Ekind_In (Scop, E_Block, E_Procedure, E_Function)
+ and then Ekind (Scop) in E_Block | E_Procedure | E_Function
and then not Has_Completion (Subp_Id)
and then No (Elaboration_Entity (Subp_Id))
and then Nkind (Subp_Decl) = N_Subprogram_Declaration
begin
pragma Assert
- (Nkind_In (N, N_Aspect_Specification,
- N_Attribute_Definition_Clause,
- N_Enumeration_Representation_Clause,
- N_Pragma,
- N_Record_Representation_Clause));
+ (Nkind (N) in N_Aspect_Specification
+ | N_Attribute_Definition_Clause
+ | N_Enumeration_Representation_Clause
+ | N_Pragma
+ | N_Record_Representation_Clause);
Item := First_Rep_Item (E);
while Present (Item) loop
function Is_Body (N : Node_Id) return Boolean is
begin
- return
- Nkind (N) in N_Body_Stub
- or else Nkind_In (N, N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body);
+ return Nkind (N) in
+ N_Body_Stub | N_Entry_Body | N_Package_Body | N_Protected_Body |
+ N_Subprogram_Body | N_Task_Body;
end Is_Body;
---------------------
Kind := Nkind (Original_Node (Parent (E)));
return
- Nkind_In (Kind, N_Formal_Object_Declaration,
- N_Formal_Type_Declaration)
+ Kind in N_Formal_Object_Declaration | N_Formal_Type_Declaration
or else Is_Formal_Subprogram (E)
or else
(Ekind (E) = E_Package
if Ekind (E) in Subprogram_Kind then
Declaration := Unit_Declaration_Node (E);
- if Nkind_In (Declaration, N_Subprogram_Body,
- N_Subprogram_Renaming_Declaration)
+ if Nkind (Declaration) in
+ N_Subprogram_Body | N_Subprogram_Renaming_Declaration
then
Specification := Corresponding_Spec (Declaration);
end if;
-- Body of RCI unit does not need validation
if Is_Remote_Call_Interface (E)
- and then Nkind_In (N, N_Package_Body, N_Subprogram_Body)
+ and then Nkind (N) in N_Package_Body | N_Subprogram_Body
then
return;
end if;
null;
- elsif Ekind_In (Param_Type, E_Anonymous_Access_Type,
- E_Anonymous_Access_Subprogram_Type)
+ elsif Ekind (Param_Type) in E_Anonymous_Access_Type
+ | E_Anonymous_Access_Subprogram_Type
then
-- From RM E.2.2(14), no anonymous access parameter other than
-- controlling ones may be used (because an anonymous access
("limited type not allowed in rci unit", Parent (E));
Explain_Limited_Type (E, Parent (E));
- elsif Ekind_In (E, E_Generic_Function,
- E_Generic_Package,
- E_Generic_Procedure)
+ elsif Ekind (E) in E_Generic_Function
+ | E_Generic_Package
+ | E_Generic_Procedure
then
Error_Msg_N ("generic declaration not allowed in rci unit",
Parent (E));
elsif Nkind (Cont_Item) = N_Pragma
and then
- Nam_In (Pragma_Name_Unmapped (Cont_Item),
- Name_Elaborate, Name_Elaborate_All)
+ Pragma_Name_Unmapped (Cont_Item)
+ in Name_Elaborate | Name_Elaborate_All
and then not Used_Type_Or_Elab
then
Prag_Unit :=
-- Verify that the library unit is a package declaration
- if not Nkind_In (Unit (Lib_Unit), N_Package_Declaration,
- N_Generic_Package_Declaration)
+ if Nkind (Unit (Lib_Unit)) not in
+ N_Package_Declaration | N_Generic_Package_Declaration
then
Error_Msg_N
("no legal package declaration for package body", N);
-- Analyze the contract of a [generic] subprogram that acts as a
-- compilation unit after all compilation pragmas have been analyzed.
- if Nkind_In (Unit_Node, N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration)
+ if Nkind (Unit_Node) in
+ N_Generic_Subprogram_Declaration | N_Subprogram_Declaration
then
Analyze_Entry_Or_Subprogram_Contract (Defining_Entity (Unit_Node));
end if;
-- next compilation, which is either the main unit or some other unit
-- in the context.
- if Nkind_In (Unit_Node, N_Package_Declaration,
- N_Package_Renaming_Declaration,
- N_Subprogram_Declaration)
- or else Nkind (Unit_Node) in N_Generic_Declaration
+ if Nkind (Unit_Node) in N_Package_Declaration
+ | N_Package_Renaming_Declaration
+ | N_Subprogram_Declaration
+ | N_Generic_Declaration
or else (Nkind (Unit_Node) = N_Subprogram_Body
and then Acts_As_Spec (Unit_Node))
then
-- are triggered by these subprograms.
if GNATprove_Mode
- and then Nkind_In (Unit_Node, N_Function_Instantiation,
- N_Procedure_Instantiation,
- N_Subprogram_Body)
+ and then Nkind (Unit_Node) in N_Function_Instantiation
+ | N_Procedure_Instantiation
+ | N_Subprogram_Body
then
declare
Spec : Node_Id;
-- units manufactured by the compiler never need elab checks.
if Comes_From_Source (N)
- and then Nkind_In (Unit_Node, N_Package_Declaration,
- N_Generic_Package_Declaration,
- N_Subprogram_Declaration,
- N_Generic_Subprogram_Declaration)
+ and then Nkind (Unit_Node) in N_Package_Declaration
+ | N_Generic_Package_Declaration
+ | N_Subprogram_Declaration
+ | N_Generic_Subprogram_Declaration
then
declare
Loc : constant Source_Ptr := Sloc (N);
-- Verify that the illegal contexts given in 10.1.2 (18/2) are
-- properly rejected, including renaming declarations.
- if not Nkind_In (Ukind, N_Package_Declaration,
- N_Subprogram_Declaration)
- and then Ukind not in N_Generic_Declaration
- and then Ukind not in N_Generic_Instantiation
+ if Ukind not in N_Package_Declaration
+ | N_Subprogram_Declaration
+ | N_Generic_Declaration
+ | N_Generic_Instantiation
then
Error_Msg_N ("limited with_clause not allowed here", Item);
if Item /= It
and then Nkind (It) = N_With_Clause
and then not Limited_Present (It)
- and then
- Nkind_In (Unit (Library_Unit (It)),
- N_Package_Declaration,
- N_Package_Renaming_Declaration)
+ and then Nkind (Unit (Library_Unit (It))) in
+ N_Package_Declaration |
+ N_Package_Renaming_Declaration
then
if Nkind (Unit (Library_Unit (It))) =
N_Package_Declaration
-- Verify that the identifier for the stub is unique within this
-- declarative part.
- if Nkind_In (Parent (N), N_Block_Statement,
- N_Package_Body,
- N_Subprogram_Body)
+ if Nkind (Parent (N)) in
+ N_Block_Statement | N_Package_Body | N_Subprogram_Body
then
Decl := First (Declarations (Parent (N)));
while Present (Decl) and then Decl /= N loop
Remove_Scope;
end if;
- if Nkind_In (Unit (Lib_Spec), N_Package_Body,
- N_Subprogram_Body)
+ if Nkind (Unit (Lib_Spec)) in N_Package_Body | N_Subprogram_Body
then
Remove_Context (Library_Unit (Lib_Spec));
end if;
if Nkind (Nam) = N_Selected_Component
and then Nkind (Prefix (Nam)) = N_Identifier
and then Chars (Prefix (Nam)) = Name_Gnat
- and then Nam_In (Chars (Selector_Name (Nam)),
- Name_Most_Recent_Exception,
- Name_Exception_Traces)
+ and then Chars (Selector_Name (Nam))
+ in Name_Most_Recent_Exception | Name_Exception_Traces
then
Check_Restriction (No_Exception_Propagation, N);
Special_Exception_Package_Used := True;
-- Start of processing for Check_Private_Child_Unit
begin
- if Nkind_In (Lib_Unit, N_Package_Body, N_Subprogram_Body) then
+ if Nkind (Lib_Unit) in N_Package_Body | N_Subprogram_Body then
Curr_Unit := Defining_Entity (Unit (Library_Unit (N)));
Par_Lib := Curr_Unit;
elsif Curr_Private
or else Private_Present (Item)
- or else Nkind_In (Lib_Unit, N_Package_Body, N_Subunit)
+ or else Nkind (Lib_Unit) in N_Package_Body | N_Subunit
or else (Nkind (Lib_Unit) = N_Subprogram_Body
and then not Acts_As_Spec (Parent (Lib_Unit)))
then
Kind : constant Node_Kind := Nkind (Par);
begin
- if Nkind_In (Kind, N_Package_Body,
- N_Subprogram_Body,
- N_Task_Body,
- N_Protected_Body)
- and then Nkind_In (Parent (Par), N_Compilation_Unit, N_Subunit)
+ if Kind in
+ N_Package_Body | N_Subprogram_Body | N_Task_Body | N_Protected_Body
+ and then Nkind (Parent (Par)) in N_Compilation_Unit | N_Subunit
then
null;
-- on a child unit implies that the implicit with on the parent is also
-- private.
- if Nkind_In (Unit (N), N_Generic_Package_Declaration,
- N_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration,
- N_Subprogram_Body)
+ if Nkind (Unit (N)) in N_Generic_Package_Declaration
+ | N_Package_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Subprogram_Declaration
+ | N_Subprogram_Body
then
Set_Private_Present (Withn, Private_Present (Item));
end if;
Install_Siblings (Defining_Entity (Unit (Library_Unit (N))), N);
end if;
- if Nkind_In (Lib_Unit, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Declaration,
- N_Subprogram_Declaration)
+ if Nkind (Lib_Unit) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Package_Declaration
+ | N_Subprogram_Declaration
then
if Is_Child_Spec (Lib_Unit) then
Lib_Parent := Defining_Entity (Unit (Parent_Spec (Lib_Unit)));
elsif Private_Present (Parent (Item))
or else Curr_Private
or else Private_Present (Item)
- or else Nkind_In (Unit (Parent (Item)), N_Package_Body,
- N_Subprogram_Body,
- N_Subunit)
+ or else Nkind (Unit (Parent (Item))) in
+ N_Package_Body | N_Subprogram_Body | N_Subunit
then
-- Current unit is private, of descendant of a private unit
then
if not Private_Present (Item)
or else Private_Present (N)
- or else Nkind_In (Unit (N), N_Package_Body,
- N_Subprogram_Body,
- N_Subunit)
+ or else Nkind (Unit (N)) in
+ N_Package_Body | N_Subprogram_Body | N_Subunit
then
Install_Limited_With_Clause (Item);
end if;
end if;
if Ekind (P_Name) = E_Generic_Package
- and then not Nkind_In (Lib_Unit, N_Generic_Subprogram_Declaration,
- N_Generic_Package_Declaration)
- and then Nkind (Lib_Unit) not in N_Generic_Renaming_Declaration
+ and then Nkind (Lib_Unit) not in N_Generic_Subprogram_Declaration
+ | N_Generic_Package_Declaration
+ | N_Generic_Renaming_Declaration
then
Error_Msg_N
("child of a generic package must be a generic unit", Lib_Unit);
-- Save for subsequent examination of import pragmas.
if Comes_From_Source (Decl)
- and then (Nkind_In (Decl, N_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration,
- N_Generic_Subprogram_Declaration))
+ and then (Nkind (Decl) in N_Subprogram_Declaration
+ | N_Subprogram_Renaming_Declaration
+ | N_Generic_Subprogram_Declaration)
then
Append_Elmt (Defining_Entity (Decl), Subp_List);
-- Package declaration of generic package declaration. We need
-- to recursively examine nested declarations.
- elsif Nkind_In (Decl, N_Package_Declaration,
- N_Generic_Package_Declaration)
+ elsif Nkind (Decl) in N_Package_Declaration
+ | N_Generic_Package_Declaration
then
Check_Declarations (Specification (Decl));
Decl := First (Private_Declarations (Spec));
while Present (Decl) loop
if Comes_From_Source (Decl)
- and then (Nkind_In (Decl, N_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration,
- N_Generic_Subprogram_Declaration))
+ and then Nkind (Decl) in N_Subprogram_Declaration
+ | N_Subprogram_Renaming_Declaration
+ | N_Generic_Subprogram_Declaration
then
Append_Elmt (Defining_Entity (Decl), Subp_List);
- elsif Nkind_In (Decl, N_Package_Declaration,
- N_Generic_Package_Declaration)
+ elsif Nkind (Decl) in N_Package_Declaration
+ | N_Generic_Package_Declaration
then
Check_Declarations (Specification (Decl));
-- corresponding spec, otherwise follow pointer to parent spec.
if Present (Library_Unit (Aux_Unit))
- and then Nkind_In (Unit (Aux_Unit),
- N_Package_Body, N_Subprogram_Body)
+ and then Nkind (Unit (Aux_Unit)) in
+ N_Package_Body | N_Subprogram_Body
then
if Aux_Unit = Library_Unit (Aux_Unit) then
E1 : constant Entity_Id := Defining_Entity (Unit (U1));
E2 : Entity_Id;
begin
- if Nkind_In (Unit (U2), N_Package_Body, N_Subprogram_Body) then
+ if Nkind (Unit (U2)) in N_Package_Body | N_Subprogram_Body then
E2 := Defining_Entity (Unit (Library_Unit (U2)));
return Is_Ancestor_Package (E1, E2);
else
-- Types
- elsif Nkind_In (Decl, N_Full_Type_Declaration,
- N_Incomplete_Type_Declaration,
- N_Private_Extension_Declaration,
- N_Private_Type_Declaration,
- N_Protected_Type_Declaration,
- N_Task_Type_Declaration)
+ elsif Nkind (Decl) in N_Full_Type_Declaration
+ | N_Incomplete_Type_Declaration
+ | N_Private_Extension_Declaration
+ | N_Private_Type_Declaration
+ | N_Protected_Type_Declaration
+ | N_Task_Type_Declaration
then
Def_Id := Defining_Entity (Decl);
(Nkind (Def) = N_Derived_Type_Definition
and then Present (Record_Extension_Part (Def)));
- elsif Nkind_In (Decl, N_Incomplete_Type_Declaration,
- N_Private_Type_Declaration)
+ elsif Nkind (Decl) in N_Incomplete_Type_Declaration
+ | N_Private_Type_Declaration
then
Is_Tagged := Tagged_Present (Decl);
then
Set_Body_Needed_For_SAL (Unit_Name);
- elsif Ekind_In (Unit_Name, E_Generic_Procedure, E_Generic_Function) then
+ elsif Ekind (Unit_Name) in E_Generic_Procedure | E_Generic_Function then
Set_Body_Needed_For_SAL (Unit_Name);
elsif Is_Subprogram (Unit_Name)
if ((Is_Subprogram (Current_Scope) or else Is_Entry (Current_Scope))
and then Chars (Current_Scope) /= Name_uPostconditions)
- or else Ekind_In (Current_Scope, E_Block, E_Task_Type)
+ or else Ekind (Current_Scope) in E_Block | E_Task_Type
then
Warn_On_Useless_Assignments (Current_Scope);
end if;
-- Skip past null statements and pragmas
while Present (P)
- and then Nkind_In (P, N_Null_Statement, N_Pragma)
+ and then Nkind (P) in N_Null_Statement | N_Pragma
loop
P := Prev (P);
end loop;
if No (Exception_Id) then
P := Parent (N);
- while not Nkind_In (P, N_Exception_Handler,
- N_Subprogram_Body,
- N_Package_Body,
- N_Task_Body,
- N_Entry_Body)
+ while Nkind (P) not in
+ N_Exception_Handler | N_Subprogram_Body | N_Package_Body |
+ N_Task_Body | N_Entry_Body
loop
P := Parent (P);
end loop;
(Defining_Unit_Name (Specification (Analyzed_Formal)));
when N_Formal_Package_Declaration =>
- exit when Nkind_In (Kind, N_Formal_Package_Declaration,
- N_Generic_Package_Declaration,
- N_Package_Declaration);
+ exit when Kind in N_Formal_Package_Declaration
+ | N_Generic_Package_Declaration
+ | N_Package_Declaration;
when N_Use_Package_Clause
| N_Use_Type_Clause
exit when
Kind not in N_Formal_Subprogram_Declaration
- and then not Nkind_In (Kind, N_Subprogram_Declaration,
- N_Freeze_Entity,
- N_Null_Statement,
- N_Itype_Reference)
+ and then Kind not in N_Subprogram_Declaration
+ | N_Freeze_Entity
+ | N_Null_Statement
+ | N_Itype_Reference
and then Chars (Defining_Identifier (Formal)) =
Chars (Defining_Identifier (Analyzed_Formal));
end case;
S := Current_Scope;
while Present (S) loop
- if Ekind_In (S, E_Block,
- E_Function,
- E_Loop,
- E_Procedure)
+ if Ekind (S) in E_Block
+ | E_Function
+ | E_Loop
+ | E_Procedure
then
Needs_Freezing := False;
exit;
if Nkind (Def) = N_Constrained_Array_Definition then
DSS := First (Discrete_Subtype_Definitions (Def));
while Present (DSS) loop
- if Nkind_In (DSS, N_Subtype_Indication,
- N_Range,
- N_Attribute_Reference)
+ if Nkind (DSS) in N_Subtype_Indication
+ | N_Range
+ | N_Attribute_Reference
then
Error_Msg_N ("only a subtype mark is allowed in a formal", DSS);
end if;
while Present (S) and then S /= Standard_Standard loop
if Is_Generic_Instance (S)
and then (In_Package_Body (S)
- or else Ekind_In (S, E_Procedure, E_Function))
+ or else Ekind (S) in E_Procedure | E_Function)
then
-- We still have to remove the entities of the enclosing
-- instance from direct visibility.
Set_Is_Generic_Instance (Inst, True);
if In_Package_Body (Inst)
- or else Ekind_In (S, E_Procedure, E_Function)
+ or else Ekind (S) in E_Procedure | E_Function
then
E := First_Entity (Instances (J));
while Present (E) loop
if Nkind (Assoc) /= Nkind (N) then
return Assoc;
- elsif Nkind_In (Assoc, N_Aggregate, N_Extension_Aggregate) then
+ elsif Nkind (Assoc) in N_Aggregate | N_Extension_Aggregate then
return Assoc;
else
if (Nkind (Assoc) = N_Identifier or else Nkind (Assoc) in N_Op)
and then Present (Associated_Node (Assoc))
- and then (Nkind_In (Associated_Node (Assoc), N_Function_Call,
- N_Explicit_Dereference,
- N_Integer_Literal,
- N_Real_Literal,
- N_String_Literal))
+ and then Nkind (Associated_Node (Assoc)) in N_Function_Call
+ | N_Explicit_Dereference
+ | N_Integer_Literal
+ | N_Real_Literal
+ | N_String_Literal
then
Assoc := Associated_Node (Assoc);
end if;
if Kind = N_Formal_Type_Declaration then
return;
- elsif Nkind_In (Kind, N_Formal_Object_Declaration,
- N_Formal_Package_Declaration)
- or else Kind in N_Formal_Subprogram_Declaration
+ elsif Kind in N_Formal_Object_Declaration
+ | N_Formal_Package_Declaration
+ | N_Formal_Subprogram_Declaration
then
null;
-- If the formal entity comes from a formal declaration, it was
-- defaulted in the formal package, and no check is needed on it.
- elsif Nkind_In (Original_Node (Parent (E2)),
- N_Formal_Object_Declaration,
- N_Formal_Type_Declaration)
+ elsif Nkind (Original_Node (Parent (E2))) in
+ N_Formal_Object_Declaration | N_Formal_Type_Declaration
then
-- If the formal is a tagged type the corresponding class-wide
-- type has been generated as well, and it must be skipped.
-- Special casing for identifiers and other entity names and operators
- if Nkind_In (New_N, N_Character_Literal,
- N_Expanded_Name,
- N_Identifier,
- N_Operator_Symbol)
- or else Nkind (New_N) in N_Op
+ if Nkind (New_N) in N_Character_Literal
+ | N_Expanded_Name
+ | N_Identifier
+ | N_Operator_Symbol
+ | N_Op
then
if not Instantiating then
end if;
elsif No (Ent)
- or else
- not Nkind_In (Ent, N_Defining_Identifier,
- N_Defining_Character_Literal,
- N_Defining_Operator_Symbol)
+ or else Nkind (Ent) not in N_Defining_Identifier
+ | N_Defining_Character_Literal
+ | N_Defining_Operator_Symbol
or else No (Scope (Ent))
or else
(Scope (Ent) = Current_Instantiated_Parent.Gen_Id
then
Set_Entity (New_N, Entity (Name (Assoc)));
- elsif Nkind_In (Assoc, N_Defining_Identifier,
- N_Defining_Character_Literal,
- N_Defining_Operator_Symbol)
+ elsif Nkind (Assoc) in N_Defining_Identifier
+ | N_Defining_Character_Literal
+ | N_Defining_Operator_Symbol
and then Expander_Active
then
-- Inlining case: we are copying a tree that contains
Set_Assignment_OK (Name (New_N), True);
end if;
- elsif Nkind_In (N, N_Aggregate, N_Extension_Aggregate) then
+ elsif Nkind (N) in N_Aggregate | N_Extension_Aggregate then
if not Instantiating then
Set_Associated_Node (N, New_N);
-- Do not copy Comment or Ident pragmas their content is relevant to
-- the generic unit, not to the instantiating unit.
- if Nam_In (Pragma_Name_Unmapped (N), Name_Comment, Name_Ident) then
+ if Pragma_Name_Unmapped (N) in Name_Comment | Name_Ident then
New_N := Make_Null_Statement (Sloc (N));
-- Do not copy pragmas generated from aspects because the pragmas do
Copy_Descendants;
end if;
- elsif Nkind_In (N, N_Integer_Literal, N_Real_Literal) then
+ elsif Nkind (N) in N_Integer_Literal | N_Real_Literal then
-- No descendant fields need traversing
else
Inst := Next (Decl);
- while not Nkind_In (Inst, N_Formal_Package_Declaration,
- N_Function_Instantiation,
- N_Package_Instantiation,
- N_Procedure_Instantiation)
+ while Nkind (Inst) not in N_Formal_Package_Declaration
+ | N_Function_Instantiation
+ | N_Package_Instantiation
+ | N_Procedure_Instantiation
loop
Next (Inst);
end loop;
while Present (P)
and then Nkind (Parent (P)) /= N_Compilation_Unit
loop
- if Nkind_In (P, N_Package_Body, N_Subprogram_Body) then
+ if Nkind (P) in N_Package_Body | N_Subprogram_Body then
if Nkind (Parent (P)) = N_Subunit then
return Corresponding_Stub (Parent (P));
else
-- the current scope as well.
elsif Present (Next (N))
- and then Nkind_In (Next (N), N_Subprogram_Body,
- N_Package_Body)
+ and then Nkind (Next (N)) in N_Subprogram_Body
+ | N_Package_Body
and then Comes_From_Source (Next (N))
then
null;
Must_Delay :=
(Gen_Unit = Act_Unit
- and then (Nkind_In (Gen_Unit, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ and then (Nkind (Gen_Unit) in N_Generic_Package_Declaration
+ | N_Package_Declaration
or else (Gen_Unit = Body_Unit
and then True_Sloc (N, Act_Unit) <
Sloc (Orig_Body)))
-- Freeze package enclosing instance of inner generic after
-- instance of enclosing generic.
- elsif Nkind_In (Parent (N), N_Package_Body, N_Subprogram_Body)
+ elsif Nkind (Parent (N)) in N_Package_Body | N_Subprogram_Body
and then In_Same_Declarative_Part
(Parent (Freeze_Node (Par)), Parent (N))
then
end if;
if (Present (Act_E) and then Is_Overloadable (Act_E))
- or else Nkind_In (Act, N_Attribute_Reference,
- N_Indexed_Component,
- N_Character_Literal,
- N_Explicit_Dereference)
+ or else Nkind (Act) in N_Attribute_Reference
+ | N_Indexed_Component
+ | N_Character_Literal
+ | N_Explicit_Dereference
then
return;
end if;
Nam := Actual;
elsif Present (Default_Name (Formal)) then
- if not Nkind_In (Default_Name (Formal), N_Attribute_Reference,
- N_Selected_Component,
- N_Indexed_Component,
- N_Character_Literal)
+ if Nkind (Default_Name (Formal)) not in N_Attribute_Reference
+ | N_Selected_Component
+ | N_Indexed_Component
+ | N_Character_Literal
and then Present (Entity (Default_Name (Formal)))
then
Nam := New_Occurrence_Of (Entity (Default_Name (Formal)), Loc);
if Ada_Version >= Ada_2005
and then Present (Actual_Decl)
- and then Nkind_In (Actual_Decl, N_Formal_Object_Declaration,
- N_Object_Declaration)
+ and then Nkind (Actual_Decl) in N_Formal_Object_Declaration
+ | N_Object_Declaration
and then Nkind (Analyzed_Formal) = N_Formal_Object_Declaration
and then not Has_Null_Exclusion (Actual_Decl)
and then Has_Null_Exclusion (Analyzed_Formal)
Root_Type (Act_T)))
or else
- (Ekind_In (Gen_T, E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Type)
+ (Ekind (Gen_T) in E_Anonymous_Access_Subprogram_Type
+ | E_Anonymous_Access_Type
and then Ekind (Act_T) = Ekind (Gen_T)
and then Subtypes_Statically_Match
(Designated_Type (Gen_T), Designated_Type (Act_T)));
Set_Generic_Parent_Type (Decl_Node, Ancestor);
end if;
- elsif Nkind_In (Def, N_Formal_Private_Type_Definition,
- N_Formal_Incomplete_Type_Definition)
+ elsif Nkind (Def) in N_Formal_Private_Type_Definition
+ | N_Formal_Incomplete_Type_Definition
then
Set_Generic_Parent_Type (Decl_Node, A_Gen_T);
end if;
-- For a subprogram instantiation, omit instantiations intrinsic
-- operations (Unchecked_Conversions, etc.) that have no bodies.
- elsif Nkind_In (Decl, N_Function_Instantiation,
- N_Procedure_Instantiation)
+ elsif Nkind (Decl) in N_Function_Instantiation
+ | N_Procedure_Instantiation
and then not Is_Intrinsic_Subprogram (Entity (Name (Decl)))
then
Append_Elmt (Decl, Previous_Instances);
(Last (Visible_Declarations
(Specification (Info.Act_Decl))));
begin
- while Nkind_In (Decl,
- N_Null_Statement,
- N_Pragma,
- N_Subprogram_Renaming_Declaration)
+ while Nkind (Decl) in
+ N_Null_Statement |
+ N_Pragma |
+ N_Subprogram_Renaming_Declaration
loop
Decl := Prev (Decl);
end loop;
-- explicitly now, in order to remain consistent with the view of the
-- parent type.
- if Ekind_In (Typ, E_Private_Type,
- E_Limited_Private_Type,
- E_Record_Type_With_Private)
+ if Ekind (Typ) in E_Private_Type
+ | E_Limited_Private_Type
+ | E_Record_Type_With_Private
then
Dep_Elmt := First_Elmt (Private_Dependents (Typ));
while Present (Dep_Elmt) loop
-- preserve in this case, since the expansion will be redone in
-- the instance.
- if not Nkind_In (E, N_Defining_Character_Literal,
- N_Defining_Identifier,
- N_Defining_Operator_Symbol)
+ if Nkind (E) not in N_Defining_Character_Literal
+ | N_Defining_Identifier
+ | N_Defining_Operator_Symbol
then
Set_Associated_Node (N, Empty);
Set_Etype (N, Empty);
-- its value. Otherwise the folding will happen in any instantiation.
elsif Nkind (Parent (N)) = N_Selected_Component
- and then Nkind_In (Parent (N2), N_Integer_Literal, N_Real_Literal)
+ and then Nkind (Parent (N2)) in N_Integer_Literal | N_Real_Literal
then
if Present (Entity (Original_Node (Parent (N2))))
and then Is_Global (Entity (Original_Node (Parent (N2))))
-- global references within their aspects due to the timing of
-- annotation analysis.
- if Nkind_In (Nod, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Body,
- N_Package_Body_Stub,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub)
+ if Nkind (Nod) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Package_Body
+ | N_Package_Body_Stub
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
then
-- Since the capture of global references is done on the
-- unanalyzed generic template, there is no information around
-- constant folding which will be repeated in the instance.
-- Is this still needed???
- elsif Nkind_In (N2, N_Integer_Literal, N_Real_Literal)
+ elsif Nkind (N2) in N_Integer_Literal | N_Real_Literal
and then Is_Entity_Name (Original_Node (N2))
then
Set_Associated_Node (N, Original_Node (N2));
-- The operator was folded into a literal
- elsif Nkind_In (N2, N_Integer_Literal,
- N_Real_Literal,
- N_String_Literal)
+ elsif Nkind (N2) in N_Integer_Literal
+ | N_Real_Literal
+ | N_String_Literal
then
if Present (Original_Node (N2))
and then Nkind (Original_Node (N2)) = Nkind (N)
-- Aggregates
- elsif Nkind_In (N, N_Aggregate, N_Extension_Aggregate) then
+ elsif Nkind (N) in N_Aggregate | N_Extension_Aggregate then
Save_References_In_Aggregate (N);
-- Character literals, operator symbols
- elsif Nkind_In (N, N_Character_Literal, N_Operator_Symbol) then
+ elsif Nkind (N) in N_Character_Literal | N_Operator_Symbol then
Save_References_In_Char_Lit_Or_Op_Symbol (N);
-- Defining identifiers
function Find_Type (N : Node_Id) return Traverse_Result is
begin
if N = Typ
- or else (Nkind_In (N, N_Identifier, N_Expanded_Name)
+ or else (Nkind (N) in N_Identifier | N_Expanded_Name
and then Present (Entity (N))
and then Entity (N) = Typ)
then
-- package body Pack is
-- pragma Prag;
- if Nkind_In (N, N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (N) in N_Entry_Body
+ | N_Package_Body
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
Decls := Declarations (N);
-- package Pack is
-- pragma Prag;
- elsif Nkind_In (N, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ elsif Nkind (N) in N_Generic_Package_Declaration
+ | N_Package_Declaration
then
Decls := Visible_Declarations (Specification (N));
begin
while Present (Disc) loop
if Chars (Expr) = Chars (Disc)
- and then Ekind_In
- (Etype (Disc),
- E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Type)
+ and then Ekind (Etype (Disc)) in
+ E_Anonymous_Access_Subprogram_Type |
+ E_Anonymous_Access_Type
then
Set_Has_Implicit_Dereference (E);
Set_Has_Implicit_Dereference (Disc);
begin
-- The relaxed parameter is a formal parameter
- if Nkind_In (Param, N_Identifier, N_Expanded_Name) then
+ if Nkind (Param) in N_Identifier | N_Expanded_Name then
Analyze (Param);
declare
begin
if Present (Pref)
and then
- Nkind_In (Pref, N_Identifier, N_Expanded_Name)
+ Nkind (Pref) in N_Identifier | N_Expanded_Name
and then
Entity (Pref) = Subp_Id
then
begin
-- Check valid declarations for 'Yield
- if (Nkind_In (N, N_Abstract_Subprogram_Declaration,
- N_Entry_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration)
- or else Nkind (N) in N_Formal_Subprogram_Declaration)
+ if Nkind (N) in N_Abstract_Subprogram_Declaration
+ | N_Entry_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Subprogram_Declaration
+ | N_Formal_Subprogram_Declaration
and then not Within_Protected_Type (E)
then
null;
| Aspect_Interrupt_Priority
| Aspect_Priority
=>
- if Nkind_In (N, N_Subprogram_Body,
- N_Subprogram_Declaration)
+ if Nkind (N) in N_Subprogram_Body | N_Subprogram_Declaration
then
-- Analyze the aspect expression
Context := Instance_Spec (Context);
end if;
- if Nkind_In (Context, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (Context) in N_Generic_Package_Declaration
+ | N_Package_Declaration
then
Make_Aitem_Pragma
(Pragma_Argument_Associations => New_List (
Context := Instance_Spec (Context);
end if;
- if Nkind_In (Context, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (Context) in N_Generic_Package_Declaration
+ | N_Package_Declaration
then
Make_Aitem_Pragma
(Pragma_Argument_Associations => New_List (
Context := Instance_Spec (Context);
end if;
- if Nkind_In (Context, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (Context) in N_Generic_Package_Declaration
+ | N_Package_Declaration
then
Make_Aitem_Pragma
(Pragma_Argument_Associations => New_List (
-- Part_Of
when Aspect_Part_Of =>
- if Nkind_In (N, N_Object_Declaration,
- N_Package_Instantiation)
+ if Nkind (N) in N_Object_Declaration
+ | N_Package_Instantiation
or else Is_Single_Concurrent_Type_Declaration (N)
then
Make_Aitem_Pragma
if Class_Present (Aspect)
and then Is_Concurrent_Type (Current_Scope)
- and then Ekind_In (E, E_Entry, E_Function, E_Procedure)
+ and then Ekind (E) in E_Entry | E_Function | E_Procedure
then
Error_Msg_Name_1 := Original_Aspect_Pragma_Name (Aspect);
Error_Msg_N
if A_Id in Library_Unit_Aspects
and then
- Nkind_In (N, N_Package_Declaration,
- N_Generic_Package_Declaration)
+ Nkind (N) in N_Package_Declaration
+ | N_Generic_Package_Declaration
and then Nkind (Parent (N)) /= N_Compilation_Unit
-- Aspect is legal on a local instantiation of a library-
-- When delay is not required and the context is a package or a
-- subprogram body, insert the pragma in the body declarations.
- elsif Nkind_In (N, N_Package_Body, N_Subprogram_Body) then
+ elsif Nkind (N) in N_Package_Body | N_Subprogram_Body then
if No (Declarations (N)) then
Set_Declarations (N, New_List);
end if;
if Ignore_Rep_Clauses then
Set_Address_Taken (U_Ent);
- if Ekind_In (U_Ent, E_Variable, E_Constant) then
+ if Ekind (U_Ent) in E_Variable | E_Constant then
Record_Rep_Item (U_Ent, N);
end if;
-- Case of address clause for an object
- elsif Ekind_In (U_Ent, E_Constant, E_Variable) then
+ elsif Ekind (U_Ent) in E_Constant | E_Variable then
declare
Expr : constant Node_Id := Expression (N);
O_Ent : Entity_Id;
Nam);
return;
- elsif not Ekind_In (U_Ent, E_Access_Type, E_General_Access_Type)
+ elsif Ekind (U_Ent) not in E_Access_Type | E_General_Access_Type
then
Error_Msg_N
("storage pool can only be given for access types", Nam);
while Present (Decl) loop
DeclO := Original_Node (Decl);
if Comes_From_Source (DeclO)
- and not Nkind_In (DeclO, N_Pragma,
- N_Use_Package_Clause,
- N_Use_Type_Clause,
- N_Implicit_Label_Declaration)
+ and Nkind (DeclO) not in N_Pragma
+ | N_Use_Package_Clause
+ | N_Use_Type_Clause
+ | N_Implicit_Label_Declaration
then
Error_Msg_N
("this declaration not allowed in machine code subprogram",
null;
elsif Comes_From_Source (StmtO)
- and then not Nkind_In (StmtO, N_Pragma,
- N_Label,
- N_Code_Statement)
+ and then Nkind (StmtO) not in
+ N_Pragma | N_Label | N_Code_Statement
then
Error_Msg_N
("this statement is not allowed in machine code subprogram",
-- Identifier (other than static expression) case
- else pragma Assert (Nkind_In (N, N_Expanded_Name, N_Identifier));
+ else pragma Assert (Nkind (N) in N_Expanded_Name | N_Identifier);
-- Type case
-------------------------------------
function Reset_Quantified_Variable_Scope
- (N : Node_Id) return Traverse_Result
- is
+ (N : Node_Id) return Traverse_Result is
begin
- if Nkind_In (N, N_Iterator_Specification,
- N_Loop_Parameter_Specification)
+ if Nkind (N) in N_Iterator_Specification
+ | N_Loop_Parameter_Specification
then
Set_Scope (Defining_Identifier (N),
Predicate_Function (Typ));
-- Otherwise look at the identifier and see if it is OK
- if Ekind_In (Ent, E_Named_Integer, E_Named_Real)
+ if Ekind (Ent) in E_Named_Integer | E_Named_Real
or else Is_Type (Ent)
then
return;
- elsif Ekind_In (Ent, E_Constant, E_In_Parameter) then
+ elsif Ekind (Ent) in E_Constant | E_In_Parameter then
-- This is the case where we must have Ent defined before
-- U_Ent. Clearly if they are in different units this
Check_Expr_Constants (Prefix (Nod));
when N_Attribute_Reference =>
- if Nam_In (Attribute_Name (Nod), Name_Address,
- Name_Access,
- Name_Unchecked_Access,
- Name_Unrestricted_Access)
+ if Attribute_Name (Nod) in Name_Address
+ | Name_Access
+ | Name_Unchecked_Access
+ | Name_Unrestricted_Access
then
Check_At_Constant_Address (Prefix (Nod));
-- record, both at location zero. This seems a bit strange, but
-- it seems to happen in some circumstances, perhaps on an error.
- if Nam_In (Chars (C1_Ent), Name_uTag, Name_uTag) then
+ if Chars (C1_Ent) = Name_uTag then
return;
end if;
Parent_Last_Bit := UI_From_Int (System_Address_Size - 1);
Pcomp := First_Entity (Tagged_Parent);
while Present (Pcomp) loop
- if Ekind_In (Pcomp, E_Discriminant, E_Component) then
+ if Ekind (Pcomp) in E_Discriminant | E_Component then
if Component_Bit_Offset (Pcomp) /= No_Uint
and then Known_Static_Esize (Pcomp)
then
-- This latter test is repeated recursively up the variant tree.
Main_Component_Loop : while Present (C1_Ent) loop
- if not Ekind_In (C1_Ent, E_Component, E_Discriminant) then
+ if Ekind (C1_Ent) not in E_Component | E_Discriminant then
goto Continue_Main_Component_Loop;
end if;
-- but be careful not to flag a non-girder discriminant
-- and the girder discriminant it renames as overlapping.
- if Nkind_In (Clist, N_Full_Type_Declaration,
- N_Private_Type_Declaration)
+ if Nkind (Clist) in N_Full_Type_Declaration
+ | N_Private_Type_Declaration
then
if Has_Discriminants (Defining_Identifier (Clist)) then
C2_Ent :=
-- The subprogram is inherited (implicitly declared), it does not
-- override and does not cover a primitive of an interface.
- if Ekind_In (Subp_Id, E_Function, E_Procedure)
+ if Ekind (Subp_Id) in E_Function | E_Procedure
and then Present (Alias (Subp_Id))
and then No (Interface_Alias (Subp_Id))
and then No (Overridden_Operation (Subp_Id))
return Entity (Rep_Item);
else
- pragma Assert (Nkind_In (Rep_Item,
- N_Attribute_Definition_Clause,
- N_Pragma));
+ pragma Assert
+ (Nkind (Rep_Item) in N_Attribute_Definition_Clause | N_Pragma);
return Entity (Name (Rep_Item));
end if;
end Rep_Item_Entity;
-- 20. A call to a predefined boolean logical operator, where each
-- operand is predicate-static.
- elsif (Nkind_In (Expr, N_Op_And, N_Op_Or, N_Op_Xor)
+ elsif (Nkind (Expr) in N_Op_And | N_Op_Or | N_Op_Xor
and then Is_Predicate_Static (Left_Opnd (Expr), Nam)
and then Is_Predicate_Static (Right_Opnd (Expr), Nam))
or else
-- A self-referential aspect is illegal if it forces freezing the
-- entity before the corresponding pragma has been analyzed.
- if Nkind_In (N, N_Attribute_Definition_Clause, N_Pragma)
+ if Nkind (N) in N_Attribute_Definition_Clause | N_Pragma
and then From_Aspect_Specification (N)
then
Error_Msg_NE
declare
Pname : constant Name_Id := Pragma_Name (N);
begin
- if Nam_In (Pname, Name_Convention, Name_Import, Name_Export,
- Name_External, Name_Interface)
+ if Pname in Name_Convention | Name_Import | Name_Export
+ | Name_External | Name_Interface
then
return False;
end if;
-- function, scope is the current one, because it is the one of the
-- current type declaration, except for the pathological case below.
- if Nkind_In (Related_Nod, N_Object_Declaration,
- N_Access_Function_Definition)
+ if Nkind (Related_Nod) in
+ N_Object_Declaration | N_Access_Function_Definition
then
Anon_Scope := Current_Scope;
begin
Par := Related_Nod;
- while Nkind_In (Par, N_Access_Function_Definition,
- N_Access_Definition)
+ while Nkind (Par) in
+ N_Access_Function_Definition | N_Access_Definition
loop
Par := Parent (Par);
end loop;
-- (Z : access T)))
D_Ityp := Associated_Node_For_Itype (Desig_Type);
- while not (Nkind_In (D_Ityp, N_Full_Type_Declaration,
- N_Private_Type_Declaration,
- N_Private_Extension_Declaration,
- N_Procedure_Specification,
- N_Function_Specification,
- N_Entry_Body)
-
- or else
- Nkind_In (D_Ityp, N_Object_Declaration,
- N_Object_Renaming_Declaration,
- N_Formal_Object_Declaration,
- N_Formal_Type_Declaration,
- N_Task_Type_Declaration,
- N_Protected_Type_Declaration))
+ while Nkind (D_Ityp) not in N_Full_Type_Declaration
+ | N_Private_Type_Declaration
+ | N_Private_Extension_Declaration
+ | N_Procedure_Specification
+ | N_Function_Specification
+ | N_Entry_Body
+ | N_Object_Declaration
+ | N_Object_Renaming_Declaration
+ | N_Formal_Object_Declaration
+ | N_Formal_Type_Declaration
+ | N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
loop
D_Ityp := Parent (D_Ityp);
pragma Assert (D_Ityp /= Empty);
Set_Associated_Node_For_Itype (Desig_Type, D_Ityp);
- if Nkind_In (D_Ityp, N_Procedure_Specification,
- N_Function_Specification)
+ if Nkind (D_Ityp) in N_Procedure_Specification | N_Function_Specification
then
Set_Scope (Desig_Type, Scope (Defining_Entity (D_Ityp)));
- elsif Nkind_In (D_Ityp, N_Full_Type_Declaration,
- N_Object_Declaration,
- N_Object_Renaming_Declaration,
- N_Formal_Type_Declaration)
+ elsif Nkind (D_Ityp) in N_Full_Type_Declaration
+ | N_Object_Declaration
+ | N_Object_Renaming_Declaration
+ | N_Formal_Type_Declaration
then
Set_Scope (Desig_Type, Scope (Defining_Identifier (D_Ityp)));
end if;
-- because they have already been resolved.
elsif Decls = Visible_Declarations (Context)
- and then Ekind_In (Typ, E_Limited_Private_Type,
- E_Private_Type,
- E_Record_Type_With_Private)
+ and then Ekind (Typ) in E_Limited_Private_Type
+ | E_Private_Type
+ | E_Record_Type_With_Private
and then Has_Own_Invariants (Typ)
then
Build_Invariant_Procedure_Body
-- controlled primitives.
if Nkind (Body_Spec) /= N_Procedure_Specification
- or else not Nam_In (Chars (Body_Id), Name_Adjust,
- Name_Finalize,
- Name_Initialize)
+ or else Chars (Body_Id) not in Name_Adjust
+ | Name_Finalize
+ | Name_Initialize
then
return;
Spec_Id := Current_Entity (Body_Id);
while Present (Spec_Id) loop
- if Ekind_In (Spec_Id, E_Procedure, E_Generic_Procedure)
+ if Ekind (Spec_Id) in E_Procedure | E_Generic_Procedure
and then Scope (Spec_Id) = Current_Scope
and then Present (First_Formal (Spec_Id))
and then No (Next_Formal (First_Formal (Spec_Id)))
if Nkind (Parent (L)) = N_Component_List then
null;
- elsif Nkind_In (Parent (L), N_Protected_Definition,
- N_Task_Definition)
+ elsif Nkind (Parent (L)) in
+ N_Protected_Definition | N_Task_Definition
then
Check_Entry_Contracts;
return;
end if;
- if Nkind_In (E, N_Integer_Literal, N_Real_Literal) then
+ if Nkind (E) in N_Integer_Literal | N_Real_Literal then
Set_Etype (E, Etype (Id));
end if;
("parent of type extension must be a tagged type ", Indic);
goto Leave;
- elsif Ekind_In (Parent_Type, E_Void, E_Incomplete_Type) then
+ elsif Ekind (Parent_Type) in E_Void | E_Incomplete_Type then
Error_Msg_N ("premature derivation of incomplete type", Indic);
goto Leave;
Mark_Rewrite_Insertion (Comp);
- if Nkind_In (N, N_Object_Declaration, N_Access_Function_Definition)
+ if Nkind (N) in N_Object_Declaration | N_Access_Function_Definition
or else (Nkind (Parent (N)) = N_Full_Type_Declaration
and then not Is_Type (Current_Scope))
then
end Replace_Type_Name;
begin
- if Ekind_In (Id, E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type,
- E_Anonymous_Access_Subprogram_Type)
+ if Ekind (Id) in E_Access_Subprogram_Type
+ | E_Access_Protected_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
+ | E_Anonymous_Access_Subprogram_Type
then
null;
-- build-in-place library function, child unit or not.
if (Nkind (Nod) in N_Entity and then Is_Compilation_Unit (Nod))
- or else (Nkind_In (Nod, N_Defining_Program_Unit_Name,
- N_Subprogram_Declaration)
- and then Is_Compilation_Unit (Defining_Entity (Nod)))
+ or else (Nkind (Nod) in
+ N_Defining_Program_Unit_Name | N_Subprogram_Declaration
+ and then Is_Compilation_Unit (Defining_Entity (Nod)))
then
Add_Global_Declaration (IR);
else
Analyze_And_Resolve (Bound, Base_Type (Par_T));
- if Nkind_In (Bound, N_Integer_Literal, N_Real_Literal) then
+ if Nkind (Bound) in N_Integer_Literal | N_Real_Literal then
New_Bound := New_Copy (Bound);
Set_Etype (New_Bound, Der_T);
Set_Analyzed (New_Bound);
begin
if not Comes_From_Source (E) then
- if Ekind_In (E, E_Task_Type, E_Protected_Type) then
+ if Ekind (E) in E_Task_Type | E_Protected_Type then
-- It may be an anonymous protected type created for a
-- single variable. Post error on variable, if present.
-- this kind is reserved for predefined operators, that are
-- intrinsic and do not need completion.
- elsif Ekind_In (E, E_Function,
- E_Procedure,
- E_Generic_Function,
- E_Generic_Procedure)
+ elsif Ekind (E) in E_Function
+ | E_Procedure
+ | E_Generic_Function
+ | E_Generic_Procedure
then
if Has_Completion (E) then
null;
Post_Error;
end if;
- elsif Ekind_In (E, E_Task_Type, E_Protected_Type) then
+ elsif Ekind (E) in E_Task_Type | E_Protected_Type then
if not Has_Completion (E) then
Post_Error;
end if;
if Is_Tagged_Type (Typ) or else Has_Controlled_Component (Typ) then
Old_C := First_Component (Typ);
while Present (Old_C) loop
- if Nam_In (Chars (Old_C), Name_uTag, Name_uParent) then
+ if Chars (Old_C) in Name_uTag | Name_uParent then
Append_Elmt (Old_C, Comp_List);
end if;
or else Is_Private_Overriding
or else Is_Internal_Name (Chars (Parent_Subp))
or else (Is_Controlled (Parent_Type)
- and then Nam_In (Chars (Parent_Subp), Name_Adjust,
- Name_Finalize,
- Name_Initialize))
+ and then Chars (Parent_Subp) in Name_Adjust
+ | Name_Finalize
+ | Name_Initialize)
then
Set_Derived_Name;
-- set on both views of the type.
if Is_Controlled (Parent_Type)
- and then Nam_In (Chars (Parent_Subp), Name_Initialize,
- Name_Adjust,
- Name_Finalize)
+ and then Chars (Parent_Subp) in Name_Initialize
+ | Name_Adjust
+ | Name_Finalize
and then Is_Hidden (Parent_Subp)
and then not Is_Visibly_Controlled (Parent_Type)
then
-- Check for early use of incomplete or private type
- if Ekind_In (Parent_Type, E_Void, E_Incomplete_Type) then
+ if Ekind (Parent_Type) in E_Void | E_Incomplete_Type then
Error_Msg_N ("premature derivation of incomplete type", Indic);
return;
-- Check invalid completion of private or incomplete type
- elsif not Nkind_In (N, N_Full_Type_Declaration,
- N_Task_Type_Declaration,
- N_Protected_Type_Declaration)
+ elsif Nkind (N) not in N_Full_Type_Declaration
+ | N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
and then
(Ada_Version < Ada_2012
or else not Is_Incomplete_Type (Prev)
- or else not Nkind_In (N, N_Private_Type_Declaration,
- N_Private_Extension_Declaration))
+ or else Nkind (N) not in N_Private_Type_Declaration
+ | N_Private_Extension_Declaration)
then
-- Completion must be a full type declarations (RM 7.3(4))
end if;
if Nkind (N) = N_Full_Type_Declaration
- and then Nkind_In
- (Type_Definition (N), N_Record_Definition,
- N_Derived_Type_Definition)
+ and then Nkind (Type_Definition (N)) in
+ N_Record_Definition | N_Derived_Type_Definition
and then Interface_Present (Type_Definition (N))
then
Error_Msg_N
New_Id := Id;
elsif Ekind (Prev) = E_Private_Type
- and then Nkind_In (N, N_Task_Type_Declaration,
- N_Protected_Type_Declaration)
+ and then Nkind (N) in N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
then
Error_Msg_N
("completion of nonlimited type cannot be limited", N);
elsif Ekind (Prev) = E_Record_Type_With_Private
- and then Nkind_In (N, N_Task_Type_Declaration,
- N_Protected_Type_Declaration)
+ and then Nkind (N) in N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
then
if not Is_Limited_Record (Prev) then
Error_Msg_N
-- type or a protected type. This case arises when covering
-- interface types.
- elsif Nkind_In (N, N_Task_Type_Declaration,
- N_Protected_Type_Declaration)
+ elsif Nkind (N) in N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
then
null;
if Ada_Version >= Ada_2012
and then Is_Incomplete_Type (Prev)
- and then Nkind_In (N, N_Private_Type_Declaration,
- N_Private_Extension_Declaration)
+ and then Nkind (N) in N_Private_Type_Declaration
+ | N_Private_Extension_Declaration
then
-- No need to check private extensions since they are tagged
-- a synchronized type that implements interfaces) or a
-- type extension, otherwise this is an error.
- elsif Nkind_In (N, N_Task_Type_Declaration,
- N_Protected_Type_Declaration)
+ elsif Nkind (N) in N_Task_Type_Declaration
+ | N_Protected_Type_Declaration
then
if No (Interface_List (N)) and then not Error_Posted (N) then
Tag_Mismatch;
-- Case of an anonymous array subtype
- if Nkind_In (Def_Kind, N_Constrained_Array_Definition,
- N_Unconstrained_Array_Definition)
+ if Def_Kind in
+ N_Constrained_Array_Definition | N_Unconstrained_Array_Definition
then
T := Empty;
Array_Type_Declaration (T, Obj_Def);
then
null;
- elsif Ekind_In (Derived_Base, E_Private_Type,
- E_Limited_Private_Type)
+ elsif Ekind (Derived_Base) in E_Private_Type | E_Limited_Private_Type
then
null;
return Constraint_Kind = N_Range_Constraint;
when Decimal_Fixed_Point_Kind =>
- return Nkind_In (Constraint_Kind, N_Digits_Constraint,
- N_Range_Constraint);
+ return Constraint_Kind in N_Digits_Constraint | N_Range_Constraint;
when Ordinary_Fixed_Point_Kind =>
- return Nkind_In (Constraint_Kind, N_Delta_Constraint,
- N_Range_Constraint);
+ return Constraint_Kind in N_Delta_Constraint | N_Range_Constraint;
when Float_Kind =>
- return Nkind_In (Constraint_Kind, N_Digits_Constraint,
- N_Range_Constraint);
+ return Constraint_Kind in N_Digits_Constraint | N_Range_Constraint;
when Access_Kind
| Array_Kind
-- Start of processing for Is_Visible_Component
begin
- if Ekind_In (C, E_Component, E_Discriminant) then
+ if Ekind (C) in E_Component | E_Discriminant then
Original_Comp := Original_Record_Component (C);
end if;
Priv := Node (Priv_Elmt);
Priv_Scop := Scope (Priv);
- if Ekind_In (Priv, E_Private_Subtype,
- E_Limited_Private_Subtype,
- E_Record_Subtype_With_Private)
+ if Ekind (Priv) in E_Private_Subtype
+ | E_Limited_Private_Subtype
+ | E_Record_Subtype_With_Private
then
Full := Make_Defining_Identifier (Sloc (Priv), Chars (Priv));
Set_Is_Itype (Full);
Prim := Next_Entity (Full_T);
while Present (Prim) and then Prim /= Priv_T loop
- if Ekind_In (Prim, E_Procedure, E_Function) then
+ if Ekind (Prim) in E_Procedure | E_Function then
Disp_Typ := Find_Dispatching_Type (Prim);
if Disp_Typ = Full_T
exit when
Nkind (Insert_Node) in N_Declaration
and then
- not Nkind_In
- (Insert_Node, N_Component_Declaration,
- N_Loop_Parameter_Specification,
- N_Function_Specification,
- N_Procedure_Specification);
-
- exit when Nkind (Insert_Node) in N_Later_Decl_Item
- or else Nkind (Insert_Node) in
- N_Statement_Other_Than_Procedure_Call
- or else Nkind_In (Insert_Node, N_Procedure_Call_Statement,
- N_Pragma);
+ Nkind (Insert_Node) not in N_Component_Declaration
+ | N_Loop_Parameter_Specification
+ | N_Function_Specification
+ | N_Procedure_Specification;
+
+ exit when Nkind (Insert_Node) in
+ N_Later_Decl_Item |
+ N_Statement_Other_Than_Procedure_Call |
+ N_Procedure_Call_Statement |
+ N_Pragma;
Insert_Node := Parent (Insert_Node);
end loop;
-- The following is ugly, can't we have a range or even a flag???
May_Have_Null_Exclusion :=
- Nkind_In (P, N_Access_Definition,
- N_Access_Function_Definition,
- N_Access_Procedure_Definition,
- N_Access_To_Object_Definition,
- N_Allocator,
- N_Component_Definition)
- or else
- Nkind_In (P, N_Derived_Type_Definition,
- N_Discriminant_Specification,
- N_Formal_Object_Declaration,
- N_Object_Declaration,
- N_Object_Renaming_Declaration,
- N_Parameter_Specification,
- N_Subtype_Declaration);
+ Nkind (P) in N_Access_Definition
+ | N_Access_Function_Definition
+ | N_Access_Procedure_Definition
+ | N_Access_To_Object_Definition
+ | N_Allocator
+ | N_Component_Definition
+ | N_Derived_Type_Definition
+ | N_Discriminant_Specification
+ | N_Formal_Object_Declaration
+ | N_Object_Declaration
+ | N_Object_Renaming_Declaration
+ | N_Parameter_Specification
+ | N_Subtype_Declaration;
-- Create an Itype that is a duplicate of Entity (S) but with the
-- null-exclusion attribute.
if Nkind (N) in N_Membership_Test then
Error_Msg_N ("ambiguous operands for membership", N);
- elsif Nkind_In (N, N_Op_Eq, N_Op_Ne) then
+ elsif Nkind (N) in N_Op_Eq | N_Op_Ne then
Error_Msg_N ("ambiguous operands for equality", N);
else
-- performing the writable actuals check.
if Has_Arbitrary_Evaluation_Order (Nkind (P))
- and then not Nkind_In (P, N_Assignment_Statement,
- N_Object_Declaration)
+ and then Nkind (P) not in
+ N_Assignment_Statement | N_Object_Declaration
then
Outermost := P;
end if;
exit when Stop_Subtree_Climbing (Nkind (P))
or else (Nkind (P) = N_Range
- and then not
- Nkind_In (Parent (P), N_In, N_Not_In));
+ and then
+ Nkind (Parent (P)) not in N_In | N_Not_In);
P := Parent (P);
end loop;
-- Check for tasking cases where only an entry call will do
elsif not L
- and then Nkind_In (K, N_Entry_Call_Alternative,
- N_Triggering_Alternative)
+ and then K in N_Entry_Call_Alternative | N_Triggering_Alternative
then
Error_Msg_N ("entry name expected", Nam);
elsif Nkind (Nam) = N_Selected_Component then
Nam_Ent := Entity (Selector_Name (Nam));
- if not Ekind_In (Nam_Ent, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure)
+ if Ekind (Nam_Ent) not in E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Procedure
then
Error_Msg_N ("name in call is not a callable entity", Nam);
Set_Etype (N, Any_Type);
Set_Etype (Nam, It.Typ);
end if;
- elsif Nkind_In (Name (N), N_Function_Call, N_Selected_Component)
+ elsif Nkind (Name (N)) in N_Function_Call | N_Selected_Component
then
Remove_Interp (X);
end if;
-- Verify Nam is a non-visible controlled primitive
- and then Nam_In (Chars (Nam), Name_Adjust,
- Name_Finalize,
- Name_Initialize)
+ and then Chars (Nam) in Name_Adjust
+ | Name_Finalize
+ | Name_Initialize
and then Ekind (Nam) = E_Procedure
and then Is_Controlled (Etype (First_Form))
and then No (Next_Formal (First_Form))
Find_Type (Mark);
T := Entity (Mark);
- if Nkind_In (Enclosing_Declaration (N), N_Formal_Type_Declaration,
- N_Full_Type_Declaration,
- N_Incomplete_Type_Declaration,
- N_Protected_Type_Declaration,
- N_Private_Extension_Declaration,
- N_Private_Type_Declaration,
- N_Subtype_Declaration,
- N_Task_Type_Declaration)
+ if Nkind (Enclosing_Declaration (N)) in
+ N_Formal_Type_Declaration |
+ N_Full_Type_Declaration |
+ N_Incomplete_Type_Declaration |
+ N_Protected_Type_Declaration |
+ N_Private_Extension_Declaration |
+ N_Private_Type_Declaration |
+ N_Subtype_Declaration |
+ N_Task_Type_Declaration
and then T = Defining_Identifier (Enclosing_Declaration (N))
then
Error_Msg_N ("current instance not allowed", Mark);
elsif Is_Access_Type (Etype (Nod)) then
return True;
- elsif Nkind_In (Nod, N_Indexed_Component, N_Selected_Component) then
+ elsif Nkind (Nod) in N_Indexed_Component | N_Selected_Component then
return Has_Dereference (Prefix (Nod));
else
begin
if Nkind (Parent (N)) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Parent (N)),
- Name_Access,
- Name_Unchecked_Access,
- Name_Unrestricted_Access)
+ and then Attribute_Name (Parent (N)) in
+ Name_Access
+ | Name_Unchecked_Access
+ | Name_Unrestricted_Access
and then Is_Class_Wide_Type (Prefix_Type)
and then (Is_Synchronized_Interface (Prefix_Type)
or else Is_Protected_Interface (Prefix_Type))
or else
(Nkind (Parent_N) = N_Attribute_Reference
and then
- Nam_In (Attribute_Name (Parent_N), Name_First,
- Name_Last,
- Name_Length,
- Name_Range)))
+ Attribute_Name (Parent_N) in Name_First
+ | Name_Last
+ | Name_Length
+ | Name_Range))
then
Set_Etype (N, Etype (Comp));
-- a visible entity is found.
if Is_Tagged_Type (Prefix_Type)
- and then Nkind_In (Parent (N), N_Function_Call,
- N_Indexed_Component,
- N_Procedure_Call_Statement)
+ and then Nkind (Parent (N)) in N_Function_Call
+ | N_Indexed_Component
+ | N_Procedure_Call_Statement
and then Has_Mode_Conformant_Spec (Comp)
then
Has_Candidate := True;
-- Note: a selected component may not denote a component of a
-- protected type (4.1.3(7)).
- elsif Ekind_In (Comp, E_Discriminant, E_Entry_Family)
+ elsif Ekind (Comp) in E_Discriminant | E_Entry_Family
or else (In_Scope
and then not Is_Protected_Type (Prefix_Type)
and then Is_Entity_Name (Name))
end if;
elsif Nkind (Expr) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Expr), Name_Access,
- Name_Unchecked_Access,
- Name_Unrestricted_Access)
+ and then Attribute_Name (Expr) in Name_Access
+ | Name_Unchecked_Access
+ | Name_Unrestricted_Access
then
Error_Msg_N ("argument of conversion cannot be access", N);
Error_Msg_N ("\use qualified expression instead", N);
-- Start of processing for Check_Arithmetic_Pair
begin
- if Nam_In (Op_Name, Name_Op_Add, Name_Op_Subtract) then
+ if Op_Name in Name_Op_Add | Name_Op_Subtract then
if Is_Numeric_Type (T1)
and then Is_Numeric_Type (T2)
and then (Covers (T1 => T1, T2 => T2)
Add_One_Interp (N, Op_Id, Specific_Type (T1, T2));
end if;
- elsif Nam_In (Op_Name, Name_Op_Multiply, Name_Op_Divide) then
+ elsif Op_Name in Name_Op_Multiply | Name_Op_Divide then
if Is_Fixed_Point_Type (T1)
and then (Is_Fixed_Point_Type (T2) or else T2 = Universal_Real)
then
else
while Present (It.Nam) loop
- if Ekind_In (It.Nam, E_Function, E_Operator) then
+ if Ekind (It.Nam) in E_Function | E_Operator then
return;
else
Get_Next_Interp (X, It);
procedure Check_Access_Attribute (N : Node_Id) is
begin
if Nkind (N) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (N),
- Name_Access,
- Name_Unchecked_Access)
+ and then Attribute_Name (N) in Name_Access | Name_Unchecked_Access
then
Error_Msg_N
("access attribute cannot be used as actual for "
-- pretty much know that the other operand should be Boolean, so
-- resolve it that way (generating an error).
- elsif Nkind_In (N, N_Op_And, N_Op_Or, N_Op_Xor) then
+ elsif Nkind (N) in N_Op_And | N_Op_Or | N_Op_Xor then
if Etype (L) = Standard_Boolean then
Resolve (R, Standard_Boolean);
return;
-- is not the same numeric type. If it is a non-numeric type,
-- then probably it is intended to match the other operand.
- elsif Nkind_In (N, N_Op_Add,
- N_Op_Divide,
- N_Op_Ge,
- N_Op_Gt,
- N_Op_Le,
- N_Op_Lt,
- N_Op_Mod,
- N_Op_Multiply,
- N_Op_Rem,
- N_Op_Subtract)
+ elsif Nkind (N) in N_Op_Add
+ | N_Op_Divide
+ | N_Op_Ge
+ | N_Op_Gt
+ | N_Op_Le
+ | N_Op_Lt
+ | N_Op_Mod
+ | N_Op_Multiply
+ | N_Op_Rem
+ | N_Op_Subtract
then
-- If Allow_Integer_Address is active, check whether the
-- operation becomes legal after converting an operand.
Unchecked_Convert_To (
Standard_Address, Relocate_Node (R)));
- if Nkind_In (N, N_Op_Ge, N_Op_Gt, N_Op_Le, N_Op_Lt) then
+ if Nkind (N) in N_Op_Ge | N_Op_Gt | N_Op_Le | N_Op_Lt then
Analyze_Comparison_Op (N);
else
Analyze_Arithmetic_Op (N);
Unchecked_Convert_To (
Standard_Address, Relocate_Node (R)));
- if Nkind_In (N, N_Op_Ge, N_Op_Gt, N_Op_Le, N_Op_Lt) then
+ if Nkind (N) in N_Op_Ge | N_Op_Gt | N_Op_Le | N_Op_Lt then
Analyze_Comparison_Op (N);
else
Analyze_Arithmetic_Op (N);
Unchecked_Convert_To (
Standard_Address, Relocate_Node (R)));
- if Nkind_In (N, N_Op_Ge, N_Op_Gt, N_Op_Le, N_Op_Lt) then
+ if Nkind (N) in N_Op_Ge | N_Op_Gt | N_Op_Le | N_Op_Lt then
Analyze_Comparison_Op (N);
else
Analyze_Arithmetic_Op (N);
elsif Null_To_Null_Address_Convert_OK (N) then
Replace_Null_By_Null_Address (N);
- if Nkind_In (N, N_Op_Ge, N_Op_Gt, N_Op_Le, N_Op_Lt) then
+ if Nkind (N) in N_Op_Ge | N_Op_Gt | N_Op_Le | N_Op_Lt then
Analyze_Comparison_Op (N);
else
Analyze_Arithmetic_Op (N);
-- Comparisons on A'Access are common enough to deserve a
-- special message.
- elsif Nkind_In (N, N_Op_Eq, N_Op_Ne)
+ elsif Nkind (N) in N_Op_Eq | N_Op_Ne
and then Ekind (Etype (L)) = E_Access_Attribute_Type
and then Ekind (Etype (R)) = E_Access_Attribute_Type
then
return;
- elsif Nkind_In (N, N_Op_Eq, N_Op_Ne) then
+ elsif Nkind (N) in N_Op_Eq | N_Op_Ne then
if Address_Integer_Convert_OK (Etype (R), Etype (L)) then
Rewrite (L,
Unchecked_Convert_To (
-- indicate that the integer operand should be of
-- type Integer.
- if Nkind_In (N, N_Op_Multiply, N_Op_Divide)
+ if Nkind (N) in N_Op_Multiply | N_Op_Divide
and then Is_Fixed_Point_Type (Etype (L))
and then Is_Integer_Type (Etype (R))
then
-- resolution does not depend on the type of the parameter that
-- includes the indexing operation.
- elsif Nkind_In (Parent (Par), N_Function_Call,
- N_Procedure_Call_Statement)
+ elsif Nkind (Parent (Par)) in
+ N_Function_Call | N_Procedure_Call_Statement
and then Is_Entity_Name (Name (Parent (Par)))
then
declare
Hom := Current_Entity (Subprog);
while Present (Hom) loop
- if Ekind_In (Hom, E_Procedure, E_Function)
+ if Ekind (Hom) in E_Procedure | E_Function
and then Present (Renamed_Entity (Hom))
and then Is_Generic_Actual_Subprogram (Hom)
and then In_Open_Scopes (Scope (Hom))
Candidate := Hom;
end if;
- if Ekind_In (Candidate, E_Function, E_Procedure)
+ if Ekind (Candidate) in E_Function | E_Procedure
and then (not Is_Hidden (Candidate) or else In_Instance)
and then Scope (Candidate) = Scope (Base_Type (Anc_Type))
and then First_Formal_Match (Candidate, CW_Typ)
Obj_Type := Designated_Type (Obj_Type);
end if;
- if Ekind_In (Obj_Type, E_Private_Subtype,
- E_Record_Subtype_With_Private)
+ if Ekind (Obj_Type)
+ in E_Private_Subtype | E_Record_Subtype_With_Private
then
Obj_Type := Base_Type (Obj_Type);
end if;
if Is_Derived_Type (T) then
return Primitive_Operations (T);
- elsif Ekind_In (Scope (T), E_Procedure, E_Function) then
+ elsif Ekind (Scope (T)) in E_Procedure | E_Function then
-- Scan the list of generic formals to find subprograms
-- that may have a first controlling formal of the type.
if Is_Entity_Name (Opnd)
and then (Ekind (Entity (Opnd)) = E_Out_Parameter
- or else Ekind_In (Entity (Opnd),
- E_In_Out_Parameter,
- E_Generic_In_Out_Parameter)
+ or else Ekind (Entity (Opnd)) in
+ E_In_Out_Parameter | E_Generic_In_Out_Parameter
or else
(Ekind (Entity (Opnd)) = E_Variable
and then Nkind (Parent (Entity (Opnd))) =
-- If assignment operand is a component reference, then we get the
-- actual subtype of the component for the unconstrained case.
- elsif Nkind_In (Opnd, N_Selected_Component, N_Explicit_Dereference)
+ elsif Nkind (Opnd) in N_Selected_Component | N_Explicit_Dereference
and then not Is_Unchecked_Union (Opnd_Type)
then
Decl := Build_Actual_Subtype_Of_Component (Opnd_Type, Opnd);
and then Is_Assignable (Entity (Lhs))
and then Is_Composite_Type (T1)
and then not Is_Constrained (Etype (Entity (Lhs)))
- and then Nkind_In (Rhs, N_If_Expression, N_Case_Expression)
+ and then Nkind (Rhs) in N_If_Expression | N_Case_Expression
then
Resolve (Rhs, Base_Type (T1));
-- Do not install the return object
- if not Ekind_In (Id, E_Constant, E_Variable)
+ if Ekind (Id) not in E_Constant | E_Variable
or else not Is_Return_Object (Id)
then
Install_Entity (Id);
if Is_Entity_Name (Exp) then
Ent := Entity (Exp);
- if Ekind_In (Ent, E_Variable,
- E_In_Out_Parameter,
- E_Out_Parameter)
+ if Ekind (Ent) in E_Variable | E_In_Out_Parameter | E_Out_Parameter
then
if List_Length (Choices) = 1
and then Nkind (First (Choices)) in N_Subexpr
Scope_Id := Scope_Stack.Table (J).Entity;
if Label_Scope = Scope_Id
- or else not Ekind_In (Scope_Id, E_Block, E_Loop, E_Return_Statement)
+ or else Ekind (Scope_Id) not in
+ E_Block | E_Loop | E_Return_Statement
then
if Scope_Id /= Label_Scope then
Error_Msg_N
if Nkind (Orig_Iter_Name) = N_Selected_Component
and then
Present (Entity (Selector_Name (Orig_Iter_Name)))
- and then Ekind_In
- (Entity (Selector_Name (Orig_Iter_Name)),
- E_Component,
- E_Discriminant)
+ and then
+ Ekind (Entity (Selector_Name (Orig_Iter_Name))) in
+ E_Component | E_Discriminant
and then Is_Dependent_Component_Of_Mutable_Object
(Orig_Iter_Name)
then
if Analyzed (Original_Bound) then
return Original_Bound;
- elsif Nkind_In (Analyzed_Bound, N_Integer_Literal,
- N_Character_Literal)
+ elsif Nkind (Analyzed_Bound) in
+ N_Integer_Literal | N_Character_Literal
or else Is_Entity_Name (Analyzed_Bound)
then
Analyze_And_Resolve (Original_Bound, Typ);
and then not Is_Type (Entity (DS_Copy)))
or else (Nkind (DS_Copy) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (DS_Copy),
- Name_Loop_Entry, Name_Old))
+ and then Attribute_Name (DS_Copy) in
+ Name_Loop_Entry | Name_Old)
or else Has_Aspect (Etype (DS_Copy), Aspect_Iterable)
-- Case where we have a range or a subtype, get type bounds
- if Nkind_In (DS, N_Range, N_Subtype_Indication)
+ if Nkind (DS) in N_Range | N_Subtype_Indication
and then not Error_Posted (DS)
and then Etype (DS) /= Any_Type
and then Is_Discrete_Type (Etype (DS))
elsif Kind = N_Function_Call
and then Is_Entity_Name (Name (Return_Expr))
- and then Ekind_In (Entity (Name (Return_Expr)), E_Function,
- E_Generic_Function)
+ and then Ekind (Entity (Name (Return_Expr))) in
+ E_Function | E_Generic_Function
and then No_Return (Entity (Name (Return_Expr)))
then
return;
-- We are only interested in return statements
- if not Nkind_In (Return_Stmt, N_Extended_Return_Statement,
- N_Simple_Return_Statement)
+ if Nkind (Return_Stmt) not in
+ N_Extended_Return_Statement | N_Simple_Return_Statement
then
return;
end if;
if Nkind (Assoc) = N_Attribute_Reference then
Expr := Assoc;
- elsif Nkind_In (Assoc, N_Component_Association,
- N_Discriminant_Association)
+ elsif Nkind (Assoc) in
+ N_Component_Association | N_Discriminant_Association
then
Expr := Expression (Assoc);
else
Obj := Original_Node (Prefix (Expr));
loop
- while Nkind_In (Obj, N_Explicit_Dereference,
- N_Indexed_Component,
- N_Selected_Component)
+ while Nkind (Obj) in N_Explicit_Dereference
+ | N_Indexed_Component
+ | N_Selected_Component
loop
-- When we encounter a named access type then we can
-- ignore accessibility checks on the dereference.
-- This early expansion is done only when the return statement is
-- not part of a handled sequence of statements.
- if Nkind_In (Expr, N_Aggregate,
- N_Extension_Aggregate)
+ if Nkind (Expr) in N_Aggregate | N_Extension_Aggregate
and then Needs_Finalization (R_Type)
and then Nkind (Parent (N)) /= N_Handled_Sequence_Of_Statements
then
if Expander_Active
and then Serious_Errors_Detected = 0
and then Is_Access_Type (R_Type)
- and then not Nkind_In (Expr, N_Null, N_Raise_Expression)
+ and then Nkind (Expr) not in N_Null | N_Raise_Expression
and then Is_Interface (Designated_Type (R_Type))
and then Is_Progenitor (Designated_Type (R_Type),
Designated_Type (Etype (Expr)))
and then not Is_Constrained (R_Type)
and then Is_Build_In_Place_Function (Scope_Id)
and then Needs_BIP_Alloc_Form (Scope_Id)
- and then Nkind_In (Expr, N_Aggregate, N_Extension_Aggregate)
+ and then Nkind (Expr) in N_Aggregate | N_Extension_Aggregate
then
Preanalyze (Obj_Decl);
-- Special processing for Elab_Spec, Elab_Body and Elab_Subp_Body calls
if Nkind (P) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (P), Name_Elab_Spec,
- Name_Elab_Body,
- Name_Elab_Subp_Body)
+ and then Attribute_Name (P) in Name_Elab_Spec
+ | Name_Elab_Body
+ | Name_Elab_Subp_Body
then
if Present (Actuals) then
Error_Msg_N
-- function, the context will select the operation whose type is Void.
elsif Nkind (P) = N_Selected_Component
- and then Ekind_In (Entity (Selector_Name (P)), E_Entry,
- E_Function,
- E_Procedure)
+ and then Ekind (Entity (Selector_Name (P)))
+ in E_Entry | E_Function | E_Procedure
then
-- When front-end inlining is enabled, as with SPARK_Mode, a call
-- in prefix notation may still be missing its controlling argument,
------------------------------
procedure Analyze_Return_Statement (N : Node_Id) is
- pragma Assert (Nkind_In (N, N_Extended_Return_Statement,
- N_Simple_Return_Statement));
+ pragma Assert
+ (Nkind (N) in N_Extended_Return_Statement | N_Simple_Return_Statement);
Returns_Object : constant Boolean :=
Nkind (N) = N_Extended_Return_Statement
for J in reverse 0 .. Scope_Stack.Last loop
Result := Scope_Stack.Table (J).Entity;
- exit when not Ekind_In (Result, E_Block, E_Loop)
+ exit when Ekind (Result) not in E_Block | E_Loop
and then Chars (Result) /= Name_uPostconditions;
end loop;
-- implicitly-generated return that is placed at the end.
if No_Return (Scope_Id)
- and then Ekind_In (Kind, E_Procedure, E_Generic_Procedure)
+ and then Kind in E_Procedure | E_Generic_Procedure
and then Comes_From_Source (N)
then
Error_Msg_N
-- Check that functions return objects, and other things do not
- if Ekind_In (Kind, E_Function, E_Generic_Function) then
+ if Kind in E_Function | E_Generic_Function then
if not Returns_Object then
Error_Msg_N ("missing expression in return from function", N);
end if;
- elsif Ekind_In (Kind, E_Procedure, E_Generic_Procedure) then
+ elsif Kind in E_Procedure | E_Generic_Procedure then
if Returns_Object then
Error_Msg_N ("procedure cannot return value (use function)", N);
end if;
- elsif Ekind_In (Kind, E_Entry, E_Entry_Family) then
+ elsif Kind in E_Entry | E_Entry_Family then
if Returns_Object then
if Is_Protected_Type (Scope (Scope_Id)) then
Error_Msg_N ("entry body cannot return value", N);
Error_Msg_N ("illegal context for return statement", N);
end if;
- if Ekind_In (Kind, E_Function, E_Generic_Function) then
+ if Kind in E_Function | E_Generic_Function then
Analyze_Function_Return (N);
- elsif Ekind_In (Kind, E_Procedure, E_Generic_Procedure) then
+ elsif Kind in E_Procedure | E_Generic_Procedure then
Set_Return_Present (Scope_Id);
end if;
null;
elsif Nkind (Parent (N)) = N_Subprogram_Body
- or else Nkind_In (Parent (Parent (N)), N_Accept_Statement,
- N_Entry_Body)
+ or else Nkind (Parent (Parent (N))) in
+ N_Accept_Statement | N_Entry_Body
then
Error_Msg_NE
("invalid use of untagged incomplete type&",
-- the environment task is our effective master, so nothing
-- to mark.
- if Nkind_In
- (Par, N_Task_Body, N_Block_Statement, N_Subprogram_Body)
+ if Nkind (Par)
+ in N_Task_Body | N_Block_Statement | N_Subprogram_Body
then
Set_Is_Task_Master (Par, True);
exit;
-- Do not process subprogram bodies as they already use the non-
-- limited view of types.
- if not Ekind_In (Subp_Id, E_Function, E_Procedure) then
+ if Ekind (Subp_Id) not in E_Function | E_Procedure then
return No_Elist;
end if;
if Is_Entity_Name (Node) and then Present (Entity (Node)) then
Mask_Type (Etype (Entity (Node)));
- if Ekind_In (Entity (Node), E_Component, E_Discriminant) then
+ if Ekind (Entity (Node)) in E_Component | E_Discriminant then
Mask_Type (Scope (Entity (Node)));
end if;
- elsif Nkind_In (Node, N_Aggregate, N_Null, N_Type_Conversion)
+ elsif Nkind (Node) in N_Aggregate | N_Null | N_Type_Conversion
and then Present (Etype (Node))
then
Mask_Type (Etype (Node));
-- Move relevant pragmas to the spec
- elsif Nam_In (Pragma_Name_Unmapped (Decl),
- Name_Depends,
- Name_Ghost,
- Name_Global,
- Name_Pre,
- Name_Precondition,
- Name_Post,
- Name_Refined_Depends,
- Name_Refined_Global,
- Name_Refined_Post,
- Name_Inline,
- Name_Pure_Function,
- Name_Volatile_Function)
+ elsif Pragma_Name_Unmapped (Decl) in Name_Depends
+ | Name_Ghost
+ | Name_Global
+ | Name_Pre
+ | Name_Precondition
+ | Name_Post
+ | Name_Refined_Depends
+ | Name_Refined_Global
+ | Name_Refined_Post
+ | Name_Inline
+ | Name_Pure_Function
+ | Name_Volatile_Function
then
Remove (Decl);
Insert_After (Insert_Nod, Decl);
-- expansion. As a result, we add an exception for this case.
elsif not Present (Overridden_Operation (Spec_Id))
- and then not (Nam_In (Chars (Spec_Id), Name_Adjust,
- Name_Finalize,
- Name_Initialize)
+ and then not (Chars (Spec_Id) in Name_Adjust
+ | Name_Finalize
+ | Name_Initialize
and then In_Instance)
then
Error_Msg_NE
-- Push_xxx_Error_Label to find the first real statement.
Stm := First (Statements (HSS));
- while Nkind_In (Stm, N_Call_Marker, N_Label)
- or else Nkind (Stm) in N_Push_xxx_Label
- loop
+ while Nkind (Stm) in N_Call_Marker | N_Label | N_Push_xxx_Label loop
Next (Stm);
end loop;
-- In case of primitives associated with abstract interface types
-- the check is applied later (see Analyze_Subprogram_Declaration).
- if not Nkind_In (Original_Node (Parent (N)),
- N_Abstract_Subprogram_Declaration,
- N_Formal_Abstract_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration)
+ if Nkind (Original_Node (Parent (N))) not in
+ N_Abstract_Subprogram_Declaration |
+ N_Formal_Abstract_Subprogram_Declaration |
+ N_Subprogram_Renaming_Declaration
then
if Is_Abstract_Type (Etype (Designator)) then
Error_Msg_N
-- the only way these may receive a convention is if they inherit
-- the convention of a related subprogram.
- if Ekind_In (Id1, E_Anonymous_Access_Subprogram_Type,
- E_Subprogram_Type)
+ if Ekind (Id1) in E_Anonymous_Access_Subprogram_Type
+ | E_Subprogram_Type
or else
- Ekind_In (Id2, E_Anonymous_Access_Subprogram_Type,
- E_Subprogram_Type)
+ Ekind (Id2) in E_Anonymous_Access_Subprogram_Type
+ | E_Subprogram_Type
then
return True;
if Ctype >= Mode_Conformant then
if Parameter_Mode (Old_Formal) /= Parameter_Mode (New_Formal) then
- if not Ekind_In (New_Id, E_Function, E_Procedure)
+ if Ekind (New_Id) not in E_Function | E_Procedure
or else not Is_Primitive_Wrapper (New_Id)
then
Conformance_Error ("\mode of & does not match!", New_Formal);
Decl := Unit_Declaration_Node (Subp);
end if;
- if Nkind_In (Decl, N_Subprogram_Body,
- N_Subprogram_Body_Stub,
- N_Subprogram_Declaration,
- N_Abstract_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration)
+ if Nkind (Decl) in N_Subprogram_Body
+ | N_Subprogram_Body_Stub
+ | N_Subprogram_Declaration
+ | N_Abstract_Subprogram_Declaration
+ | N_Subprogram_Renaming_Declaration
then
Spec := Specification (Decl);
if Present (Overridden_Subp)
and then (not Is_Hidden (Overridden_Subp)
or else
- (Nam_In (Chars (Overridden_Subp), Name_Initialize,
- Name_Adjust,
- Name_Finalize)
+ (Chars (Overridden_Subp) in Name_Initialize
+ | Name_Adjust
+ | Name_Finalize
and then Present (Alias (Overridden_Subp))
and then (not Is_Hidden (Alias (Overridden_Subp))
or else In_Instance)))
-- Don't count exception junk
or else
- (Nkind_In (Last_Stm, N_Goto_Statement,
- N_Label,
- N_Object_Declaration)
+ (Nkind (Last_Stm) in
+ N_Goto_Statement | N_Label | N_Object_Declaration
and then Exception_Junk (Last_Stm))
- or else Nkind (Last_Stm) in N_Push_xxx_Label
- or else Nkind (Last_Stm) in N_Pop_xxx_Label
+ or else Nkind (Last_Stm) in N_Push_xxx_Label | N_Pop_xxx_Label
-- Inserted code, such as finalization calls, is irrelevant: we only
-- need to check original source.
function Is_Valid_Formal (F : Entity_Id) return Boolean is
begin
return
- Ekind_In (F, E_In_Out_Parameter, E_Out_Parameter)
+ Ekind (F) in E_In_Out_Parameter | E_Out_Parameter
or else
(Nkind (Parameter_Type (Parent (F))) = N_Access_Definition
and then not Constant_Present (Parameter_Type (Parent (F))));
-- Entries and procedures can override abstract or null interface
-- procedures.
- elsif Ekind_In (Def_Id, E_Entry, E_Procedure)
+ elsif Ekind (Def_Id) in E_Entry | E_Procedure
and then Ekind (Subp) = E_Procedure
and then Matches_Prefixed_View_Profile
(Parameter_Specifications (Parent (Def_Id)),
-- override, the first parameter of the overridden routine
-- must be of mode "out", "in out", or access-to-variable.
- if Ekind_In (Candidate, E_Entry, E_Procedure)
+ if Ekind (Candidate) in E_Entry | E_Procedure
and then Is_Protected_Type (Typ)
and then not Is_Valid_Formal (Formal)
then
-- or both could be access to protected subprograms.
Are_Anonymous_Access_To_Subprogram_Types :=
- Ekind_In (Type_1, E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type)
+ Ekind (Type_1) in E_Anonymous_Access_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
and then
- Ekind_In (Type_2, E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type);
+ Ekind (Type_2) in E_Anonymous_Access_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type;
-- Test anonymous access type case. For this case, static subtype
-- matching is required for mode conformance (RM 6.3.1(15)). We check
-- to this are inherited operations from a parent type in which
-- case the derived type acts as their parent.
- if Nkind_In (Subp_Decl, N_Function_Specification,
- N_Procedure_Specification)
+ if Nkind (Subp_Decl) in N_Function_Specification
+ | N_Procedure_Specification
then
Subp_Decl := Parent (Subp_Decl);
end if;
-- conformant with it. That can occur in cases where an
-- actual type causes unrelated homographs in the instance.
- if Nkind_In (N, N_Subprogram_Body,
- N_Subprogram_Renaming_Declaration)
+ if Nkind (N) in N_Subprogram_Body
+ | N_Subprogram_Renaming_Declaration
and then Present (Homonym (E))
and then not Fully_Conformant (Designator, E)
then
function User_Defined_Numeric_Literal_Mismatch return Boolean is
E1_Is_User_Defined : constant Boolean :=
- not Nkind_In (Given_E1, N_Integer_Literal, N_Real_Literal);
+ Nkind (Given_E1) not in N_Integer_Literal | N_Real_Literal;
E2_Is_User_Defined : constant Boolean :=
- not Nkind_In (Given_E2, N_Integer_Literal, N_Real_Literal);
+ Nkind (Given_E2) not in N_Integer_Literal | N_Real_Literal;
+
begin
pragma Assert (E1_Is_User_Defined = E2_Is_User_Defined);
H := Homonym (H);
exit when not Present (H) or else Scope (H) /= Scope (S);
- if Nkind_In
- (Parent (H),
- N_Private_Extension_Declaration,
- N_Private_Type_Declaration)
+ if Nkind (Parent (H)) in
+ N_Private_Extension_Declaration |
+ N_Private_Type_Declaration
and then Defining_Identifier (Parent (H)) = Partial_View
then
return True;
and then not Is_Generic_Type (Formal_Type)
and then not Is_Class_Wide_Type (Formal_Type)
then
- if not Nkind_In
- (Parent (T), N_Access_Function_Definition,
- N_Access_Procedure_Definition)
+ if Nkind (Parent (T)) not in
+ N_Access_Function_Definition |
+ N_Access_Procedure_Definition
then
Append_Elmt (Current_Scope,
Private_Dependents (Base_Type (Formal_Type)));
end if;
end if;
- elsif not Nkind_In (Parent (T), N_Access_Function_Definition,
- N_Access_Procedure_Definition)
+ elsif Nkind (Parent (T)) not in N_Access_Function_Definition
+ | N_Access_Procedure_Definition
then
-- AI05-0151: Tagged incomplete types are allowed in all
-- formal parts. Untagged incomplete types are not allowed
then
null;
- elsif Nkind_In (Context, N_Accept_Statement,
- N_Accept_Alternative,
- N_Entry_Body)
+ elsif Nkind (Context) in N_Accept_Statement
+ | N_Accept_Alternative
+ | N_Entry_Body
or else (Nkind (Context) = N_Subprogram_Body
and then Comes_From_Source (Context))
then
-- these are not standard Ada legality rules.
if SPARK_Mode = On then
- if Ekind_In (Scope (Formal), E_Function, E_Generic_Function) then
+ if Ekind (Scope (Formal)) in E_Function | E_Generic_Function then
-- A function cannot have a parameter of mode IN OUT or OUT
-- (SPARK RM 6.1).
- if Ekind_In (Formal, E_In_Out_Parameter, E_Out_Parameter) then
+ if Ekind (Formal) in E_In_Out_Parameter | E_Out_Parameter then
Error_Msg_N
("function cannot have parameter of mode `OUT` or "
& "`IN OUT`", Formal);
Set_Has_Out_Or_In_Out_Parameter (Id, True);
end if;
- if Ekind_In (Id, E_Function, E_Generic_Function) then
+ if Ekind (Id) in E_Function | E_Generic_Function then
-- [IN] OUT parameters allowed for functions in Ada 2012
-- Verify that user-defined operators have proper number of arguments
-- First case of operators which can only be unary
- if Nam_In (Id, Name_Op_Not, Name_Op_Abs) then
+ if Id in Name_Op_Not | Name_Op_Abs then
N_OK := (N = 1);
-- Case of operators which can be unary or binary
- elsif Nam_In (Id, Name_Op_Add, Name_Op_Subtract) then
+ elsif Id in Name_Op_Add | Name_Op_Subtract then
N_OK := (N in 1 .. 2);
-- All other operators can only be binary
-- if they are not followed by a construct which can reference
-- and export them.
- elsif Nkind_In (Decl, N_Exception_Declaration,
- N_Object_Declaration,
- N_Object_Renaming_Declaration)
+ elsif Nkind (Decl) in N_Exception_Declaration
+ | N_Object_Declaration
+ | N_Object_Renaming_Declaration
then
Decl_Id := Defining_Entity (Decl);
-- for them to see whether they are referenced on an individual
-- basis by looking into the table of referenced subprograms.
- elsif Nkind_In (Decl, N_Subprogram_Declaration,
- N_Subprogram_Renaming_Declaration)
+ elsif Nkind (Decl) in N_Subprogram_Declaration
+ | N_Subprogram_Renaming_Declaration
then
Decl_Id := Defining_Entity (Decl);
then
Generate_Reference (Id, Scope (Id), 'k', False);
- elsif not Nkind_In (Unit (Cunit (Main_Unit)), N_Subprogram_Body,
- N_Subunit)
+ elsif Nkind (Unit (Cunit (Main_Unit))) not in
+ N_Subprogram_Body | N_Subunit
then
-- If current unit is an ancestor of main unit, generate a
-- reference to its own parent.
-- prevents cascaded errors when routines defined only for type
-- entities are called with non-type entities.
- if Nkind_In (Decl, N_Incomplete_Type_Declaration,
- N_Private_Type_Declaration)
+ if Nkind (Decl) in N_Incomplete_Type_Declaration
+ | N_Private_Type_Declaration
and then Is_Type (Defining_Identifier (Decl))
and then Has_Discriminants (Defining_Identifier (Decl))
and then Present (Full_View (Defining_Identifier (Decl)))
while Present (Gen_Par) and then Is_Child_Unit (Gen_Par) loop
Inst_Node := Get_Unit_Instantiation_Node (Inst_Par);
- if Nkind_In (Inst_Node, N_Package_Instantiation,
- N_Formal_Package_Declaration)
+ if Nkind (Inst_Node) in
+ N_Package_Instantiation | N_Formal_Package_Declaration
and then Nkind (Name (Inst_Node)) = N_Expanded_Name
then
Inst_Par := Entity (Prefix (Name (Inst_Node)));
-- implicit completion at some point.
elsif (Is_Overloadable (Id)
- and then not Ekind_In (Id, E_Enumeration_Literal, E_Operator)
+ and then Ekind (Id) not in E_Enumeration_Literal | E_Operator
and then not Is_Abstract_Subprogram (Id)
and then not Has_Completion (Id)
and then Comes_From_Source (Parent (Id)))
and then not Is_Generic_Type (Id))
or else
- (Ekind_In (Id, E_Task_Type, E_Protected_Type)
+ (Ekind (Id) in E_Task_Type | E_Protected_Type
and then not Has_Completion (Id))
or else
Check_Conventions (Id);
end if;
- if Ekind_In (Id, E_Private_Type, E_Limited_Private_Type)
+ if Ekind (Id) in E_Private_Type | E_Limited_Private_Type
and then No (Full_View (Id))
and then not Is_Generic_Type (Id)
and then not Is_Derived_Type (Id)
Subt : Entity_Id;
begin
- if Nkind_In (Nam, N_Function_Call, N_Explicit_Dereference)
+ if Nkind (Nam) in N_Function_Call | N_Explicit_Dereference
and then Is_Composite_Type (Typ)
and then not Is_Constrained (Typ)
and then not Has_Unknown_Discriminants (Typ)
then
-- If Actual_Subtype is already set, nothing to do
- if Ekind_In (Id, E_Variable, E_Constant)
+ if Ekind (Id) in E_Variable | E_Constant
and then Present (Actual_Subtype (Id))
then
null;
-- check.
if Comes_From_Source (N) then
- if Nkind_In (Nam, N_Function_Call, N_Explicit_Dereference) then
+ if Nkind (Nam) in N_Function_Call | N_Explicit_Dereference then
Is_Object_Ref := Is_Object_Reference (Nam);
else
Is_Object_Ref := Is_Object_Reference (Original_Node (Nam));
-- Generate:
-- return Subp_Id (Actuals);
- if Ekind_In (Subp_Id, E_Function, E_Operator) then
+ if Ekind (Subp_Id) in E_Function | E_Operator then
return
Make_Simple_Return_Statement (Loc,
Expression =>
Formal : Node_Id;
begin
- pragma Assert (Ekind_In (Subp_Id, E_Function, E_Operator));
+ pragma Assert (Ekind (Subp_Id) in E_Function | E_Operator);
-- Build the actual parameters of the call
-- dispatching call to the wrapped function is known during proof.
if GNATprove_Mode
- and then Ekind_In (Ren_Id, E_Function, E_Operator)
+ and then Ekind (Ren_Id) in E_Function | E_Operator
then
New_Spec := Build_Spec (Ren_Id);
Body_Decl :=
-- Guard against previous errors, and omit renamings of predefined
-- operators.
- elsif not Ekind_In (Old_S, E_Function, E_Procedure) then
+ elsif Ekind (Old_S) not in E_Function | E_Procedure then
null;
elsif Requires_Overriding (Old_S)
elsif Present (Expressions (Nam)) then
Error_Msg_N ("illegal expressions in attribute reference", Nam);
- elsif
- Nam_In (Aname, Name_Compose, Name_Exponent, Name_Leading_Part,
- Name_Pos, Name_Round, Name_Scaling,
- Name_Val)
+ elsif Aname in Name_Compose | Name_Exponent | Name_Leading_Part |
+ Name_Pos | Name_Round | Name_Scaling |
+ Name_Val
then
if Nkind (N) = N_Subprogram_Renaming_Declaration
and then Present (Corresponding_Formal_Spec (N))
elsif Is_Concurrent_Type (Scope (E)) then
P := Parent (N);
while Present (P)
- and then not Nkind_In (P, N_Parameter_Specification,
- N_Component_Declaration)
+ and then Nkind (P) not in
+ N_Parameter_Specification | N_Component_Declaration
loop
P := Parent (P);
end loop;
Pop_Scope;
while not (Is_List_Member (Decl))
- or else Nkind_In (Parent (Decl), N_Protected_Definition,
- N_Task_Definition)
+ or else Nkind (Parent (Decl)) in N_Protected_Definition
+ | N_Task_Definition
loop
Decl := Parent (Decl);
end loop;
-- is Put or Put_Line, then add a special error message (since
-- this is a very common error for beginners to make).
- if Nam_In (Chars (N), Name_Put, Name_Put_Line) then
+ if Chars (N) in Name_Put | Name_Put_Line then
Error_Msg_N -- CODEFIX
("\\possible missing `WITH Ada.Text_'I'O; " &
"USE Ada.Text_'I'O`!", N);
if Ada_Version >= Ada_2012
and then
(Nkind (Parent (N)) in N_Subexpr
- or else Nkind_In (Parent (N), N_Assignment_Statement,
- N_Object_Declaration,
- N_Parameter_Association))
+ or else Nkind (Parent (N)) in N_Assignment_Statement
+ | N_Object_Declaration
+ | N_Parameter_Association)
then
Check_Implicit_Dereference (N, Etype (E));
end if;
Par := Nod;
while Present (Par) loop
if Nkind (Par) = N_Pragma then
- if Nam_In (Pragma_Name_Unmapped (Par),
- Name_Abstract_State,
- Name_Depends,
- Name_Global,
- Name_Initializes,
- Name_Refined_Depends,
- Name_Refined_Global)
+ if Pragma_Name_Unmapped (Par)
+ in Name_Abstract_State
+ | Name_Depends
+ | Name_Global
+ | Name_Initializes
+ | Name_Refined_Depends
+ | Name_Refined_Global
then
return True;
-- The non-limited view may itself be incomplete, in which case
-- get the full view if available.
- elsif Ekind_In (Id, E_Incomplete_Type, E_Class_Wide_Type)
+ elsif Ekind (Id) in E_Incomplete_Type | E_Class_Wide_Type
and then From_Limited_With (Id)
and then Present (Non_Limited_View (Id))
and then Scope (Non_Limited_View (Id)) = P_Name
end;
if No (Id)
- and then Ekind_In (P_Name, E_Procedure, E_Function)
+ and then Ekind (P_Name) in E_Procedure | E_Function
and then Is_Generic_Instance (P_Name)
then
-- Expanded name denotes entity in (instance of) generic subprogram.
exit when S = Standard_Standard;
- if Ekind_In (S, E_Function,
- E_Package,
- E_Procedure)
+ if Ekind (S) in E_Function | E_Package | E_Procedure
then
P :=
Generic_Parent (Specification
-- The subprogram may be a renaming (of an enclosing scope) as
-- in the case of the name of the generic within an instantiation.
- if Ekind_In (P_Name, E_Procedure, E_Function)
+ if Ekind (P_Name) in E_Procedure | E_Function
and then Present (Alias (P_Name))
and then Is_Generic_Instance (Alias (P_Name))
then
pragma Assert (No (Old_F));
- if Ekind_In (Old_S, E_Function, E_Enumeration_Literal) then
+ if Ekind (Old_S) in E_Function | E_Enumeration_Literal then
Set_Etype (New_S, Etype (Old_S));
end if;
end if;
-- Use clauses in and of themselves do not count as a "use" of a
-- package.
- if Nkind_In (Parent (Id), N_Use_Package_Clause, N_Use_Type_Clause) then
+ if Nkind (Parent (Id)) in N_Use_Package_Clause | N_Use_Type_Clause then
return;
end if;
-- Mark primitives
elsif (Ekind (Id) in Overloadable_Kind
- or else Ekind_In (Id, E_Generic_Function,
- E_Generic_Procedure))
+ or else Ekind (Id) in
+ E_Generic_Function | E_Generic_Procedure)
and then (Is_Potentially_Use_Visible (Id)
or else Is_Intrinsic_Subprogram (Id)
- or else (Ekind_In (Id, E_Function, E_Procedure)
+ or else (Ekind (Id) in E_Function | E_Procedure
and then Is_Generic_Actual_Subprogram (Id)))
then
Mark_Parameters (Id);
-- Ignore fully qualified names as they do not count as a "use" of
-- a package.
- if Nkind_In (Id, N_Identifier, N_Operator_Symbol)
+ if Nkind (Id) in N_Identifier | N_Operator_Symbol
or else (Present (Prefix (Id))
and then Scope (Entity (Id)) /= Entity (Prefix (Id)))
then
& "use_type_clause #??", Clause1, T);
return;
- elsif Nkind_In (Unit2, N_Package_Body, N_Subprogram_Body)
+ elsif Nkind (Unit2) in N_Package_Body | N_Subprogram_Body
and then Nkind (Unit1) /= Nkind (Unit2)
and then Nkind (Unit1) /= N_Subunit
then
-- when Lock_Free_Given is True.
begin
- pragma Assert (Nkind_In (N, N_Protected_Type_Declaration,
- N_Protected_Body));
+ pragma Assert
+ (Nkind (N) in N_Protected_Type_Declaration | N_Protected_Body);
-- The lock-free implementation is currently enabled through a debug
-- flag. When Lock_Free_Given is True, an aspect Lock_Free forces the
if Ekind (Id) = E_Component then
Comp_Id := Id;
- elsif Ekind_In (Id, E_Constant, E_Variable)
+ elsif Ekind (Id) in E_Constant | E_Variable
and then Present (Prival_Link (Id))
then
Comp_Id := Prival_Link (Id);
Analyze_List (Pragmas_Before (N));
end if;
- if Nkind_In (Parent (N), N_Selective_Accept, N_Timed_Entry_Call) then
+ if Nkind (Parent (N)) in N_Selective_Accept | N_Timed_Entry_Call then
Expr := Expression (Delay_Statement (N));
-- Defer full analysis until the statement is expanded, to insure
Item_Id := First_Entity (Prot_Typ);
while Present (Item_Id) loop
- if Ekind_In (Item_Id, E_Function, E_Procedure) then
+ if Ekind (Item_Id) in E_Function | E_Procedure then
Set_Convention (Item_Id, Convention_Protected);
else
Propagate_Concurrent_Flags (Prot_Typ, Etype (Item_Id));
Enclosing := Scope_Stack.Table (J).Entity;
exit when Is_Entry (Enclosing);
- if not Ekind_In (Enclosing, E_Block, E_Loop) then
+ if Ekind (Enclosing) not in E_Block | E_Loop then
Error_Msg_N ("requeue must appear within accept or entry body", N);
return;
end if;
-- perform an unconditional goto so that any further
-- references will not occur anyway.
- if Ekind_In (Ent, E_Out_Parameter, E_In_Out_Parameter) then
+ if Ekind (Ent) in E_Out_Parameter | E_In_Out_Parameter then
Set_Never_Set_In_Source (Ent, False);
Set_Is_True_Constant (Ent, False);
end if;
begin
pragma Assert
- (Nkind_In (N, N_Protected_Type_Declaration, N_Task_Type_Declaration));
+ (Nkind (N) in N_Protected_Type_Declaration | N_Task_Type_Declaration);
if Present (Interface_List (N)) then
Set_Is_Tagged_Type (T);
-- Named symbol argument
if No (Symbol_Expr)
- or else not Nkind_In (Symbol_Expr, N_Character_Literal,
- N_String_Literal)
+ or else Nkind (Symbol_Expr) not in
+ N_Character_Literal | N_String_Literal
then
Symbol_Expr := Empty;
-- Verify symbol expression is a string or a character
- if not Nkind_In (Symbol_Expr, N_Character_Literal,
- N_String_Literal)
+ if Nkind (Symbol_Expr) not in
+ N_Character_Literal | N_String_Literal
then
Symbol_Expr := Empty;
Error_Msg_N
-- Special error if no Symbol choice but expression is string
-- or character.
- elsif Nkind_In (Expression (Assoc), N_Character_Literal,
- N_String_Literal)
+ elsif Nkind (Expression (Assoc)) in
+ N_Character_Literal | N_String_Literal
then
Num_Choices := Num_Choices + 1;
Error_Msg_N
-- Check the second argument for each dimension aggregate is
-- a string or a character.
- if not Nkind_In (Unit_Symbol, N_String_Literal,
- N_Character_Literal)
+ if Nkind (Unit_Symbol) not in
+ N_String_Literal | N_Character_Literal
then
Error_Msg_N
("expected unit symbol (string or character)",
-- Check the third argument for each dimension aggregate is
-- a string or a character.
- if not Nkind_In (Dim_Symbol, N_String_Literal,
- N_Character_Literal)
+ if Nkind (Dim_Symbol) not in
+ N_String_Literal | N_Character_Literal
then
Error_Msg_N
("expected dimension symbol (string or character)",
return;
elsif not Comes_From_Source (N) then
- if Nkind_In (N, N_Explicit_Dereference,
- N_Identifier,
- N_Object_Declaration,
- N_Subtype_Declaration)
+ if Nkind (N) not in N_Explicit_Dereference
+ | N_Identifier
+ | N_Object_Declaration
+ | N_Subtype_Declaration
then
- null;
- else
return;
end if;
end if;
return;
end if;
- if Nkind_In (N_Kind, N_Op_Add, N_Op_Expon, N_Op_Subtract)
- or else N_Kind in N_Multiplying_Operator
- or else N_Kind in N_Op_Compare
+ if N_Kind in N_Op_Add | N_Op_Expon | N_Op_Subtract
+ | N_Multiplying_Operator | N_Op_Compare
then
declare
L : constant Node_Id := Left_Opnd (N);
begin
-- N_Op_Add, N_Op_Mod, N_Op_Rem or N_Op_Subtract case
- if Nkind_In (N, N_Op_Add, N_Op_Mod, N_Op_Rem, N_Op_Subtract) then
+ if N_Kind in N_Op_Add | N_Op_Mod | N_Op_Rem | N_Op_Subtract then
-- Check both operands have same dimension
-- N_Op_Multiply or N_Op_Divide case
- elsif Nkind_In (N_Kind, N_Op_Multiply, N_Op_Divide) then
+ elsif N_Kind in N_Op_Multiply | N_Op_Divide then
-- Check at least one operand is not dimensionless
-- literal is treated as if its dimension matches the type
-- dimension.
- elsif Nkind_In (Original_Node (L), N_Integer_Literal,
- N_Real_Literal)
+ elsif Nkind (Original_Node (L)) in
+ N_Integer_Literal | N_Real_Literal
then
Dim_Warning_For_Numeric_Literal (L, Etype (R));
- elsif Nkind_In (Original_Node (R), N_Integer_Literal,
- N_Real_Literal)
+ elsif Nkind (Original_Node (R)) in
+ N_Integer_Literal | N_Real_Literal
then
Dim_Warning_For_Numeric_Literal (R, Etype (L));
-- dimensionless to indicate the literal is treated as if its
-- dimension matches the type dimension.
- if Nkind_In (Original_Node (Expr), N_Real_Literal,
- N_Integer_Literal)
+ if Nkind (Original_Node (Expr)) in
+ N_Real_Literal | N_Integer_Literal
then
Dim_Warning_For_Numeric_Literal (Expr, Etyp);
if Present (Expr)
and then Dims_Of_Typ /= Dimensions_Of (Expr)
- and then Nkind_In (Original_Node (Expr), N_Real_Literal,
- N_Integer_Literal)
+ and then Nkind (Original_Node (Expr)) in
+ N_Real_Literal | N_Integer_Literal
then
Dim_Warning_For_Numeric_Literal (Expr, Etype (Typ));
end if;
Check_Error_Detected;
return;
- elsif Ekind_In (Id, E_Constant, E_Named_Real)
+ elsif Ekind (Id) in E_Constant | E_Named_Real
and then Exists (Dimensions_Of (Id))
then
Set_Dimensions (N, Dimensions_Of (Id));
-- not dimensionless to indicate the literal is treated as if
-- its dimension matches the type dimension.
- if Nkind_In (Original_Node (Expr), N_Real_Literal,
- N_Integer_Literal)
+ if Nkind (Original_Node (Expr)) in
+ N_Real_Literal | N_Integer_Literal
then
Dim_Warning_For_Numeric_Literal (Expr, Etyp);
Next_Formal (Formal);
end loop;
- if Ekind_In (Subp, E_Function, E_Generic_Function) then
+ if Ekind (Subp) in E_Function | E_Generic_Function then
Ctrl_Type := Check_Controlling_Type (Etype (Subp), Subp);
if Present (Ctrl_Type) then
Par := Parent (Par);
end if;
- if Nkind_In (Par, N_Function_Call, N_Procedure_Call_Statement)
+ if Nkind (Par) in N_Function_Call | N_Procedure_Call_Statement
and then Is_Entity_Name (Name (Par))
then
declare
-- For equality operators, one of the operands must be
-- statically or dynamically tagged.
- elsif Nkind_In (Par, N_Op_Eq, N_Op_Ne) then
+ elsif Nkind (Par) in N_Op_Eq | N_Op_Ne then
if N = Right_Opnd (Par)
and then Is_Tag_Indeterminate (Left_Opnd (Par))
then
-- Start of processing for Check_Dispatching_Operation
begin
- if not Ekind_In (Subp, E_Function, E_Procedure) then
+ if Ekind (Subp) not in E_Function | E_Procedure then
return;
-- The Default_Initial_Condition procedure is not a primitive subprogram
-- visible operation that may be declared in a partial view when
-- the full view is controlled.
- if Nam_In (Chars (Subp), Name_Initialize, Name_Adjust, Name_Finalize)
+ if Chars (Subp) in Name_Initialize | Name_Adjust | Name_Finalize
and then Is_Controlled (Tagged_Type)
and then not Is_Visibly_Controlled (Tagged_Type)
and then not Is_Inherited_Public_Operation (Ovr_Subp)
Set_DT_Position_Value (Subp, No_Uint);
elsif Has_Controlled_Component (Tagged_Type)
- and then Nam_In (Chars (Subp), Name_Initialize,
- Name_Adjust,
- Name_Finalize,
- Name_Finalize_Address)
+ and then Chars (Subp) in Name_Initialize
+ | Name_Adjust
+ | Name_Finalize
+ | Name_Finalize_Address
then
declare
F_Node : constant Node_Id := Freeze_Node (Tagged_Type);
Ctrl_Type : Entity_Id;
begin
- if Ekind_In (Subp, E_Function, E_Procedure)
+ if Ekind (Subp) in E_Function | E_Procedure
and then Present (DTC_Entity (Subp))
then
return Scope (DTC_Entity (Subp));
-- we are generating code.
if Comes_From_Source (P)
+ and then Expander_Active
and then Is_Record_Type (ET)
- and then (Is_Remote_Call_Interface (ET)
- or else Is_Remote_Types (ET))
+ and then (Is_Remote_Call_Interface (ET) or else Is_Remote_Types (ET))
and then Present (Corresponding_Remote_Type (ET))
- and then Nkind_In (Parent (Parent (P)), N_Procedure_Call_Statement,
- N_Indexed_Component)
- and then Expander_Active
+ and then Nkind (Parent (Parent (P))) in
+ N_Procedure_Call_Statement | N_Indexed_Component
then
RAS_E_Dereference (P);
return True;
Par := Parent (Call);
while Present (Par) loop
- if Nkind_In (Par, N_Package_Body, N_Package_Declaration) then
+ if Nkind (Par) in N_Package_Body | N_Package_Declaration then
return Defining_Entity (Par);
elsif Nkind (Par) = N_Handled_Sequence_Of_Statements then
-- task objects found in the declarations.
else
- pragma Assert (Nkind_In (Context, N_Block_Statement,
- N_Entry_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body));
+ pragma Assert
+ (Nkind (Context) in
+ N_Block_Statement | N_Entry_Body | N_Protected_Body |
+ N_Subprogram_Body | N_Task_Body);
Traverse_List
(List => Declarations (Context),
-- When the name denotes an array or record component, find the whole
-- object.
- while Nkind_In (Nam, N_Explicit_Dereference,
- N_Indexed_Component,
- N_Selected_Component,
- N_Slice)
+ while Nkind (Nam) in
+ N_Explicit_Dereference | N_Indexed_Component |
+ N_Selected_Component | N_Slice
loop
Nam := Prefix (Nam);
end loop;
elsif (Debug_Flag_Underscore_A
or else Restriction_Active
(No_Entry_Calls_In_Elaboration_Code))
- and then Nkind_In (Original_Node (Scen), N_Accept_Statement,
- N_Selective_Accept)
+ and then Nkind (Original_Node (Scen)) in
+ N_Accept_Statement | N_Selective_Accept
then
return Abandon;
-- until expansion transforms the node and relocates the contents.
-- Examine these lists in case expansion is disabled.
- elsif Nkind_In (Scen, N_And_Then, N_Or_Else) then
+ elsif Nkind (Scen) in N_And_Then | N_Or_Else then
Traverse_List (Actions (Scen));
- elsif Nkind_In (Scen, N_Elsif_Part, N_Iteration_Scheme) then
+ elsif Nkind (Scen) in N_Elsif_Part | N_Iteration_Scheme then
Traverse_List (Condition_Actions (Scen));
elsif Nkind (Scen) = N_If_Expression then
Traverse_List (Then_Actions (Scen));
Traverse_List (Else_Actions (Scen));
- elsif Nkind_In (Scen, N_Component_Association,
- N_Iterated_Component_Association)
+ elsif Nkind (Scen) in
+ N_Component_Association | N_Iterated_Component_Association
then
Traverse_List (Loop_Actions (Scen));
-- contexts because nested calls has not been relocated to their
-- final context.
- if Nkind_In (Par, N_Aspect_Specification,
- N_Generic_Association)
+ if Nkind (Par) in N_Aspect_Specification | N_Generic_Association
then
return True;
-- To qualify, the node must appear immediately within a source call
-- which invokes a source target.
- if Nkind_In (Outer_Call, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ if Nkind (Outer_Call) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
and then Comes_From_Source (Outer_Call)
then
Outer_Nam := Call_Name (Outer_Call);
return
Nkind (Subp_Decl) = N_Subprogram_Renaming_Declaration
and then not Comes_From_Source (Subp_Decl)
- and then Nkind_In (Context, N_Function_Specification,
- N_Package_Specification,
- N_Procedure_Specification)
+ and then Nkind (Context) in N_Function_Specification
+ | N_Package_Specification
+ | N_Procedure_Specification
and then Present (Generic_Parent (Context));
end Is_Generic_Formal_Subp;
-- Nothing to do when the input does not denote a call or a requeue
- elsif not Nkind_In (N, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement,
- N_Requeue_Statement)
+ elsif Nkind (N) not in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
+ | N_Requeue_Statement
then
return;
-- elaboration) is in effect.
elsif Debug_Flag_Underscore_E
- and then Nkind_In (N, N_Entry_Call_Statement, N_Requeue_Statement)
+ and then Nkind (N) in N_Entry_Call_Statement | N_Requeue_Statement
then
return;
(Marker, Find_Enclosing_Level (N) = Declaration_Level);
Set_Is_Dispatching_Call
- (Marker, Nkind_In (N, N_Function_Call, N_Procedure_Call_Statement)
- and then Present (Controlling_Argument (N)));
+ (Marker,
+ Nkind (N) in N_Function_Call | N_Procedure_Call_Statement
+ and then Present (Controlling_Argument (N)));
Set_Is_Elaboration_Checks_OK_Node
(Marker, Is_Elaboration_Checks_OK_Node (N));
-- statement due to expansion activities.
if Nkind (Comp_Unit) = N_Null_Statement
- and then Nkind_In (Original_Node (Comp_Unit), N_Protected_Body,
- N_Task_Body)
+ and then Nkind (Original_Node (Comp_Unit)) in
+ N_Protected_Body | N_Task_Body
then
Comp_Unit := Parent (Comp_Unit);
pragma Assert (Nkind (Comp_Unit) = N_Subunit);
-- the instantiated subprogram.
if Nkind (Comp_Unit) = N_Package_Specification
- and then Nkind_In (Original_Node (Parent (Comp_Unit)),
- N_Function_Instantiation,
- N_Procedure_Instantiation)
+ and then Nkind (Original_Node (Parent (Comp_Unit))) in
+ N_Function_Instantiation | N_Procedure_Instantiation
then
Comp_Unit := Parent (Parent (Comp_Unit));
-- Enter encapsulators by inspecting their declarations and/or
-- statements.
- if Nkind_In (Curr, N_Block_Statement, N_Package_Body) then
+ if Nkind (Curr) in N_Block_Statement | N_Package_Body then
Enter_Handled_Body (Curr);
elsif Nkind (Curr) = N_Package_Declaration then
-- amount of work, but has the beneficial effect of computing
-- the early call regions of all preceding bodies.
- elsif Nkind_In (Curr, N_Entry_Body, N_Subprogram_Body) then
+ elsif Nkind (Curr) in N_Entry_Body | N_Subprogram_Body then
Start :=
Find_Early_Call_Region
(Body_Decl => Curr,
-- visible declarations -> upper level
-- visible declarations -> terminate
- if Nkind_In (Context, N_Package_Specification,
- N_Protected_Definition,
- N_Task_Definition)
+ if Nkind (Context) in N_Package_Specification
+ | N_Protected_Definition
+ | N_Task_Definition
then
Transition_Spec_Declarations (Context, Curr);
-- declarations -> corresponding package spec (Elab_Body)
-- declarations -> terminate
- elsif Nkind_In (Context, N_Block_Statement,
- N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ elsif Nkind (Context) in N_Block_Statement
+ | N_Entry_Body
+ | N_Package_Body
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
Transition_Body_Declarations (Context, Curr);
-- The search must come from the statements of certain bodies or
-- statements.
- pragma Assert (Nkind_In (Bod, N_Block_Statement,
- N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body));
+ pragma Assert
+ (Nkind (Bod) in
+ N_Block_Statement |
+ N_Entry_Body |
+ N_Package_Body |
+ N_Protected_Body |
+ N_Subprogram_Body |
+ N_Task_Body);
-- The search must come from the statements of the handled
-- sequence.
begin
-- Nothing to do if the pragma is not related to elaboration
- if not Nam_In (Prag_Nam, Name_Elaborate, Name_Elaborate_All) then
+ if Prag_Nam not in Name_Elaborate | Name_Elaborate_All then
return;
-- Nothing to do when the pragma is illegal
-- body -> spec
if Present (Unit_Id)
- and then Nkind_In (Unit_Id, N_Package_Body, N_Subprogram_Body)
+ and then Nkind (Unit_Id) in N_Package_Body | N_Subprogram_Body
then
Find_Elaboration_Context (Parent (Unit_Id));
-- parent spec -> grandparent spec and so on
if Present (Unit_Id)
- and then Nkind_In (Unit_Id, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Declaration,
- N_Subprogram_Declaration)
+ and then Nkind (Unit_Id) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Package_Declaration
+ | N_Subprogram_Declaration
then
Find_Elaboration_Context (Parent (Unit_Id));
Prag_Nam : Name_Id;
In_State : Processing_In_State)
is
- pragma Assert (Nam_In (Prag_Nam, Name_Elaborate, Name_Elaborate_All));
+ pragma Assert (Prag_Nam in Name_Elaborate | Name_Elaborate_All);
begin
-- Nothing to do when the need for prior elaboration came from a
Req_Nam : Name_Id;
In_State : Processing_In_State)
is
- pragma Assert (Nam_In (Req_Nam, Name_Elaborate, Name_Elaborate_All));
+ pragma Assert (Req_Nam in Name_Elaborate | Name_Elaborate_All);
Main_Id : constant Entity_Id := Main_Unit_Entity;
Unit_Id : constant Entity_Id := Find_Top_Unit (Targ_Id);
-- requirement.
if Present (Unit_Prag)
- and then Nam_In (Pragma_Name (Unit_Prag), Name_Elaborate_All,
- Req_Nam)
+ and then Pragma_Name (Unit_Prag) in Name_Elaborate_All | Req_Nam
then
Req_Met := True;
Par := N;
while Present (Par) loop
- if Nkind_In (Par, N_Package_Body,
- N_Package_Declaration,
- N_Subprogram_Body,
- N_Subprogram_Declaration)
+ if Nkind (Par) in N_Package_Body
+ | N_Package_Declaration
+ | N_Subprogram_Body
+ | N_Subprogram_Declaration
and then Is_Generic_Instance (Unique_Defining_Entity (Par))
then
return Par;
-- but are later relocated in a different context retain their original
-- declaration level.
- if Nkind_In (N, N_Call_Marker,
- N_Function_Instantiation,
- N_Package_Instantiation,
- N_Procedure_Instantiation)
+ if Nkind (N) in N_Call_Marker
+ | N_Function_Instantiation
+ | N_Package_Instantiation
+ | N_Procedure_Instantiation
and then Is_Declaration_Level_Node (N)
then
return Declaration_Level;
-- they are always elaborated when the enclosing context is invoked
-- or elaborated.
- elsif Nkind_In (Curr, N_Package_Body, N_Package_Declaration) then
+ elsif Nkind (Curr) in N_Package_Body | N_Package_Declaration then
null;
-- The current construct is a block statement
-- The current construct is a declaration-level encapsulator
- elsif Nkind_In (Curr, N_Entry_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ elsif Nkind (Curr) in
+ N_Entry_Body | N_Subprogram_Body | N_Task_Body
then
-- If the traversal came from the handled sequence of statments,
-- then the node cannot possibly appear at any level. This is
-- that of the "related instance".
elsif Nkind (N) = N_Package_Declaration
- and then Nkind_In (Orig_N, N_Function_Instantiation,
- N_Procedure_Instantiation)
+ and then Nkind (Orig_N) in
+ N_Function_Instantiation | N_Procedure_Instantiation
and then Nkind (Context) = N_Compilation_Unit
then
return Related_Instance (Defining_Entity (N));
elsif Nkind (N) = N_Subunit
and then Nkind (Proper_Body (N)) = N_Null_Statement
- and then Nkind_In (Original_Node (Proper_Body (N)), N_Protected_Body,
- N_Task_Body)
+ and then Nkind (Original_Node (Proper_Body (N))) in
+ N_Protected_Body | N_Task_Body
then
return Defining_Entity (Original_Node (Proper_Body (N)));
-- Handle various combinations of concurrent and private types
loop
- if Ekind_In (Typ, E_Protected_Type, E_Task_Type)
+ if Ekind (Typ) in E_Protected_Type | E_Task_Type
and then Present (Anonymous_Object (Typ))
then
Typ := Anonymous_Object (Typ);
elsif Is_Task_Type (Id) then
Rec := Create_Task_Rep (Id);
- elsif Ekind_In (Id, E_Constant, E_Variable) then
+ elsif Ekind (Id) in E_Constant | E_Variable then
Rec := Create_Variable_Rep (Id);
- elsif Ekind_In (Id, E_Entry,
- E_Function,
- E_Operator,
- E_Procedure)
+ elsif Ekind (Id) in E_Entry | E_Function | E_Operator | E_Procedure
then
Rec := Create_Subprogram_Rep (Id);
-- The main unit is a body
- if Ekind_In (Main_Unit_Id, E_Package_Body,
- E_Subprogram_Body)
+ if Ekind (Main_Unit_Id) in E_Package_Body | E_Subprogram_Body
then
return In_Body;
-- The main unit is a stand-alone subprogram body
- elsif Ekind_In (Main_Unit_Id, E_Function, E_Procedure)
+ elsif Ekind (Main_Unit_Id) in E_Function | E_Procedure
and then Nkind (Unit_Declaration_Node (Main_Unit_Id)) =
N_Subprogram_Body
then
-- Otherwise the node is in the complementary unit of the main
-- unit. The main unit is a body, the node is in the spec.
- elsif Ekind_In (Main_Unit_Id, E_Package_Body,
- E_Subprogram_Body)
+ elsif Ekind (Main_Unit_Id) in E_Package_Body | E_Subprogram_Body
then
return In_Spec;
-- Protected type
- elsif Nkind_In (Decl, N_Protected_Type_Declaration,
- N_Single_Protected_Declaration)
+ elsif Nkind (Decl) in N_Protected_Type_Declaration
+ | N_Single_Protected_Declaration
then
Process_Protected_Type_Declaration
(Prot_Decl => Decl,
-- Subprogram or entry
- elsif Nkind_In (Decl, N_Entry_Declaration,
- N_Subprogram_Declaration)
+ elsif Nkind (Decl) in N_Entry_Declaration
+ | N_Subprogram_Declaration
then
Process_Subprogram_Declaration
(Subp_Decl => Decl,
-- Task type
- elsif Nkind_In (Decl, N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ elsif Nkind (Decl) in N_Single_Task_Declaration
+ | N_Task_Type_Declaration
then
Process_Task_Type_Declaration
(Task_Decl => Decl,
-- Nothing to do for an abstract subprogram because it has no body to
-- examine.
- elsif Ekind_In (Subp_Id, E_Function, E_Procedure)
+ elsif Ekind (Subp_Id) in E_Function | E_Procedure
and then Is_Abstract_Subprogram (Subp_Id)
then
return;
-- DFS traversal into its barrier function and body.
if In_Extended_Main_Code_Unit (Subp_Id) then
- if Ekind_In (Subp_Id, E_Entry, E_Entry_Family, E_Procedure) then
+ if Ekind (Subp_Id) in E_Entry | E_Entry_Family | E_Procedure then
Traverse_Invocation_Body
(N => Barrier_Body_Declaration (Subp_Rep),
In_State => In_State);
-- Process the entries of the task type because they represent valid
-- entry points into the task body.
- if Nkind_In (Task_Decl, N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ if Nkind (Task_Decl) in N_Single_Task_Declaration
+ | N_Task_Type_Declaration
then
Task_Def := Task_Definition (Task_Decl);
-- Entry, operator, or subprogram call. This case must come last
-- because most invocations above are variations of this case.
- elsif Ekind_In (Targ_Id, E_Entry,
- E_Function,
- E_Operator,
- E_Procedure)
+ elsif Ekind (Targ_Id) in
+ E_Entry | E_Function | E_Operator | E_Procedure
then
Extra := Empty;
Kind := Call;
begin
-- An abstract subprogram does not have a body
- if Ekind_In (Subp_Id, E_Function,
- E_Operator,
- E_Procedure)
+ if Ekind (Subp_Id) in E_Function | E_Operator | E_Procedure
and then Is_Abstract_Subprogram (Subp_Id)
then
return True;
Formal_Id : Entity_Id;
begin
- pragma Assert (Nam_In (Subp_Nam, Name_Adjust,
- Name_Finalize,
- Name_Initialize));
+ pragma Assert
+ (Subp_Nam in Name_Adjust | Name_Finalize | Name_Initialize);
-- To qualify, the subprogram must denote a source procedure with
-- name Adjust, Finalize, or Initialize where the sole formal is
-- protected type.
return
- Ekind_In (Id, E_Function, E_Procedure)
+ Ekind (Id) in E_Function | E_Procedure
and then Is_Protected_Type (Non_Private_View (Scope (Id)));
end Is_Protected_Subp;
-- Protected_Subprogram set.
return
- Ekind_In (Id, E_Function, E_Procedure)
+ Ekind (Id) in E_Function | E_Procedure
and then Present (Protected_Subprogram (Id));
end Is_Protected_Body_Subp;
-- is hidden within an anonymous package, and is a generic instance.
return
- Ekind_In (Id, E_Function, E_Procedure)
+ Ekind (Id) in E_Function | E_Procedure
and then Is_Hidden (Id)
and then Is_Generic_Instance (Id);
end Is_Subprogram_Inst;
-- The attribute name must be one of the 'Access forms. Note that
-- 'Unchecked_Access cannot apply to a subprogram.
- and then Nam_In (Nam, Name_Access, Name_Unrestricted_Access);
+ and then Nam in Name_Access | Name_Unrestricted_Access;
end Is_Suitable_Access_Taken;
----------------------
-- Bodies
- if Nkind_In (N, N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (N) in N_Package_Body
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
Spec_Id := Corresponding_Spec (N);
-- Declarations
- elsif Nkind_In (N, N_Entry_Declaration,
- N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Declaration,
- N_Protected_Type_Declaration,
- N_Subprogram_Declaration,
- N_Task_Type_Declaration)
+ elsif Nkind (N) in N_Entry_Declaration
+ | N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Package_Declaration
+ | N_Protected_Type_Declaration
+ | N_Subprogram_Declaration
+ | N_Task_Type_Declaration
then
Spec_Decl := N;
begin
return
- Nkind_In (Decl, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Declaration,
- N_Protected_Type_Declaration,
- N_Subprogram_Declaration,
- N_Task_Type_Declaration)
+ Nkind (Decl) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Package_Declaration
+ | N_Protected_Type_Declaration
+ | N_Subprogram_Declaration
+ | N_Task_Type_Declaration
and then Present (Corresponding_Body (Decl))
and then Nkind (Parent (Unit_Declaration_Node
(Corresponding_Body (Decl)))) = N_Subunit;
if Nkind (Decl) = N_Subprogram_Body then
Body_Acts_As_Spec := True;
- elsif Nkind_In (Decl, N_Subprogram_Declaration,
- N_Subprogram_Body_Stub)
+ elsif Nkind (Decl) in
+ N_Subprogram_Declaration | N_Subprogram_Body_Stub
or else Inst_Case
then
Body_Acts_As_Spec := False;
P := Parent (N);
while Present (P) loop
- if Nkind_In (P, N_Parameter_Specification,
- N_Component_Declaration)
+ if Nkind (P) in N_Parameter_Specification | N_Component_Declaration
then
return;
-- Filter out case of default expressions, where we do not
-- do the check at this stage.
- if Nkind_In (P, N_Parameter_Specification,
- N_Component_Declaration)
+ if Nkind (P) in
+ N_Parameter_Specification | N_Component_Declaration
then
return;
end if;
if Nkind (P) = N_Protected_Body then
return;
- elsif Nkind_In (P, N_Subprogram_Body,
- N_Task_Body,
- N_Block_Statement,
- N_Entry_Body)
+ elsif Nkind (P) in N_Subprogram_Body
+ | N_Task_Body
+ | N_Block_Statement
+ | N_Entry_Body
then
if L = Declarations (P) then
exit;
-- then there is nothing to do (we do not know what is being assigned),
-- but otherwise this is an assignment to the prefix.
- if Nkind_In (N, N_Indexed_Component,
- N_Selected_Component,
- N_Slice)
- then
+ if Nkind (N) in N_Indexed_Component | N_Selected_Component | N_Slice then
if not Is_Access_Type (Etype (Prefix (N))) then
Check_Elab_Assign (Prefix (N));
end if;
-- If not function or procedure call, instantiation, or 'Access, then
-- ignore call (this happens in some error cases and rewriting cases).
- elsif not Nkind_In (N, N_Attribute_Reference,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ elsif Nkind (N) not in N_Attribute_Reference
+ | N_Function_Call
+ | N_Procedure_Call_Statement
and then not Inst_Case
then
return;
-- code, do not trace past an accept statement, because the rendez-
-- vous will happen after elaboration.
- if Nkind_In (Original_Node (N), N_Accept_Statement,
- N_Selective_Accept)
+ if Nkind (Original_Node (N)) in
+ N_Accept_Statement | N_Selective_Accept
and then Restriction_Active (No_Entry_Calls_In_Elaboration_Code)
then
return Abandon;
elsif not Debug_Flag_Dot_UU
and then Nkind (N) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (N), Name_Access,
- Name_Unrestricted_Access)
+ and then
+ Attribute_Name (N) in Name_Access | Name_Unrestricted_Access
and then Is_Entity_Name (Prefix (N))
and then Is_Subprogram (Entity (Prefix (N)))
then
Sbody := Unit_Declaration_Node (E);
- if not Nkind_In (Sbody, N_Subprogram_Body, N_Package_Body) then
+ if Nkind (Sbody) not in N_Subprogram_Body | N_Package_Body then
Ebody := Corresponding_Body (Sbody);
if No (Ebody) then
-- Check we have an If statement or a null statement (happens
-- when the If has been expanded to be True).
- exit when not Nkind_In (P, N_If_Statement, N_Null_Statement);
+ exit when Nkind (P) not in N_If_Statement | N_Null_Statement;
-- Our special case will be indicated either by the pragma
-- coming from an aspect ...
-- A rather specific check. For Finalize/Adjust/Initialize, if
-- the type has Warnings_Off set, suppress the warning.
- if Nam_In (Chars (E), Name_Adjust,
- Name_Finalize,
- Name_Initialize)
+ if Chars (E) in Name_Adjust
+ | Name_Finalize
+ | Name_Initialize
and then Present (First_Formal (E))
then
declare
function Is_Call_Of_Generic_Formal (N : Node_Id) return Boolean is
begin
- return Nkind_In (N, N_Function_Call, N_Procedure_Call_Statement)
+ return Nkind (N) in N_Function_Call | N_Procedure_Call_Statement
-- Always return False if debug flag -gnatd.G is set
S1 := Scop1;
while S1 /= Standard_Standard
and then not Is_Compilation_Unit (S1)
- and then Ekind_In (S1, E_Package, E_Protected_Type, E_Block)
+ and then Ekind (S1) in E_Package | E_Protected_Type | E_Block
loop
S1 := Scope (S1);
end loop;
S2 := Scop2;
while S2 /= Standard_Standard
and then not Is_Compilation_Unit (S2)
- and then Ekind_In (S2, E_Package, E_Protected_Type, E_Block)
+ and then Ekind (S2) in E_Package | E_Protected_Type | E_Block
loop
S2 := Scope (S2);
end loop;
-- Check for case of body entity
-- Why is the check for E_Void needed???
- if Ekind_In (E, E_Void, E_Subprogram_Body, E_Package_Body) then
+ if Ekind (E) in E_Void | E_Subprogram_Body | E_Package_Body then
Decl := E;
loop
-- Check for case of subprogram
- elsif Ekind_In (E, E_Function, E_Procedure) then
+ elsif Ekind (E) in E_Function | E_Procedure then
-- If Source_Location present, then see if it matches
-- Determine if the out-of-range violation constitutes a warning
-- or an error based on context, according to RM 4.9 (34/3).
- elsif Nkind_In (Original_Node (N), N_Type_Conversion,
- N_Qualified_Expression)
+ elsif Nkind (Original_Node (N)) in
+ N_Type_Conversion | N_Qualified_Expression
and then Comes_From_Source (Original_Node (N))
then
Apply_Compile_Time_Constraint_Error
-- Fixup only required for First/Last attribute reference
if Nkind (N) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (N), Name_First, Name_Last)
+ and then Attribute_Name (N) in Name_First | Name_Last
then
Xtyp := Etype (Prefix (N));
-- Values are the same if they refer to the same entity and the
-- entity is nonvolatile.
- elsif Nkind_In (Lf, N_Identifier, N_Expanded_Name)
- and then Nkind_In (Rf, N_Identifier, N_Expanded_Name)
+ elsif Nkind (Lf) in N_Identifier | N_Expanded_Name
+ and then Nkind (Rf) in N_Identifier | N_Expanded_Name
and then Entity (Lf) = Entity (Rf)
-- If the entity is a discriminant, the two expressions may be
elsif Nkind (Lf) = N_Attribute_Reference
and then Attribute_Name (Lf) = Attribute_Name (Rf)
- and then Nam_In (Attribute_Name (Lf), Name_First, Name_Last)
- and then Nkind_In (Prefix (Lf), N_Identifier, N_Expanded_Name)
- and then Nkind_In (Prefix (Rf), N_Identifier, N_Expanded_Name)
+ and then Attribute_Name (Lf) in Name_First | Name_Last
+ and then Nkind (Prefix (Lf)) in N_Identifier | N_Expanded_Name
+ and then Nkind (Prefix (Rf)) in N_Identifier | N_Expanded_Name
and then Entity (Prefix (Lf)) = Entity (Prefix (Rf))
and then Is_Same_Subscript (Expressions (Lf), Expressions (Rf))
then
-- Other literals and NULL are known at compile time
- elsif
- Nkind_In (K, N_Character_Literal,
- N_Real_Literal,
- N_String_Literal,
- N_Null)
+ elsif K in
+ N_Character_Literal | N_Real_Literal | N_String_Literal | N_Null
then
return True;
end if;
-- so we can safely ignore these cases.
return
- Nkind_In (Context, N_Attribute_Definition_Clause,
- N_Attribute_Reference,
- N_Modular_Type_Definition,
- N_Number_Declaration,
- N_Signed_Integer_Type_Definition);
+ Nkind (Context) in N_Attribute_Definition_Clause
+ | N_Attribute_Reference
+ | N_Modular_Type_Definition
+ | N_Number_Declaration
+ | N_Signed_Integer_Type_Definition;
end In_Any_Integer_Context;
-- Local variables
-- Check_Non_Static_Context on an expanded literal may lead to spurious
-- and misleading warnings.
- if (Nkind_In (Par, N_Case_Expression_Alternative, N_If_Expression)
+ if (Nkind (Par) in N_Case_Expression_Alternative | N_If_Expression
or else Nkind (Par) not in N_Subexpr)
- and then (not Nkind_In (Par, N_Case_Expression_Alternative,
- N_If_Expression)
+ and then (Nkind (Par) not in N_Case_Expression_Alternative
+ | N_If_Expression
or else Comes_From_Source (N))
and then not In_Any_Integer_Context (Par)
then
if Is_Array_Type (Left_Typ)
and then Left_Typ /= Any_Composite
and then Number_Dimensions (Left_Typ) = 1
- and then Nkind_In (N, N_Op_Eq, N_Op_Ne)
+ and then Nkind (N) in N_Op_Eq | N_Op_Ne
then
if Raises_Constraint_Error (Left)
or else
if Is_String_Type (Left_Typ) then
if Ada_Version < Ada_2020
and then (Comes_From_Source (N)
- or else not Nkind_In (N, N_Op_Eq, N_Op_Ne))
+ or else Nkind (N) not in N_Op_Eq | N_Op_Ne)
then
Is_Static_Expression := False;
Set_Is_Static_Expression (N, False);
function Get_String_Val (N : Node_Id) return Node_Id is
begin
- if Nkind_In (N, N_String_Literal, N_Character_Literal) then
+ if Nkind (N) in N_String_Literal | N_Character_Literal then
return N;
else
pragma Assert (Is_Entity_Name (N));
if Can_Never_Be_Null (T1) /= Can_Never_Be_Null (T2) then
return False;
- elsif Ekind_In (T1, E_Access_Subprogram_Type,
- E_Anonymous_Access_Subprogram_Type)
+ elsif Ekind (T1) in E_Access_Subprogram_Type
+ | E_Anonymous_Access_Subprogram_Type
then
return
Subtype_Conformant
-- Flag array cases
elsif Is_Array_Type (E) then
- if not Nam_In (Attribute_Name (N), Name_First,
- Name_Last,
- Name_Length)
+ if Attribute_Name (N)
+ not in Name_First | Name_Last | Name_Length
then
Error_Msg_N
("!static array attribute must be Length, First, or Last "
procedure Check_Exception_Function (E : Entity_Id; N : Node_Id) is
begin
- if not Ekind_In (E, E_Function, E_Generic_Function) then
+ if Ekind (E) not in E_Function | E_Generic_Function then
Errint
("intrinsic exception subprogram must be a function", E, N);
-- literal is legal even in Ada 83 mode, where such literals are
-- not static.
- if Nam_In (Cnam, Name_Import_Address,
- Name_Import_Largest_Value,
- Name_Import_Value)
+ if Cnam in Name_Import_Address
+ | Name_Import_Largest_Value
+ | Name_Import_Value
then
if Etype (Arg1) = Any_Type
or else Raises_Constraint_Error (Arg1)
begin
-- Arithmetic operators
- if Nam_In (Nam, Name_Op_Add, Name_Op_Subtract, Name_Op_Multiply,
- Name_Op_Divide, Name_Op_Rem, Name_Op_Mod, Name_Op_Abs)
+ if Nam in Name_Op_Add | Name_Op_Subtract | Name_Op_Multiply |
+ Name_Op_Divide | Name_Op_Rem | Name_Op_Mod |
+ Name_Op_Abs
then
T1 := Etype (First_Formal (E));
if No (Next_Formal (First_Formal (E))) then
- if Nam_In (Nam, Name_Op_Add, Name_Op_Subtract, Name_Op_Abs) then
+ if Nam in Name_Op_Add | Name_Op_Subtract | Name_Op_Abs then
T2 := T1;
-- Previous error in declaration
-- Comparison operators
- elsif Nam_In (Nam, Name_Op_Eq, Name_Op_Ge, Name_Op_Gt, Name_Op_Le,
- Name_Op_Lt, Name_Op_Ne)
+ elsif Nam in Name_Op_Eq | Name_Op_Ge | Name_Op_Gt | Name_Op_Le |
+ Name_Op_Lt | Name_Op_Ne
then
T1 := Etype (First_Formal (E));
-- Shift cases. We allow user specification of intrinsic shift operators
-- for any numeric types.
- elsif Nam_In (Nam, Name_Rotate_Left, Name_Rotate_Right, Name_Shift_Left,
- Name_Shift_Right, Name_Shift_Right_Arithmetic)
+ elsif Nam in Name_Rotate_Left | Name_Rotate_Right | Name_Shift_Left |
+ Name_Shift_Right | Name_Shift_Right_Arithmetic
then
Check_Shift (E, N);
-- Exception functions
- elsif Nam_In (Nam, Name_Exception_Information,
- Name_Exception_Message,
- Name_Exception_Name)
+ elsif Nam in Name_Exception_Information
+ | Name_Exception_Message
+ | Name_Exception_Name
then
Check_Exception_Function (E, N);
-- Source_Location and navigation functions
- elsif Nam_In (Nam, Name_File,
- Name_Line,
- Name_Source_Location,
- Name_Enclosing_Entity,
- Name_Compilation_ISO_Date,
- Name_Compilation_Date,
- Name_Compilation_Time)
+ elsif Nam in Name_File
+ | Name_Line
+ | Name_Source_Location
+ | Name_Enclosing_Entity
+ | Name_Compilation_ISO_Date
+ | Name_Compilation_Date
+ | Name_Compilation_Time
then
null;
Ptyp2 : Node_Id;
begin
- if not Ekind_In (E, E_Function, E_Generic_Function) then
+ if Ekind (E) not in E_Function | E_Generic_Function then
Errint ("intrinsic shift subprogram must be a function", E, N);
return;
end if;
-- OUT and IN OUT parameters of record types are passed
-- by reference regardless of pragmas (RM B.3 (69/2)).
- elsif Ekind_In (Formal, E_Out_Parameter,
- E_In_Out_Parameter)
+ elsif Ekind (Formal) in
+ E_Out_Parameter | E_In_Out_Parameter
then
Set_Mechanism (Formal, By_Reference);
elsif Ekind (Item_Id) = E_Constant then
Add_Str_To_Name_Buffer ("constant");
- elsif Ekind_In (Item_Id, E_Generic_In_Out_Parameter,
- E_Generic_In_Parameter)
+ elsif Ekind (Item_Id) in
+ E_Generic_In_Out_Parameter | E_Generic_In_Parameter
then
Add_Str_To_Name_Buffer ("generic parameter");
-- Constants
- if Ekind_In (Item_Id, E_Constant, E_Loop_Parameter)
+ if Ekind (Item_Id) in E_Constant | E_Loop_Parameter
or else
-- Current instances of concurrent types
- Ekind_In (Item_Id, E_Protected_Type, E_Task_Type)
+ Ekind (Item_Id) in E_Protected_Type | E_Task_Type
or else
-- Formal parameters
- Ekind_In (Item_Id, E_Generic_In_Out_Parameter,
- E_Generic_In_Parameter,
- E_In_Parameter,
- E_In_Out_Parameter,
- E_Out_Parameter)
+ Ekind (Item_Id) in E_Generic_In_Out_Parameter
+ | E_Generic_In_Parameter
+ | E_In_Parameter
+ | E_In_Out_Parameter
+ | E_Out_Parameter
or else
-- States, variables
- Ekind_In (Item_Id, E_Abstract_State, E_Variable)
+ Ekind (Item_Id) in E_Abstract_State | E_Variable
then
-- A [generic] function is not allowed to have Output
-- items in its dependency relations. Note that "null"
-- and attribute 'Result are still valid items.
- if Ekind_In (Spec_Id, E_Function, E_Generic_Function)
+ if Ekind (Spec_Id) in E_Function | E_Generic_Function
and then not Is_Input
then
SPARK_Msg_N
-- they behave as objects in the context of pragma
-- [Refined_]Depends.
- if Ekind_In (Item_Id, E_Protected_Type, E_Task_Type) then
+ if Ekind (Item_Id) in E_Protected_Type | E_Task_Type then
-- This use is legal as long as the concurrent type is
-- the current instance of an enclosing type.
Ref => Item);
end if;
- if Ekind_In (Item_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ if Ekind (Item_Id) in E_Abstract_State
+ | E_Constant
+ | E_Variable
and then Present (Encapsulating_State (Item_Id))
then
Append_New_Elmt (Item_Id, Constits_Seen);
procedure Check_Function_Return is
begin
- if Ekind_In (Spec_Id, E_Function, E_Generic_Function)
+ if Ekind (Spec_Id) in E_Function | E_Generic_Function
and then not Result_Seen
then
SPARK_Msg_NE
Adjusted_Kind : Entity_Kind := Ekind (Item_Id);
begin
- if Ekind_In (Item_Id, E_Constant,
- E_Generic_In_Parameter,
- E_In_Parameter)
+ if Ekind (Item_Id) in E_Constant
+ | E_Generic_In_Parameter
+ | E_In_Parameter
and then Is_Access_Type (Etype (Item_Id))
then
Adjusted_Kind := E_Variable;
-- the current instance of an enclosing protected or task type
-- (SPARK RM 6.1.4).
- elsif Ekind_In (Item_Id, E_Protected_Type, E_Task_Type) then
+ elsif Ekind (Item_Id) in E_Protected_Type | E_Task_Type then
if Is_CCT_Instance (Item_Id, Spec_Id) then
-- Pragma [Refined_]Global associated with a protected
-- The only legal references are those to abstract states,
-- objects and various kinds of constants (SPARK RM 6.1.4(4)).
- elsif not Ekind_In (Item_Id, E_Abstract_State,
- E_Constant,
- E_Loop_Parameter,
- E_Variable)
+ elsif Ekind (Item_Id) not in E_Abstract_State
+ | E_Constant
+ | E_Loop_Parameter
+ | E_Variable
then
SPARK_Msg_N
("global item must denote object, state or current "
-- nonvolatile function (SPARK RM 7.1.3(8)).
elsif Is_External_State (Item_Id)
- and then Ekind_In (Spec_Id, E_Function, E_Generic_Function)
+ and then Ekind (Spec_Id) in E_Function | E_Generic_Function
and then not Is_Volatile_Function (Spec_Id)
then
SPARK_Msg_NE
-- Unless it is of an access type, a constant is a read-only
-- item, therefore it cannot act as an output.
- if Nam_In (Global_Mode, Name_In_Out, Name_Output) then
+ if Global_Mode in Name_In_Out | Name_Output then
SPARK_Msg_NE
("constant & cannot act as output", Item, Item_Id);
return;
-- A loop parameter is a read-only item, therefore it cannot
-- act as an output.
- if Nam_In (Global_Mode, Name_In_Out, Name_Output) then
+ if Global_Mode in Name_In_Out | Name_Output then
SPARK_Msg_NE
("loop parameter & cannot act as output",
Item, Item_Id);
-- An effectively volatile object cannot appear as a global
-- item of a nonvolatile function (SPARK RM 7.1.3(8)).
- if Ekind_In (Spec_Id, E_Function, E_Generic_Function)
+ if Ekind (Spec_Id) in E_Function | E_Generic_Function
and then not Is_Volatile_Function (Spec_Id)
then
Error_Msg_NE
-- Verify that an output does not appear as an input in an
-- enclosing subprogram.
- if Nam_In (Global_Mode, Name_In_Out, Name_Output) then
+ if Global_Mode in Name_In_Out | Name_Output then
Check_Mode_Restriction_In_Enclosing_Context (Item, Item_Id);
end if;
Ref => Item);
end if;
- if Ekind_In (Item_Id, E_Abstract_State, E_Constant, E_Variable)
+ if Ekind (Item_Id) in E_Abstract_State | E_Constant | E_Variable
and then Present (Encapsulating_State (Item_Id))
then
Append_New_Elmt (Item_Id, Constits_Seen);
procedure Check_Mode_Restriction_In_Function (Mode : Node_Id) is
begin
- if Ekind_In (Spec_Id, E_Function, E_Generic_Function) then
+ if Ekind (Spec_Id) in E_Function | E_Generic_Function then
SPARK_Msg_N
("global mode & is not applicable to functions", Mode);
end if;
-- Single global item declaration
- elsif Nkind_In (List, N_Expanded_Name,
- N_Identifier,
- N_Selected_Component)
+ elsif Nkind (List) in N_Expanded_Name
+ | N_Identifier
+ | N_Selected_Component
then
Analyze_Global_Item (List, Global_Mode);
Item_Id := Entity_Of (Item);
if Present (Item_Id)
- and then Ekind_In (Item_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ and then Ekind (Item_Id) in
+ E_Abstract_State | E_Constant | E_Variable
then
-- When the initialization item is undefined, it appears as
-- Any_Id. Do not continue with the analysis of the item.
Input_Id := Entity_Of (Input);
if Present (Input_Id)
- and then Ekind_In (Input_Id, E_Abstract_State,
- E_Constant,
- E_Generic_In_Out_Parameter,
- E_Generic_In_Parameter,
- E_In_Parameter,
- E_In_Out_Parameter,
- E_Out_Parameter,
- E_Protected_Type,
- E_Task_Type,
- E_Variable)
+ and then Ekind (Input_Id) in E_Abstract_State
+ | E_Constant
+ | E_Generic_In_Out_Parameter
+ | E_Generic_In_Parameter
+ | E_In_Parameter
+ | E_In_Out_Parameter
+ | E_Out_Parameter
+ | E_Protected_Type
+ | E_Task_Type
+ | E_Variable
then
-- The input cannot denote states or objects declared
-- within the related package (SPARK RM 7.1.5(4)).
-- it is allowed for an initialization item to depend
-- on an input item.
- if Ekind_In (Input_Id, E_Generic_In_Out_Parameter,
- E_Generic_In_Parameter)
+ if Ekind (Input_Id) in E_Generic_In_Out_Parameter
+ | E_Generic_In_Parameter
then
null;
- elsif Ekind_In (Input_Id, E_Constant, E_Variable)
+ elsif Ekind (Input_Id) in E_Constant | E_Variable
and then Present (Corresponding_Generic_Association
(Declaration_Node (Input_Id)))
then
Append_New_Elmt (Input_Id, States_Seen);
end if;
- if Ekind_In (Input_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ if Ekind (Input_Id) in E_Abstract_State
+ | E_Constant
+ | E_Variable
and then Present (Encapsulating_State (Input_Id))
then
Append_New_Elmt (Input_Id, Constits_Seen);
Decl := First (Visible_Declarations (Pack_Spec));
while Present (Decl) loop
if Comes_From_Source (Decl)
- and then Nkind_In (Decl, N_Object_Declaration,
- N_Object_Renaming_Declaration)
+ and then Nkind (Decl) in N_Object_Declaration
+ | N_Object_Renaming_Declaration
then
Append_New_Elmt (Defining_Entity (Decl), States_And_Objs);
-- Only abstract states and variables can act as constituents of an
-- encapsulating single concurrent type.
- if Ekind_In (Item_Id, E_Abstract_State, E_Variable) then
+ if Ekind (Item_Id) in E_Abstract_State | E_Variable then
null;
-- The constituent is a constant
-- the single concurrent type (SPARK RM 9(3)).
if Item_Context = Encap_Context then
- if Nkind_In (Item_Context, N_Package_Specification,
- N_Protected_Definition,
- N_Task_Definition)
+ if Nkind (Item_Context) in N_Package_Specification
+ | N_Protected_Definition
+ | N_Task_Definition
then
Prv_Decls := Private_Declarations (Item_Context);
Vis_Decls := Visible_Declarations (Item_Context);
Encap_Id := Empty;
Legal := False;
- if Nkind_In (Encap, N_Expanded_Name,
- N_Identifier,
- N_Selected_Component)
+ if Nkind (Encap) in
+ N_Expanded_Name | N_Identifier | N_Selected_Component
then
Analyze (Encap);
Resolve_State (Encap);
-- original pragma name by routine Original_Aspect_Pragma_Name.
if Comes_From_Source (N) then
- if Nam_In (Pname, Name_Pre, Name_Pre_Class) then
+ if Pname in Name_Pre | Name_Pre_Class then
Is_Pre_Post := True;
Set_Class_Present (N, Pname = Name_Pre_Class);
Rewrite (Prag_Iden, Make_Identifier (Loc, Name_Precondition));
- elsif Nam_In (Pname, Name_Post, Name_Post_Class) then
+ elsif Pname in Name_Post | Name_Post_Class then
Is_Pre_Post := True;
Set_Class_Present (N, Pname = Name_Post_Class);
Rewrite (Prag_Iden, Make_Identifier (Loc, Name_Postcondition));
-- in a body. Pragmas Precondition and Postcondition were introduced
-- before aspects and are not subject to the same aspect-like rules.
- if Nam_In (Pname, Name_Precondition, Name_Postcondition) then
+ if Pname in Name_Precondition | Name_Postcondition then
Duplicates_OK := True;
In_Body_OK := True;
end if;
-- Fully analyze the pragma when it appears inside an entry or
-- subprogram body because it cannot benefit from forward references.
- if Nkind_In (Subp_Decl, N_Entry_Body,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub)
+ if Nkind (Subp_Decl) in N_Entry_Body
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
then
-- The legality checks of pragmas Precondition and Postcondition
-- are affected by the SPARK mode in effect and the volatility of
Body_Decl := Find_Related_Declaration_Or_Body (N, Do_Checks => True);
- if not Nkind_In (Body_Decl, N_Entry_Body,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub,
- N_Task_Body,
- N_Task_Body_Stub)
+ if Nkind (Body_Decl) not in
+ N_Entry_Body | N_Subprogram_Body | N_Subprogram_Body_Stub |
+ N_Task_Body | N_Task_Body_Stub
then
Pragma_Misplaced;
return;
-- When dealing with protected entries or protected subprograms, use
-- the enclosing protected type as the proper context.
- if Ekind_In (Spec_Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure)
+ if Ekind (Spec_Id) in E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Procedure
and then Ekind (Scope (Spec_Id)) = E_Protected_Type
then
Spec_Decl := Declaration_Node (Scope (Spec_Id));
Mark_Ghost_Pragma (N, Spec_Id);
- if Nam_In (Pname, Name_Refined_Depends, Name_Refined_Global) then
+ if Pname in Name_Refined_Depends | Name_Refined_Global then
Ensure_Aggregate_Form (Get_Argument (N, Spec_Id));
end if;
end Analyze_Refined_Depends_Global_Post;
begin
Check_Arg_Is_Identifier (Argx);
- if not Nam_In (Chars (Argx), N1, N2) then
+ if Chars (Argx) not in N1 | N2 then
Error_Msg_Name_2 := N1;
Error_Msg_Name_3 := N2;
Error_Pragma_Arg ("argument for pragma% must be% or%", Argx);
begin
Check_Arg_Is_Identifier (Argx);
- if not Nam_In (Chars (Argx), N1, N2, N3) then
+ if Chars (Argx) not in N1 | N2 | N3 then
Error_Pragma_Arg ("invalid argument for pragma%", Argx);
end if;
end Check_Arg_Is_One_Of;
begin
Check_Arg_Is_Identifier (Argx);
- if not Nam_In (Chars (Argx), N1, N2, N3, N4) then
+ if Chars (Argx) not in N1 | N2 | N3 | N4 then
Error_Pragma_Arg ("invalid argument for pragma%", Argx);
end if;
end Check_Arg_Is_One_Of;
begin
Check_Arg_Is_Identifier (Argx);
- if not Nam_In (Chars (Argx), N1, N2, N3, N4, N5) then
+ if Chars (Argx) not in N1 | N2 | N3 | N4 | N5 then
Error_Pragma_Arg ("invalid argument for pragma%", Argx);
end if;
end Check_Arg_Is_One_Of;
-- For a single protected or a single task object, the error is
-- issued on the original entity.
- if Ekind_In (Id, E_Task_Type, E_Protected_Type) then
+ if Ekind (Id) in E_Task_Type | E_Protected_Type then
Id := Defining_Identifier (Original_Node (Parent (Id)));
end if;
-- [No_]Inline which is suspicious but not an error, generate
-- an error for other pragmas.
- if Nam_In (Pragma_Name (N), Name_Inline, Name_No_Inline) then
+ if Pragma_Name (N) in Name_Inline | Name_No_Inline then
if Warn_On_Redundant_Constructs then
Error_Msg_NE
("?r?pragma% for & duplicates pragma#", N, Id);
if Nkind (Original_Node (Stmt)) = N_Pragma then
return
- Nam_In (Pragma_Name_Unmapped (Original_Node (Stmt)),
- Name_Loop_Invariant,
- Name_Loop_Variant);
+ Pragma_Name_Unmapped (Original_Node (Stmt))
+ in Name_Loop_Invariant | Name_Loop_Variant;
else
return False;
end if;
elsif Nkind (P) = N_Handled_Sequence_Of_Statements then
exit;
- elsif Nkind_In (P, N_Package_Specification,
- N_Block_Statement)
- then
+ elsif Nkind (P) in N_Package_Specification | N_Block_Statement then
return;
-- Note: the following tests seem a little peculiar, because
-- sequence, so the only way we get here is by being in the
-- declarative part of the body.
- elsif Nkind_In (P, N_Subprogram_Body,
- N_Package_Body,
- N_Task_Body,
- N_Entry_Body)
+ elsif Nkind (P) in
+ N_Subprogram_Body | N_Package_Body | N_Task_Body | N_Entry_Body
then
return;
end if;
if Nkind (P) = N_Compilation_Unit then
Unit_Kind := Nkind (Unit (P));
- if Nkind_In (Unit_Kind, N_Subprogram_Declaration,
- N_Package_Declaration)
- or else Unit_Kind in N_Generic_Declaration
+ if Unit_Kind in N_Subprogram_Declaration
+ | N_Package_Declaration
+ | N_Generic_Declaration
then
Unit_Name := Defining_Entity (Unit (P));
if SPARK_Mode = On
and then Prag_Id = Pragma_Volatile
- and then not Nkind_In (Original_Node (Decl),
- N_Full_Type_Declaration,
- N_Formal_Type_Declaration,
- N_Object_Declaration,
- N_Single_Protected_Declaration,
- N_Single_Task_Declaration)
+ and then Nkind (Original_Node (Decl)) not in
+ N_Full_Type_Declaration |
+ N_Formal_Type_Declaration |
+ N_Object_Declaration |
+ N_Single_Protected_Declaration |
+ N_Single_Task_Declaration
then
Error_Pragma_Arg
("argument of pragma % must denote a full type or object "
else
while Present (P) and then Nkind (P) not in N_Generic_Declaration
loop
- if Nkind_In (P, N_Package_Body, N_Subprogram_Body) then
+ if Nkind (P) in N_Package_Body | N_Subprogram_Body then
P := Corresponding_Spec (P);
else
P := Parent (P);
then
-- Give error if same as our pragma or Export/Convention
- if Nam_In (Pragma_Name_Unmapped (Decl),
- Name_Export,
- Name_Convention,
- Pragma_Name_Unmapped (N))
+ if Pragma_Name_Unmapped (Decl)
+ in Name_Export
+ | Name_Convention
+ | Pragma_Name_Unmapped (N)
then
exit;
-- Case of Import/Interface or the other way round
- elsif Nam_In (Pragma_Name_Unmapped (Decl),
- Name_Interface, Name_Import)
+ elsif Pragma_Name_Unmapped (Decl)
+ in Name_Interface | Name_Import
then
-- Here we know that we have Import and Interface. It
-- doesn't matter which way round they are. See if
while Present (Comp) loop
if Present (Etype (Comp))
and then
- Ekind_In (Etype (Comp),
- E_Anonymous_Access_Type,
- E_Anonymous_Access_Subprogram_Type)
+ Ekind (Etype (Comp)) in
+ E_Anonymous_Access_Type |
+ E_Anonymous_Access_Subprogram_Type
and then not Has_Convention_Pragma (Comp)
then
Set_Convention (Comp, C);
end;
elsif Is_Array_Type (E)
- and then Ekind_In (Component_Type (E),
- E_Anonymous_Access_Type,
- E_Anonymous_Access_Subprogram_Type)
+ and then Ekind (Component_Type (E)) in
+ E_Anonymous_Access_Type |
+ E_Anonymous_Access_Subprogram_Type
then
Set_Convention (Designated_Type (Component_Type (E)), C);
end if;
E := Alias (E);
- elsif Nkind_In (Parent (E), N_Full_Type_Declaration,
- N_Private_Extension_Declaration)
+ elsif Nkind (Parent (E)) in
+ N_Full_Type_Declaration | N_Private_Extension_Declaration
and then Scope (E) = Scope (Alias (E))
then
E := Alias (E);
-- Check that we are not applying this to a named constant
- if Ekind_In (E, E_Named_Integer, E_Named_Real) then
+ if Ekind (E) in E_Named_Integer | E_Named_Real then
Error_Msg_Name_1 := Pname;
Error_Msg_N
("cannot apply pragma% to named constant!",
Process_Extended_Import_Export_Internal_Arg (Arg_Internal);
Def_Id := Entity (Arg_Internal);
- if not Ekind_In (Def_Id, E_Constant, E_Variable) then
+ if Ekind (Def_Id) not in E_Constant | E_Variable then
Error_Pragma_Arg
("pragma% must designate an object", Arg_Internal);
end if;
Match := False;
elsif Etype (Def_Id) /= Standard_Void_Type
- and then Nam_In (Pname, Name_Export_Procedure,
- Name_Import_Procedure)
+ and then
+ Pname in Name_Export_Procedure | Name_Import_Procedure
then
Match := False;
-- Various error checks
- if Ekind_In (Def_Id, E_Variable, E_Constant) then
+ if Ekind (Def_Id) in E_Variable | E_Constant then
-- We do not permit Import to apply to a renaming declaration
-- pragma Inline_Always (Proc);
-- end Pack;
- elsif Nkind_In (Context, N_Package_Specification,
- N_Protected_Definition,
- N_Task_Definition)
+ elsif Nkind (Context) in N_Package_Specification
+ | N_Protected_Definition
+ | N_Task_Definition
and then Init_List = Visible_Declarations (Context)
and then Prag_List = Private_Declarations (Context)
then
-- external properties.
elsif Nkind (Prop) = N_Identifier
- and then Nam_In (Chars (Prop), Name_Async_Readers,
- Name_Async_Writers,
- Name_Effective_Reads,
- Name_Effective_Writes)
+ and then Chars (Prop) in Name_Async_Readers
+ | Name_Async_Writers
+ | Name_Effective_Reads
+ | Name_Effective_Writes
then
null;
Pack_Decl := Find_Related_Package_Or_Body (N, Do_Checks => True);
- if not Nkind_In (Pack_Decl, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (Pack_Decl) not in
+ N_Generic_Package_Declaration | N_Package_Declaration
then
Pragma_Misplaced;
return;
-- The Ghost policy must be either Check or Ignore
-- (SPARK RM 6.9(6)).
- if not Nam_In (Chars (Policy), Name_Check,
- Name_Ignore)
- then
+ if Chars (Policy) not in Name_Check | Name_Ignore then
Error_Pragma_Arg
("argument of pragma % Ghost must be Check or "
& "Ignore", Policy);
if Nkind (Obj_Or_Type_Decl) /= N_Object_Declaration then
if Prag_Id = Pragma_No_Caching
- or not Nkind_In (Original_Node (Obj_Or_Type_Decl),
- N_Full_Type_Declaration,
- N_Private_Type_Declaration,
- N_Formal_Type_Declaration,
- N_Task_Type_Declaration,
- N_Protected_Type_Declaration)
+ or else Nkind (Original_Node (Obj_Or_Type_Decl)) not in
+ N_Full_Type_Declaration |
+ N_Private_Type_Declaration |
+ N_Formal_Type_Declaration |
+ N_Task_Type_Declaration |
+ N_Protected_Type_Declaration
then
Pragma_Misplaced;
return;
if (Nkind (D) = N_Full_Type_Declaration and then Is_Array_Type (E))
or else
(Nkind (D) = N_Object_Declaration
- and then Ekind_In (E, E_Constant, E_Variable)
+ and then Ekind (E) in E_Constant | E_Variable
and then Nkind (Object_Definition (D)) =
N_Constrained_Array_Definition)
or else
-- identifier is Name.
if Nkind (Arg1) /= N_Pragma_Argument_Association
- or else Nam_In (Chars (Arg1), No_Name, Name_Name)
+ or else Chars (Arg1) in No_Name | Name_Name
then
-- Old syntax
-- Check forbidden check kind
- if Nam_In (Chars (Kind), Name_Name, Name_Policy) then
+ if Chars (Kind) in Name_Name | Name_Policy then
Error_Msg_Name_2 := Chars (Kind);
Error_Pragma_Arg
("pragma% does not allow% as check name", Arg1);
-- or subprogram body because it cannot benefit from forward
-- references.
- if Nkind_In (Subp_Decl, N_Entry_Body,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub)
+ if Nkind (Subp_Decl) in N_Entry_Body
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
then
-- The legality checks of pragma Contract_Cases are affected by
-- the SPARK mode in effect and the volatility of the context.
Call := Get_Pragma_Arg (Arg1);
end if;
- if Nkind_In (Call, N_Expanded_Name,
- N_Function_Call,
- N_Identifier,
- N_Indexed_Component,
- N_Selected_Component)
+ if Nkind (Call) in N_Expanded_Name
+ | N_Function_Call
+ | N_Identifier
+ | N_Indexed_Component
+ | N_Selected_Component
then
-- If this pragma Debug comes from source, its argument was
-- parsed as a name form (which is syntactically identical).
-- The associated private type [extension] has been found, stop
-- the search.
- elsif Nkind_In (Stmt, N_Private_Extension_Declaration,
- N_Private_Type_Declaration)
+ elsif Nkind (Stmt) in N_Private_Extension_Declaration
+ | N_Private_Type_Declaration
then
Typ := Defining_Entity (Stmt);
exit;
-- or subprogram body because it cannot benefit from forward
-- references.
- if Nkind_In (Subp_Decl, N_Entry_Body,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub)
+ if Nkind (Subp_Decl) in N_Entry_Body
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
then
-- The legality checks of pragmas Depends and Global are
-- affected by the SPARK mode in effect and the volatility
Mark_Ghost_Pragma (N, Cunit_Ent);
- if Nkind_In (Unit (Cunit_Node), N_Package_Body,
- N_Subprogram_Body)
+ if Nkind (Unit (Cunit_Node)) in
+ N_Package_Body | N_Subprogram_Body
then
Error_Pragma ("pragma% must refer to a spec, not a body");
else
-- Task unit declared without a definition cannot be subject to
-- pragma Ghost (SPARK RM 6.9(19)).
- elsif Nkind_In (Stmt, N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ elsif Nkind (Stmt) in
+ N_Single_Task_Declaration | N_Task_Type_Declaration
then
Error_Pragma ("pragma % cannot apply to a task type");
return;
-- When pragma Ghost applies to an untagged derivation, the
-- derivation is transformed into a [sub]type declaration.
- if Nkind_In (Stmt, N_Full_Type_Declaration,
- N_Subtype_Declaration)
+ if Nkind (Stmt) in
+ N_Full_Type_Declaration | N_Subtype_Declaration
and then Comes_From_Source (Orig_Stmt)
and then Nkind (Orig_Stmt) = N_Full_Type_Declaration
and then Nkind (Type_Definition (Orig_Stmt)) =
-- The pragma applies to a legal construct, stop the traversal
- elsif Nkind_In (Stmt, N_Abstract_Subprogram_Declaration,
- N_Full_Type_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Object_Declaration,
- N_Private_Extension_Declaration,
- N_Private_Type_Declaration,
- N_Subprogram_Declaration,
- N_Subtype_Declaration)
+ elsif Nkind (Stmt) in N_Abstract_Subprogram_Declaration
+ | N_Full_Type_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Object_Declaration
+ | N_Private_Extension_Declaration
+ | N_Private_Type_Declaration
+ | N_Subprogram_Declaration
+ | N_Subtype_Declaration
then
Id := Defining_Entity (Stmt);
exit;
-- Protected and task types cannot be subject to pragma Ghost
-- (SPARK RM 6.9(19)).
- if Nkind_In (Context, N_Protected_Body, N_Protected_Definition)
+ if Nkind (Context) in N_Protected_Body | N_Protected_Definition
then
Error_Pragma ("pragma % cannot apply to a protected type");
return;
- elsif Nkind_In (Context, N_Task_Body, N_Task_Definition) then
+ elsif Nkind (Context) in N_Task_Body | N_Task_Definition then
Error_Pragma ("pragma % cannot apply to a task type");
return;
end if;
-- or subprogram body because it cannot benefit from forward
-- references.
- if Nkind_In (Subp_Decl, N_Entry_Body,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub)
+ if Nkind (Subp_Decl) in N_Entry_Body
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
then
-- The legality checks of pragmas Depends and Global are
-- affected by the SPARK mode in effect and the volatility
begin
GP := Parent (Parent (N));
- if Nkind_In (GP, N_Package_Declaration,
- N_Generic_Package_Declaration)
+ if Nkind (GP) in
+ N_Package_Declaration | N_Generic_Package_Declaration
then
GP := Parent (GP);
end if;
-- "synchronized".
or else
- (Ekind_In (Typ, E_Record_Type_With_Private,
- E_Record_Subtype_With_Private)
+ (Ekind (Typ) in E_Record_Type_With_Private
+ | E_Record_Subtype_With_Private
and then Synchronized_Present (Parent (Typ))))
then
null;
Pack_Decl := Find_Related_Package_Or_Body (N, Do_Checks => True);
- if not Nkind_In (Pack_Decl, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (Pack_Decl) not in
+ N_Generic_Package_Declaration | N_Package_Declaration
then
Pragma_Misplaced;
return;
Pack_Decl := Find_Related_Package_Or_Body (N, Do_Checks => True);
- if not Nkind_In (Pack_Decl, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (Pack_Decl) not in
+ N_Generic_Package_Declaration | N_Package_Declaration
then
Pragma_Misplaced;
return;
Preanalyze_Spec_Expression (Arg, RTE (RE_Interrupt_Priority));
end if;
- if not Nkind_In (P, N_Task_Definition, N_Protected_Definition) then
+ if Nkind (P) not in N_Task_Definition | N_Protected_Definition then
Pragma_Misplaced;
return;
-- A [class-wide] invariant may be associated a [limited] private
-- type or a private extension.
- elsif Ekind_In (Typ, E_Limited_Private_Type,
- E_Private_Type,
- E_Record_Type_With_Private)
+ elsif Ekind (Typ) in E_Limited_Private_Type
+ | E_Private_Type
+ | E_Record_Type_With_Private
then
null;
if Chars (Variant) = No_Name then
Error_Pragma_Arg_Ident ("expect name `Increases`", Variant);
- elsif not Nam_In (Chars (Variant), Name_Decreases,
- Name_Increases)
+ elsif Chars (Variant) not in Name_Decreases | Name_Increases
then
declare
Name : String := Get_Name_String (Chars (Variant));
-- Must appear for a spec or generic spec
- if not Nkind_In (Unit (Cunit (Current_Sem_Unit)),
- N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Declaration,
- N_Subprogram_Declaration)
+ if Nkind (Unit (Cunit (Current_Sem_Unit))) not in
+ N_Generic_Package_Declaration |
+ N_Generic_Subprogram_Declaration |
+ N_Package_Declaration |
+ N_Subprogram_Declaration
then
Error_Pragma
(Fix_Error
-- The pragma must apply to an access-to-object type
- if Ekind_In (Typ, E_Access_Type, E_General_Access_Type) then
+ if Ekind (Typ) in E_Access_Type | E_General_Access_Type then
null;
-- Give a detailed error message on all other access type kinds
loop
-- Ada 2020 (AI12-0269): A function can be No_Return
- if Ekind_In (E, E_Generic_Procedure, E_Procedure)
+ if Ekind (E) in E_Generic_Procedure | E_Procedure
or else (Ada_Version >= Ada_2020
and then
- Ekind_In (E, E_Generic_Function, E_Function))
+ Ekind (E) in E_Generic_Function | E_Function)
then
-- Check that the pragma is not applied to a body.
-- First check the specless body case, to give a
and then
(Chars (Arg1) = Name_Entity
or else
- Nkind_In (Get_Pragma_Arg (Arg1), N_Character_Literal,
- N_Identifier,
- N_Operator_Symbol))
+ Nkind (Get_Pragma_Arg (Arg1)) in
+ N_Character_Literal | N_Identifier | N_Operator_Symbol)
then
Ename := Get_Pragma_Arg (Arg1);
-- they may not depend on variable input. This check is
-- left to the SPARK prover.
- elsif Ekind_In (Item_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ elsif Ekind (Item_Id) in
+ E_Abstract_State | E_Constant | E_Variable
then
Has_Item := True;
Constits := Part_Of_Constituents (State_Id);
Check_Arg_Is_Library_Level_Local_Name (Arg1);
if not Is_Entity_Name (Get_Pragma_Arg (Arg1))
- or else not
- Ekind_In (Entity (Get_Pragma_Arg (Arg1)), E_Variable,
- E_Constant)
+ or else
+ Ekind (Entity (Get_Pragma_Arg (Arg1))) not in
+ E_Variable | E_Constant
then
Error_Pragma_Arg ("pragma% only applies to objects", Arg1);
end if;
-- Task or Protected, must be of type Integer
- elsif Nkind_In (P, N_Protected_Definition, N_Task_Definition) then
+ elsif Nkind (P) in N_Protected_Definition | N_Task_Definition then
Arg := Get_Pragma_Arg (Arg1);
Ent := Defining_Identifier (Parent (P));
procedure Check_Arg (Arg : Node_Id) is
begin
- if not Nkind_In (Original_Node (Arg),
- N_String_Literal,
- N_Identifier)
+ if Nkind (Original_Node (Arg)) not in
+ N_String_Literal | N_Identifier
then
Error_Pragma_Arg
("inappropriate argument for pragma %", Arg);
Def_Id := Entity (Internal);
- if not Ekind_In (Def_Id, E_Constant, E_Variable) then
+ if Ekind (Def_Id) not in E_Constant | E_Variable then
Error_Pragma_Arg
("pragma% must designate an object", Internal);
end if;
loop
Def_Id := Get_Base_Subprogram (E);
- if not Ekind_In (Def_Id, E_Function,
- E_Generic_Function,
- E_Operator)
+ if Ekind (Def_Id) not in
+ E_Function | E_Generic_Function | E_Operator
then
Error_Pragma_Arg
("pragma% requires a function name", Arg1);
Mark_Ghost_Pragma (N, Cunit_Ent);
- if not Nkind_In (Unit (Cunit_Node), N_Package_Declaration,
- N_Generic_Package_Declaration)
+ if Nkind (Unit (Cunit_Node)) not in
+ N_Package_Declaration | N_Generic_Package_Declaration
then
Error_Pragma
("pragma% can only apply to a package declaration");
Mark_Ghost_Pragma (N, Cunit_Ent);
- if not Nkind_In (Unit (Cunit_Node), N_Package_Declaration,
- N_Generic_Package_Declaration)
+ if Nkind (Unit (Cunit_Node)) not in
+ N_Package_Declaration | N_Generic_Package_Declaration
then
Error_Pragma
("pragma% can only apply to a package declaration");
-- anonymous type whose name cannot be used to issue error
-- messages. Recover the original entity of the type.
- if Ekind_In (Entity, E_Protected_Type, E_Task_Type) then
+ if Ekind (Entity) in E_Protected_Type | E_Task_Type then
Err_Id :=
Defining_Entity
(Original_Node (Unit_Declaration_Node (Entity)));
procedure Add_Entity_To_Name_Buffer is
begin
- if Ekind_In (E, E_Entry, E_Entry_Family) then
+ if Ekind (E) in E_Entry | E_Entry_Family then
Add_Str_To_Name_Buffer ("entry");
- elsif Ekind_In (E, E_Generic_Package,
- E_Package,
- E_Package_Body)
+ elsif Ekind (E) in E_Generic_Package
+ | E_Package
+ | E_Package_Body
then
Add_Str_To_Name_Buffer ("package");
- elsif Ekind_In (E, E_Protected_Body, E_Protected_Type) then
+ elsif Ekind (E) in E_Protected_Body | E_Protected_Type then
Add_Str_To_Name_Buffer ("protected type");
- elsif Ekind_In (E, E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Procedure,
- E_Subprogram_Body)
+ elsif Ekind (E) in E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Procedure
+ | E_Subprogram_Body
then
Add_Str_To_Name_Buffer ("subprogram");
else
- pragma Assert (Ekind_In (E, E_Task_Body, E_Task_Type));
+ pragma Assert (Ekind (E) in E_Task_Body | E_Task_Type);
Add_Str_To_Name_Buffer ("task type");
end if;
end Add_Entity_To_Name_Buffer;
-- * The mode of the context
-- * The mode of the spec (if any)
- if Nkind_In (Decl, N_Entry_Body, N_Subprogram_Body) then
+ if Nkind (Decl) in N_Entry_Body | N_Subprogram_Body then
-- A stand-alone subprogram body
else
pragma Assert
- (Nkind_In (Decl, N_Protected_Body, N_Task_Body));
+ (Nkind (Decl) in N_Protected_Body | N_Task_Body);
Check_Pragma_Conformance
(Context_Pragma => SPARK_Pragma (Body_Id),
-- SPARK_Mode of the context because the task does not have any
-- entries that could inherit the mode.
- if not Nkind_In (Decl, N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ if Nkind (Decl) not in
+ N_Single_Task_Declaration | N_Task_Type_Declaration
then
Set_SPARK_Context;
end if;
-- procedure Proc ...;
-- pragma SPARK_Mode ...;
- elsif Nkind_In (Stmt, N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration)
+ elsif Nkind (Stmt) in N_Generic_Subprogram_Declaration
+ | N_Subprogram_Declaration
or else (Nkind (Stmt) = N_Entry_Declaration
and then Is_Protected_Type
(Scope (Defining_Entity (Stmt))))
-- protected body Prot is
-- pragma SPARK_Mode ...;
- if Nkind_In (Context, N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (Context) in N_Entry_Body
+ | N_Package_Body
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
Process_Body (Context);
-- private
-- pragma SPARK_Mode ...;
- elsif Nkind_In (Context, N_Package_Specification,
- N_Protected_Definition,
- N_Task_Definition)
+ elsif Nkind (Context) in N_Package_Specification
+ | N_Protected_Definition
+ | N_Task_Definition
then
if List_Containing (N) = Visible_Declarations (Context) then
Process_Visible_Part (Parent (Context));
-- procedure Proc ...;
-- pragma SPARK_Mode ...;
- elsif Nkind_In (Context, N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration)
+ elsif Nkind (Context) in N_Generic_Subprogram_Declaration
+ | N_Subprogram_Declaration
then
Process_Overloadable (Context);
-- in a library-level package. First determine whether the current
-- compilation unit is a legal context.
- if Nkind_In (Pack_Decl, N_Package_Declaration,
- N_Generic_Package_Declaration)
+ if Nkind (Pack_Decl) in N_Package_Declaration
+ | N_Generic_Package_Declaration
then
null;
-- The context is a [generic] subprogram declared at the top level
-- of the [generic] package unit.
- elsif Nkind_In (Subp_Decl, N_Generic_Subprogram_Declaration,
- N_Subprogram_Declaration)
+ elsif Nkind (Subp_Decl) in N_Generic_Subprogram_Declaration
+ | N_Subprogram_Declaration
and then Present (Context)
- and then Nkind_In (Context, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ and then Nkind (Context) in N_Generic_Package_Declaration
+ | N_Package_Declaration
then
null;
-- or subprogram body because it cannot benefit from forward
-- references.
- if Nkind_In (Subp_Decl, N_Entry_Body,
- N_Subprogram_Body,
- N_Subprogram_Body_Stub)
+ if Nkind (Subp_Decl) in N_Entry_Body
+ | N_Subprogram_Body
+ | N_Subprogram_Body_Stub
then
-- The legality checks of pragma Test_Case are affected by the
-- SPARK mode in effect and the volatility of the context.
Spec_Id := Unique_Defining_Entity (Subp_Decl);
- if not Ekind_In (Spec_Id, E_Function, E_Generic_Function) then
+ if Ekind (Spec_Id) not in E_Function | E_Generic_Function then
Pragma_Misplaced;
return;
end if;
-- was given otherwise, by shifting the arguments.
if Nkind (Argx) = N_Identifier
- and then Nam_In (Chars (Argx), Name_Gnat, Name_Gnatprove)
+ and then Chars (Argx) in Name_Gnat | Name_Gnatprove
then
if Chars (Argx) = Name_Gnat then
if CodePeer_Mode or GNATprove_Mode then
-- On/Off one argument case was processed by parser
if Nkind (Argx) = N_Identifier
- and then Nam_In (Chars (Argx), Name_On, Name_Off)
+ and then Chars (Argx) in Name_On | Name_Off
then
null;
and then
(Etype (Nod) = Disp_Typ
or else Etype (Nod) = Class_Wide_Type (Disp_Typ))
- and then Ekind_In (Entity (Nod), E_Constant, E_Variable)
+ and then Ekind (Entity (Nod)) in E_Constant | E_Variable
then
Error_Msg_NE
("object in class-wide condition must be formal of type &",
if Is_Entity_Name (Ref_Item) then
Ref_Item_Id := Entity_Of (Ref_Item);
- if Ekind_In (Ref_Item_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ if Ekind (Ref_Item_Id) in
+ E_Abstract_State | E_Constant | E_Variable
and then Present (Encapsulating_State (Ref_Item_Id))
and then Find_Encapsulating_State
(Dep_States, Ref_Item_Id) = Dep_Item_Id
-- The input must be a constituent of a state
- if Ekind_In (Input_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ if Ekind (Input_Id) in
+ E_Abstract_State | E_Constant | E_Variable
and then Present (Encapsulating_State (Input_Id))
then
State_Id := Encapsulating_State (Input_Id);
-- Start of processing for Check_Refined_Global_Item
begin
- if Ekind_In (Item_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ if Ekind (Item_Id) in E_Abstract_State | E_Constant | E_Variable
then
Enc_State := Find_Encapsulating_State (States, Item_Id);
end if;
-- Single global item declaration
- elsif Nkind_In (List, N_Expanded_Name,
- N_Identifier,
- N_Selected_Component)
+ elsif Nkind (List) in N_Expanded_Name
+ | N_Identifier
+ | N_Selected_Component
then
Check_Refined_Global_Item (List, Global_Mode);
-- Single global item declaration
- elsif Nkind_In (List, N_Expanded_Name,
- N_Identifier,
- N_Selected_Component)
+ elsif Nkind (List) in N_Expanded_Name
+ | N_Identifier
+ | N_Selected_Component
then
Collect_Global_Item (List, Mode);
-- The constituent is a valid state or object
- elsif Ekind_In (Constit_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ elsif Ekind (Constit_Id) in
+ E_Abstract_State | E_Constant | E_Variable
then
Match_Constituent (Constit_Id);
if Ename = Pnm
or else Pnm = Name_Assertion
or else (Pnm = Name_Statement_Assertions
- and then Nam_In (Ename, Name_Assert,
- Name_Assert_And_Cut,
- Name_Assume,
- Name_Loop_Invariant,
- Name_Loop_Variant))
+ and then Ename in Name_Assert
+ | Name_Assert_And_Cut
+ | Name_Assume
+ | Name_Loop_Invariant
+ | Name_Loop_Variant)
then
Policy := Chars (Get_Pragma_Arg (Last (PPA)));
or else (Pnm = Name_Assertion
and then Is_Valid_Assertion_Kind (Nam))
or else (Pnm = Name_Statement_Assertions
- and then Nam_In (Nam, Name_Assert,
- Name_Assert_And_Cut,
- Name_Assume,
- Name_Loop_Invariant,
- Name_Loop_Variant))
+ and then Nam in Name_Assert
+ | Name_Assert_And_Cut
+ | Name_Assume
+ | Name_Loop_Invariant
+ | Name_Loop_Variant)
then
case (Chars (Get_Pragma_Arg (Last (PPA)))) is
when Name_Check
-- they depend on variable input. This check is left to the SPARK
-- prover.
- elsif Ekind_In (Item_Id, E_Abstract_State, E_Variable) then
+ elsif Ekind (Item_Id) in E_Abstract_State | E_Variable then
return True;
-- Recursively peek into nested packages and instantiations
Prag := Pre_Post_Conditions (Prags);
while Present (Prag) loop
- if Nam_In (Pragma_Name_Unmapped (Prag),
- Name_Precondition, Name_Postcondition)
+ if Pragma_Name_Unmapped (Prag)
+ in Name_Precondition | Name_Postcondition
and then Class_Present (Prag)
then
-- The generated pragma must be analyzed in the context of
procedure Collect_Global_Item (Item : Node_Id; Mode : Name_Id) is
begin
- if Nam_In (Mode, Name_In_Out, Name_Input) then
+ if Mode in Name_In_Out | Name_Input then
Append_New_Elmt (Item, Subp_Inputs);
end if;
- if Nam_In (Mode, Name_In_Out, Name_Output) then
+ if Mode in Name_In_Out | Name_Output then
Append_New_Elmt (Item, Subp_Outputs);
end if;
end Collect_Global_Item;
-- Single global item declaration
- elsif Nkind_In (List, N_Expanded_Name,
- N_Identifier,
- N_Selected_Component)
+ elsif Nkind (List) in N_Expanded_Name
+ | N_Identifier
+ | N_Selected_Component
then
Collect_Global_Item (List, Mode);
-- Process all formal parameters of entries, [generic] subprograms, and
-- their bodies.
- if Ekind_In (Subp_Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Generic_Function,
- E_Generic_Procedure,
- E_Procedure,
- E_Subprogram_Body)
+ if Ekind (Subp_Id) in E_Entry
+ | E_Entry_Family
+ | E_Function
+ | E_Generic_Function
+ | E_Generic_Procedure
+ | E_Procedure
+ | E_Subprogram_Body
then
Subp_Decl := Unit_Declaration_Node (Subp_Id);
Spec_Id := Unique_Defining_Entity (Subp_Decl);
Formal := First_Entity (Spec_Id);
while Present (Formal) loop
- if Ekind_In (Formal, E_In_Out_Parameter, E_In_Parameter) then
+ if Ekind (Formal) in E_In_Out_Parameter | E_In_Parameter then
Append_New_Elmt (Formal, Subp_Inputs);
end if;
- if Ekind_In (Formal, E_In_Out_Parameter, E_Out_Parameter) then
+ if Ekind (Formal) in E_In_Out_Parameter | E_Out_Parameter then
Append_New_Elmt (Formal, Subp_Outputs);
-- Out parameters can act as inputs when the related type is
-- Otherwise the input denotes a task type, a task body, or the
-- anonymous object created for a single task type.
- elsif Ekind_In (Subp_Id, E_Task_Type, E_Task_Body)
+ elsif Ekind (Subp_Id) in E_Task_Type | E_Task_Body
or else Is_Single_Task_Object (Subp_Id)
then
Subp_Decl := Declaration_Node (Subp_Id);
-- outputs.
if Is_Entry_Body (Subp_Id)
- or else Ekind_In (Subp_Id, E_Subprogram_Body, E_Task_Body)
+ or else Ekind (Subp_Id) in E_Subprogram_Body | E_Task_Body
then
Depends := Get_Pragma (Subp_Id, Pragma_Refined_Depends);
Global := Get_Pragma (Subp_Id, Pragma_Refined_Global);
Append_New_Elmt (Typ, Subp_Inputs);
- if Ekind_In (Spec_Id, E_Entry, E_Entry_Family, E_Procedure) then
+ if Ekind (Spec_Id) in E_Entry | E_Entry_Family | E_Procedure then
Append_New_Elmt (Typ, Subp_Outputs);
end if;
function Delay_Config_Pragma_Analyze (N : Node_Id) return Boolean is
begin
- return Nam_In (Pragma_Name_Unmapped (N),
- Name_Interrupt_State, Name_Priority_Specific_Dispatching);
+ return Pragma_Name_Unmapped (N)
+ in Name_Interrupt_State | Name_Priority_Specific_Dispatching;
end Delay_Config_Pragma_Analyze;
-----------------------
Stmt : Node_Id;
Look_For_Body : constant Boolean :=
- Nam_In (Prag_Nam, Name_Refined_Depends,
- Name_Refined_Global,
- Name_Refined_Post,
- Name_Refined_State);
+ Prag_Nam in Name_Refined_Depends
+ | Name_Refined_Global
+ | Name_Refined_Post
+ | Name_Refined_State;
-- Refinement pragmas must be associated with a subprogram body [stub]
-- Start of processing for Find_Related_Declaration_Or_Body
Args : Node_Id;
begin
- pragma Assert (Nam_In (Arg_Nam, Name_Ensures,
- Name_Mode,
- Name_Name,
- Name_Requires));
+ pragma Assert
+ (Arg_Nam in Name_Ensures | Name_Mode | Name_Name | Name_Requires);
-- The caller requests the aspect argument
and then not
(Nkind (Parent (P)) = N_Subtype_Indication
and then
- Nkind_In (Parent (Parent (P)), N_Component_Definition,
- N_Subtype_Declaration)
+ Nkind (Parent (Parent (P))) in N_Component_Definition
+ | N_Subtype_Declaration
and then Paren_Count (N) = 0)
then
Error_Msg_N
-- Legal case is in index or discriminant constraint
- elsif Nkind_In (PN, N_Index_Or_Discriminant_Constraint,
- N_Discriminant_Association)
+ elsif Nkind (PN) in N_Index_Or_Discriminant_Constraint
+ | N_Discriminant_Association
then
if Paren_Count (N) > 0 then
Error_Msg_N
else
D := PN;
P := Parent (PN);
- while not Nkind_In (P, N_Component_Declaration,
- N_Subtype_Indication,
- N_Entry_Declaration)
+ while Nkind (P) not in
+ N_Component_Declaration | N_Subtype_Indication | N_Entry_Declaration
loop
D := P;
P := Parent (P);
-- course a double fault.
if (Nkind (P) = N_Subtype_Indication
- and then Nkind_In (Parent (P), N_Component_Definition,
- N_Derived_Type_Definition)
+ and then Nkind (Parent (P)) in N_Component_Definition
+ | N_Derived_Type_Definition
and then D = Constraint (P))
-- The constraint itself may be given by a subtype indication,
function Is_Conditional_Statement (N : Node_Id) return Boolean is
begin
return
- Nkind_In (N, N_And_Then,
- N_Case_Expression,
- N_Case_Statement,
- N_If_Expression,
- N_If_Statement,
- N_Or_Else);
+ Nkind (N) in N_And_Then
+ | N_Case_Expression
+ | N_Case_Statement
+ | N_If_Expression
+ | N_If_Statement
+ | N_Or_Else;
end Is_Conditional_Statement;
-------------------------------
begin
return
Nkind (HSS) = N_Handled_Sequence_Of_Statements
- and then Nkind_In (Parent (HSS), N_Entry_Body, N_Subprogram_Body)
+ and then Nkind (Parent (HSS)) in N_Entry_Body | N_Subprogram_Body
and then Is_List_Member (N)
and then List_Containing (N) = Statements (HSS);
end Is_Immediately_Within_Body;
-- functions, this is never a parameterless call (RM 4.1.4(6)).
if Nkind (Parent (N)) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Parent (N)), Name_Address,
- Name_Code_Address,
- Name_Access)
+ and then Attribute_Name (Parent (N))
+ in Name_Address | Name_Code_Address | Name_Access
then
return False;
end if;
and then Ekind (Entity (N)) = E_Procedure
and then not Is_Overloaded (N)
and then
- Nkind_In (Parent (N), N_Parameter_Association,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ Nkind (Parent (N)) in N_Parameter_Association
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
return;
end if;
(Nkind (N) = N_Selected_Component
and then (Ekind (Entity (Selector_Name (N))) = E_Function
or else
- (Ekind_In (Entity (Selector_Name (N)), E_Entry,
- E_Procedure)
+ (Ekind (Entity (Selector_Name (N))) in
+ E_Entry | E_Procedure
and then Is_Overloaded (Selector_Name (N)))))
-- If one of the above three conditions is met, rewrite as call. Apply
elsif In_Instance then
null;
- elsif Nam_In (Op_Name, Name_Op_Multiply, Name_Op_Divide)
+ elsif Op_Name in Name_Op_Multiply | Name_Op_Divide
and then Is_Fixed_Point_Type (Etype (Act1))
and then Is_Fixed_Point_Type (Etype (Act2))
then
-- available.
elsif Ada_Version >= Ada_2005
- and then Nam_In (Op_Name, Name_Op_Eq, Name_Op_Ne)
+ and then Op_Name in Name_Op_Eq | Name_Op_Ne
and then (Is_Anonymous_Access_Type (Etype (Act1))
or else Is_Anonymous_Access_Type (Etype (Act2)))
then
and then not In_Instance
then
if Is_Fixed_Point_Type (Typ)
- and then Nam_In (Op_Name, Name_Op_Multiply, Name_Op_Divide)
+ and then Op_Name in Name_Op_Multiply | Name_Op_Divide
then
-- Already checked above
-- the equality node will not resolve any remaining ambiguity, and it
-- assumes that the first operand is not overloaded.
- if Nam_In (Op_Name, Name_Op_Eq, Name_Op_Ne)
+ if Op_Name in Name_Op_Eq | Name_Op_Ne
and then Ekind (Func) = E_Function
and then Is_Overloaded (Act1)
then
-- access-to-subprogram type.
if Nkind (N) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (N), Name_Access,
- Name_Unrestricted_Access,
- Name_Unchecked_Access)
+ and then Attribute_Name (N) in Name_Access
+ | Name_Unrestricted_Access
+ | Name_Unchecked_Access
and then Comes_From_Source (N)
and then Is_Entity_Name (Prefix (N))
and then Is_Subprogram (Entity (Prefix (N)))
Set_Entity (N, Seen);
Generate_Reference (Seen, N);
- elsif Nkind_In (N, N_Case_Expression,
- N_Character_Literal,
- N_Delta_Aggregate,
- N_If_Expression)
+ elsif Nkind (N) in N_Case_Expression
+ | N_Character_Literal
+ | N_Delta_Aggregate
+ | N_If_Expression
then
Set_Etype (N, Expr_Type);
-- with a name that is an explicit dereference, there is
-- nothing to be done at this point.
- elsif Nkind_In (N, N_Attribute_Reference,
- N_And_Then,
- N_Explicit_Dereference,
- N_Identifier,
- N_Indexed_Component,
- N_Or_Else,
- N_Range,
- N_Selected_Component,
- N_Slice)
+ elsif Nkind (N) in N_Attribute_Reference
+ | N_And_Then
+ | N_Explicit_Dereference
+ | N_Identifier
+ | N_Indexed_Component
+ | N_Or_Else
+ | N_Range
+ | N_Selected_Component
+ | N_Slice
or else Nkind (Name (N)) = N_Explicit_Dereference
then
null;
-- Apply appropriate constraint/predicate checks for IN [OUT] case
- if Ekind_In (F, E_In_Parameter, E_In_Out_Parameter) then
+ if Ekind (F) in E_In_Parameter | E_In_Out_Parameter then
-- Apply predicate tests except in certain special cases. Note
-- that it might be more consistent to apply these only when
-- Checks for OUT parameters and IN OUT parameters
- if Ekind_In (F, E_Out_Parameter, E_In_Out_Parameter) then
+ if Ekind (F) in E_Out_Parameter | E_In_Out_Parameter then
-- If there is a type conversion, make sure the return value
-- meets the constraints of the variable before the conversion.
if Comes_From_Source (Nam)
and then Is_Ghost_Entity (Nam)
- and then Ekind_In (F, E_In_Out_Parameter, E_Out_Parameter)
+ and then Ekind (F) in E_In_Out_Parameter | E_Out_Parameter
and then Is_Entity_Name (A)
and then Present (Entity (A))
and then not Is_Ghost_Entity (Entity (A))
Aggr := Original_Node (Expression (E));
if Has_Discriminants (Subtyp)
- and then Nkind_In (Aggr, N_Aggregate, N_Extension_Aggregate)
+ and then Nkind (Aggr) in N_Aggregate | N_Extension_Aggregate
then
Discrim := First_Discriminant (Base_Type (Subtyp));
-- N is the expression after "delta" in a fixed_point_definition;
-- see RM-3.5.9(6):
- return Nkind_In (Parent (N), N_Ordinary_Fixed_Point_Definition,
- N_Decimal_Fixed_Point_Definition,
+ return Nkind (Parent (N)) in N_Ordinary_Fixed_Point_Definition
+ | N_Decimal_Fixed_Point_Definition
-- N is one of the bounds in a real_range_specification;
-- see RM-3.5.7(5):
- N_Real_Range_Specification,
+ | N_Real_Range_Specification
-- N is the expression of a delta_constraint;
-- see RM-J.3(3):
- N_Delta_Constraint);
+ | N_Delta_Constraint;
end Expected_Type_Is_Any_Real;
-----------------------------
-- a conversion will be applied to each operand, so resolve it
-- with its own type.
- if Nkind_In (Parent (N), N_Op_Divide, N_Op_Multiply) then
+ if Nkind (Parent (N)) in N_Op_Divide | N_Op_Multiply then
Resolve (N);
else
-- involving a fixed-point operand) the conditional expression must
-- resolve to a unique visible fixed_point type, normally Duration.
- elsif Nkind_In (N, N_Case_Expression, N_If_Expression)
+ elsif Nkind (N) in N_Case_Expression | N_If_Expression
and then Etype (N) = Universal_Real
and then Is_Fixed_Point_Type (B_Typ)
then
and then (Is_Integer_Or_Universal (L)
or else
Is_Integer_Or_Universal (R))))
- and then Nkind_In (N, N_Op_Multiply, N_Op_Divide)
+ and then Nkind (N) in N_Op_Multiply | N_Op_Divide
then
if TL = Universal_Integer or else TR = Universal_Integer then
Check_For_Visible_Operator (N, B_Typ);
then
if B_Typ = Universal_Fixed
and then not Expected_Type_Is_Any_Real (N)
- and then not Nkind_In (Parent (N), N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ and then Nkind (Parent (N)) not in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
then
Error_Msg_N ("type cannot be determined from context!", N);
Error_Msg_N ("\explicit conversion to result type required", N);
else
if Ada_Version = Ada_83
and then Etype (N) = Universal_Fixed
- and then not
- Nkind_In (Parent (N), N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ and then Nkind (Parent (N)) not in
+ N_Type_Conversion | N_Unchecked_Type_Conversion
then
Error_Msg_N
("(Ada 83) fixed-point operation needs explicit "
-- Give warning if explicit division by zero
- if Nkind_In (N, N_Op_Divide, N_Op_Rem, N_Op_Mod)
+ if Nkind (N) in N_Op_Divide | N_Op_Rem | N_Op_Mod
and then not Division_Checks_Suppressed (Etype (N))
then
Rop := Right_Opnd (N);
-- if both operands can be negative.
if Restriction_Check_Required (No_Implicit_Conditionals)
- and then Nkind_In (N, N_Op_Rem, N_Op_Mod)
+ and then Nkind (N) in N_Op_Rem | N_Op_Mod
then
declare
Lo : Uint;
-- operations use the same circuitry because the name in the call
-- can be an arbitrary expression with special resolution rules.
- elsif Nkind_In (Subp, N_Selected_Component, N_Indexed_Component)
+ elsif Nkind (Subp) in N_Selected_Component | N_Indexed_Component
or else (Is_Entity_Name (Subp) and then Is_Entry (Entity (Subp)))
then
Resolve_Entry_Call (N, Typ);
begin
P := Prev (N);
while Present (P) loop
- if not Nkind_In (P, N_Assignment_Statement,
- N_Raise_Constraint_Error)
+ if Nkind (P) not in N_Assignment_Statement
+ | N_Raise_Constraint_Error
then
exit Scope_Loop;
end if;
-- secondary stack (or any other one).
elsif Expander_Active
- and then Ekind_In (Nam, E_Function, E_Subprogram_Type)
+ and then Ekind (Nam) in E_Function | E_Subprogram_Type
and then Requires_Transient_Scope (Etype (Nam))
and then not Is_Ignored_Ghost_Entity (Nam)
then
F := First_Formal (Nam);
A := First_Actual (N);
while Present (F) and then Present (A) loop
- if Ekind_In (F, E_Out_Parameter, E_In_Out_Parameter)
+ if Ekind (F) in E_Out_Parameter | E_In_Out_Parameter
and then Warn_On_Modified_As_Out_Parameter (F)
and then Is_Entity_Name (A)
and then Present (Entity (A))
Expr : Node_Id) return Boolean
is
begin
- if Nkind_In (Context, N_Assignment_Statement,
- N_Object_Declaration)
+ if Nkind (Context) in
+ N_Assignment_Statement | N_Object_Declaration
and then Expression (Context) = Expr
then
return True;
-- Check whether a construct that yields a name is the expression of
-- an assignment statement or an object declaration.
- elsif (Nkind_In (Context, N_Attribute_Reference,
- N_Explicit_Dereference,
- N_Indexed_Component,
- N_Selected_Component,
- N_Slice)
+ elsif (Nkind (Context) in N_Attribute_Reference
+ | N_Explicit_Dereference
+ | N_Indexed_Component
+ | N_Selected_Component
+ | N_Slice
and then Prefix (Context) = Expr)
or else
- (Nkind_In (Context, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ (Nkind (Context) in N_Type_Conversion
+ | N_Unchecked_Type_Conversion
and then Expression (Context) = Expr)
then
return
S : Entity_Id;
begin
- if Ekind_In (Etype (R), E_Allocator_Type,
- E_Access_Attribute_Type)
+ if Ekind (Etype (R)) in E_Allocator_Type | E_Access_Attribute_Type
then
Acc := Designated_Type (Etype (R));
- elsif Ekind_In (Etype (L), E_Allocator_Type,
- E_Access_Attribute_Type)
+ elsif Ekind (Etype (L)) in E_Allocator_Type | E_Access_Attribute_Type
then
Acc := Designated_Type (Etype (L));
else
return;
elsif T = Any_Access
- or else Ekind_In (T, E_Allocator_Type, E_Access_Attribute_Type)
+ or else Ekind (T) in E_Allocator_Type | E_Access_Attribute_Type
then
T := Find_Unique_Access_Type;
if Expander_Active
and then
- (Ekind_In (T, E_Anonymous_Access_Type,
- E_Anonymous_Access_Subprogram_Type)
+ (Ekind (T) in E_Anonymous_Access_Type
+ | E_Anonymous_Access_Subprogram_Type
or else Is_Private_Type (T))
then
if Etype (L) /= T then
Res : Node_Id;
begin
- if Nkind_In (Opnd, N_Integer_Literal, N_Real_Literal) then
+ if Nkind (Opnd) in N_Integer_Literal | N_Real_Literal then
Res :=
Make_Qualified_Expression (Loc,
Subtype_Mark => New_Occurrence_Of (Btyp, Loc),
if Short_Circuit_And_Or
and then B_Typ = Standard_Boolean
- and then Nkind_In (N, N_Op_And, N_Op_Or)
+ and then Nkind (N) in N_Op_And | N_Op_Or
then
-- Mark the corresponding putative SCO operator as truly a logical
-- (and short-circuit) operator.
Alt := First (Alternatives (N));
while Present (Alt) loop
if Is_OK_Static_Expression (Alt)
- and then (Nkind_In (Alt, N_Integer_Literal,
- N_Character_Literal)
- or else Nkind (Alt) in N_Has_Entity)
+ and then Nkind (Alt) in N_Integer_Literal
+ | N_Character_Literal
+ | N_Has_Entity
then
Nalts := Nalts + 1;
Alts (Nalts) := (Alt, Expr_Value (Alt));
begin
if B_Typ = Standard_Boolean
- and then Nkind_In (Opnd, N_Op_Eq, N_Op_Ne)
+ and then Nkind (Opnd) in N_Op_Eq | N_Op_Ne
and then Is_Overloaded (Opnd)
then
Resolve_Equality_Op (Opnd, B_Typ);
elsif Nkind (Parent (N)) = N_Op_Concat
and then not Need_Check
- and then not Nkind_In (Original_Node (N), N_Character_Literal,
- N_Attribute_Reference,
- N_Qualified_Expression,
- N_Type_Conversion)
+ and then Nkind (Original_Node (N)) not in N_Character_Literal
+ | N_Attribute_Reference
+ | N_Qualified_Expression
+ | N_Type_Conversion
then
Subtype_Id := Typ;
-- precision.
if Is_Fixed_Point_Type (Typ)
- and then Nkind_In (Operand, N_Op_Divide, N_Op_Multiply)
+ and then Nkind (Operand) in N_Op_Divide | N_Op_Multiply
and then Etype (Left_Opnd (Operand)) = Any_Fixed
and then Etype (Right_Opnd (Operand)) = Any_Fixed
then
Set_Etype (Operand, Universal_Real);
elsif Is_Numeric_Type (Typ)
- and then Nkind_In (Operand, N_Op_Multiply, N_Op_Divide)
+ and then Nkind (Operand) in N_Op_Multiply | N_Op_Divide
and then (Etype (Right_Opnd (Operand)) = Universal_Real
or else
Etype (Left_Opnd (Operand)) = Universal_Real)
-- newer language version.
elsif Nkind (Orig_N) = N_Qualified_Expression
- and then Nkind_In (Parent (N), N_Attribute_Reference,
- N_Indexed_Component,
- N_Selected_Component,
- N_Slice,
- N_Explicit_Dereference)
+ and then Nkind (Parent (N)) in N_Attribute_Reference
+ | N_Indexed_Component
+ | N_Selected_Component
+ | N_Slice
+ | N_Explicit_Dereference
then
null;
-- Handle subtypes
- if Ekind_In (Opnd, E_Protected_Subtype, E_Task_Subtype) then
+ if Ekind (Opnd) in E_Protected_Subtype | E_Task_Subtype then
Opnd := Etype (Opnd);
end if;
-- mod. These are the cases where the grouping can affect results.
if Paren_Count (Rorig) = 0
- and then Nkind_In (Rorig, N_Op_Mod, N_Op_Multiply, N_Op_Divide)
+ and then Nkind (Rorig) in N_Op_Mod | N_Op_Multiply | N_Op_Divide
then
-- For mod, we always give the warning, since the value is
-- affected by the parenthesization (e.g. (-5) mod 315 /=
-- overflow is impossible (divisor > 1) or we have a case of
-- division by zero in any case.
- if Nkind_In (Rorig, N_Op_Divide, N_Op_Rem)
+ if Nkind (Rorig) in N_Op_Divide | N_Op_Rem
and then Compile_Time_Known_Value (Right_Opnd (Rorig))
and then UI_Abs (Expr_Value (Right_Opnd (Rorig))) /= 1
then
or else (Is_Fixed_Point_Type (Target_Typ)
and then Conversion_OK (N)))
and then Nkind (Operand) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Operand), Name_Rounding,
- Name_Machine_Rounding,
- Name_Truncation)
+ and then Attribute_Name (Operand) in Name_Rounding
+ | Name_Machine_Rounding
+ | Name_Truncation
then
declare
Truncate : constant Boolean :=
-- When the context is a type conversion, issue the warning on the
-- expression of the conversion because it is the actual operation.
- if Nkind_In (N, N_Type_Conversion, N_Unchecked_Type_Conversion) then
+ if Nkind (N) in N_Type_Conversion | N_Unchecked_Type_Conversion then
ErrN := Expression (N);
else
ErrN := N;
-- <prefix>.all.Access_Discrim.all.Access_Discrim case,
-- where the correct result depends on <prefix>.
- return Nkind_In (Associated_Node,
- N_Procedure_Specification, -- access parameter
- N_Function_Specification, -- access parameter
- N_Object_Declaration -- saooaaat
- )
+ return Nkind (Associated_Node) in
+ N_Procedure_Specification | -- access parameter
+ N_Function_Specification | -- access parameter
+ N_Object_Declaration -- saooaaat
or else Is_Discrim_Of_Bad_Access_Conversion_Argument (Deref_Prefix);
end Is_Discrim_Of_Bad_Access_Conversion_Argument;
-- checks that must be applied to such conversions to prevent
-- out-of-scope references.
- elsif Ekind_In
- (Target_Comp_Base, E_Anonymous_Access_Type,
- E_Anonymous_Access_Subprogram_Type)
+ elsif Ekind (Target_Comp_Base) in
+ E_Anonymous_Access_Type
+ | E_Anonymous_Access_Subprogram_Type
and then Ekind (Opnd_Comp_Base) = Ekind (Target_Comp_Base)
and then
Subtypes_Statically_Match (Target_Comp_Type, Opnd_Comp_Type)
-- interface type.
elsif Is_Access_Type (Opnd_Type)
- and then Ekind_In (Target_Type, E_General_Access_Type,
- E_Anonymous_Access_Type)
+ and then Ekind (Target_Type) in
+ E_General_Access_Type | E_Anonymous_Access_Type
and then Is_Interface (Directly_Designated_Type (Target_Type))
then
-- Check the static accessibility rule of 4.6(17). Note that the
if Is_Entity_Name (Operand)
and then not Is_Local_Anonymous_Access (Opnd_Type)
and then
- Ekind_In (Entity (Operand), E_In_Parameter, E_Constant)
+ Ekind (Entity (Operand)) in E_In_Parameter | E_Constant
and then Present (Discriminal_Link (Entity (Operand)))
then
Conversion_Error_N
-- General and anonymous access types
- elsif Ekind_In (Target_Type, E_General_Access_Type,
- E_Anonymous_Access_Type)
+ elsif Ekind (Target_Type) in
+ E_General_Access_Type | E_Anonymous_Access_Type
and then
Conversion_Check
(Is_Access_Type (Opnd_Type)
- and then not
- Ekind_In (Opnd_Type, E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type),
+ and then
+ Ekind (Opnd_Type) not in
+ E_Access_Subprogram_Type |
+ E_Access_Protected_Subprogram_Type,
"must be an access-to-object type")
then
if Is_Access_Constant (Opnd_Type)
-- as universal_access "=".
elsif not Is_Local_Anonymous_Access (Opnd_Type)
- and then Nkind_In (Associated_Node_For_Itype (Opnd_Type),
- N_Function_Specification,
- N_Procedure_Specification)
- and then not Nkind_In (Parent (N), N_Op_Eq, N_Op_Ne)
+ and then Nkind (Associated_Node_For_Itype (Opnd_Type)) in
+ N_Function_Specification |
+ N_Procedure_Specification
+ and then Nkind (Parent (N)) not in N_Op_Eq | N_Op_Ne
then
Conversion_Error_N
("implicit conversion of anonymous access parameter "
if Is_Entity_Name (Operand)
and then
- Ekind_In (Entity (Operand), E_In_Parameter, E_Constant)
+ Ekind (Entity (Operand)) in E_In_Parameter | E_Constant
and then Present (Discriminal_Link (Entity (Operand)))
then
Conversion_Error_N
-- object or parameter declaration. Interface types are still
-- unsupported.
- elsif Nkind_In (Ctrl_Tag, N_Object_Declaration,
- N_Parameter_Specification)
+ elsif Nkind (Ctrl_Tag) in
+ N_Object_Declaration | N_Parameter_Specification
then
Ctrl_Typ := Etype (Defining_Identifier (Ctrl_Tag));
-- Check contents of the boolean expression associated with the
-- membership test.
- pragma Assert (Nkind_In (N, N_Identifier,
- N_And_Then,
- N_Or_Else,
- N_Expression_With_Actions)
+ pragma Assert
+ (Nkind (N) in
+ N_Identifier | N_And_Then | N_Or_Else |
+ N_Expression_With_Actions
and then Etype (N) = Standard_Boolean);
-- Check the entity identifier of the associated tagged type (that
-- An Access_To_Subprogram is compatible with itself, or with an
-- anonymous type created for an attribute reference Access.
- elsif Ekind_In (BT1, E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type)
+ elsif Ekind (BT1) in E_Access_Subprogram_Type
+ | E_Access_Protected_Subprogram_Type
and then Is_Access_Type (T2)
and then (not Comes_From_Source (T1)
or else not Comes_From_Source (T2))
-- with itself, or with an anonymous type created for an attribute
-- reference Access.
- elsif Ekind_In (BT1, E_Anonymous_Access_Subprogram_Type,
- E_Anonymous_Access_Protected_Subprogram_Type)
+ elsif Ekind (BT1) in E_Anonymous_Access_Subprogram_Type
+ | E_Anonymous_Access_Protected_Subprogram_Type
and then Is_Access_Type (T2)
and then (not Comes_From_Source (T1)
or else not Comes_From_Source (T2))
-- imposed by context.
elsif Ekind (T2) = E_Access_Attribute_Type
- and then Ekind_In (BT1, E_General_Access_Type, E_Access_Type)
+ and then Ekind (BT1) in E_General_Access_Type | E_Access_Type
and then Covers (Designated_Type (T1), Designated_Type (T2))
then
-- If the target type is a RACW type while the source is an access
and then Is_Overloaded (Act1)
and then
(Nkind (Act1) in N_Unary_Op
- or else Nkind_In (Left_Opnd (Act1), N_Integer_Literal,
- N_Real_Literal))
- and then Nkind_In (Right_Opnd (Act1), N_Integer_Literal,
- N_Real_Literal)
+ or else Nkind (Left_Opnd (Act1)) in
+ N_Integer_Literal | N_Real_Literal)
+ and then Nkind (Right_Opnd (Act1)) in
+ N_Integer_Literal | N_Real_Literal
and then Has_Compatible_Type (Act1, Standard_Boolean)
and then Etype (F1) = Standard_Boolean
then
elsif Present (Act2)
and then Nkind (Act2) in N_Op
and then Is_Overloaded (Act2)
- and then Nkind_In (Right_Opnd (Act2), N_Integer_Literal,
- N_Real_Literal)
+ and then Nkind (Right_Opnd (Act2)) in
+ N_Integer_Literal | N_Real_Literal
and then Has_Compatible_Type (Act2, Standard_Boolean)
then
-- The preference rule on the first actual is not
and then not In_Instance
then
if Is_Fixed_Point_Type (Typ)
- and then Nam_In (Chars (Nam1), Name_Op_Multiply, Name_Op_Divide)
+ and then Chars (Nam1) in Name_Op_Multiply | Name_Op_Divide
and then
(Ada_Version = Ada_83
or else (Ada_Version >= Ada_2012
-- declared in the same declarative list as the type. The node
-- may be an operator or a function call.
- elsif Nam_In (Chars (Nam1), Name_Op_Eq, Name_Op_Ne)
+ elsif Chars (Nam1) in Name_Op_Eq | Name_Op_Ne
and then Ada_Version >= Ada_2005
and then Etype (User_Subp) = Standard_Boolean
and then Is_Anonymous_Access_Type (Operand_Type)
elsif Num = 1 then
T1 := Etype (New_First_F);
- if Nam_In (Op_Name, Name_Op_Subtract, Name_Op_Add, Name_Op_Abs) then
+ if Op_Name in Name_Op_Subtract | Name_Op_Add | Name_Op_Abs then
return Base_Type (T1) = Base_Type (T)
and then Is_Numeric_Type (T);
T1 := Etype (New_First_F);
T2 := Etype (Next_Formal (New_First_F));
- if Nam_In (Op_Name, Name_Op_And, Name_Op_Or, Name_Op_Xor) then
+ if Op_Name in Name_Op_And | Name_Op_Or | Name_Op_Xor then
return Base_Type (T1) = Base_Type (T2)
and then Base_Type (T1) = Base_Type (T)
and then Valid_Boolean_Arg (Base_Type (T));
- elsif Nam_In (Op_Name, Name_Op_Eq, Name_Op_Ne) then
+ elsif Op_Name in Name_Op_Eq | Name_Op_Ne then
return Base_Type (T1) = Base_Type (T2)
and then not Is_Limited_Type (T1)
and then Is_Boolean_Type (T);
- elsif Nam_In (Op_Name, Name_Op_Lt, Name_Op_Le,
- Name_Op_Gt, Name_Op_Ge)
+ elsif Op_Name in Name_Op_Lt | Name_Op_Le | Name_Op_Gt | Name_Op_Ge
then
return Base_Type (T1) = Base_Type (T2)
and then Valid_Comparison_Arg (T1)
and then Is_Boolean_Type (T);
- elsif Nam_In (Op_Name, Name_Op_Add, Name_Op_Subtract) then
+ elsif Op_Name in Name_Op_Add | Name_Op_Subtract then
return Base_Type (T1) = Base_Type (T2)
and then Base_Type (T1) = Base_Type (T)
and then Is_Numeric_Type (T);
and then Is_Floating_Point_Type (T2)
and then Base_Type (T2) = Base_Type (T));
- elsif Nam_In (Op_Name, Name_Op_Mod, Name_Op_Rem) then
+ elsif Op_Name in Name_Op_Mod | Name_Op_Rem then
return Base_Type (T1) = Base_Type (T2)
and then Base_Type (T1) = Base_Type (T)
and then Is_Integer_Type (T);
then
return T2;
- elsif Ekind_In (B1, E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type)
+ elsif Ekind (B1) in E_Access_Subprogram_Type
+ | E_Access_Protected_Subprogram_Type
and then Ekind (Designated_Type (B1)) /= E_Subprogram_Type
and then Is_Access_Type (T2)
then
return T2;
- elsif Ekind_In (B2, E_Access_Subprogram_Type,
- E_Access_Protected_Subprogram_Type)
+ elsif Ekind (B2) in E_Access_Subprogram_Type
+ | E_Access_Protected_Subprogram_Type
and then Ekind (Designated_Type (B2)) /= E_Subprogram_Type
and then Is_Access_Type (T1)
then
return T1;
- elsif Ekind_In (T1, E_Allocator_Type, E_Access_Attribute_Type)
+ elsif Ekind (T1) in E_Allocator_Type | E_Access_Attribute_Type
and then Is_Access_Type (T2)
then
return T2;
- elsif Ekind_In (T2, E_Allocator_Type, E_Access_Attribute_Type)
+ elsif Ekind (T2) in E_Allocator_Type | E_Access_Attribute_Type
and then Is_Access_Type (T1)
then
return T1;
Nod := Declaration_Node (Base_Type (Typ));
- if Nkind_In (Nod, N_Full_Type_Declaration,
- N_Private_Type_Declaration)
+ if Nkind (Nod) in N_Full_Type_Declaration | N_Private_Type_Declaration
then
return Empty_List;
end if;
HSS : Node_Id;
begin
- pragma Assert (Nkind_In (N, N_Block_Statement,
- N_Entry_Body,
- N_Package_Body,
- N_Subprogram_Body,
- N_Task_Body));
+ pragma Assert
+ (Nkind (N) in
+ N_Block_Statement |
+ N_Entry_Body |
+ N_Package_Body |
+ N_Subprogram_Body |
+ N_Task_Body);
HSS := Handled_Statement_Sequence (N);
-- Don't collect identifiers of packages, called functions, etc
- elsif Ekind_In (Entity (N), E_Package,
- E_Function,
- E_Procedure,
- E_Entry)
+ elsif Ekind (Entity (N)) in
+ E_Package | E_Function | E_Procedure | E_Entry
then
return Skip;
-- to identify a corner case???
elsif Nkind (Parent (N)) = N_Component_Association
- and then Nkind_In (Parent (Parent (N)),
- N_Aggregate,
- N_Extension_Aggregate)
+ and then Nkind (Parent (Parent (N))) in
+ N_Aggregate | N_Extension_Aggregate
then
declare
Choice : constant Node_Id := First (Choices (Parent (N)));
return Abandon;
end if;
- if Ekind_In (Id, E_Function, E_Generic_Function)
+ if Ekind (Id) in E_Function | E_Generic_Function
and then Has_Out_Or_In_Out_Parameter (Id)
then
Formal := First_Formal (Id);
Actual := First_Actual (Call);
while Present (Actual) and then Present (Formal) loop
if Actual = N then
- if Ekind_In (Formal, E_Out_Parameter,
- E_In_Out_Parameter)
+ if Ekind (Formal) in E_Out_Parameter
+ | E_In_Out_Parameter
then
Is_Writable_Actual := True;
end if;
if Ada_Version < Ada_2012
or else not Check_Actuals (N)
- or else (not (Nkind (N) in N_Op)
- and then not (Nkind (N) in N_Membership_Test)
- and then not Nkind_In (N, N_Range,
- N_Aggregate,
- N_Extension_Aggregate,
- N_Full_Type_Declaration,
- N_Function_Call,
- N_Procedure_Call_Statement,
- N_Entry_Call_Statement))
+ or else Nkind (N) not in N_Op
+ | N_Membership_Test
+ | N_Range
+ | N_Aggregate
+ | N_Extension_Aggregate
+ | N_Full_Type_Declaration
+ | N_Function_Call
+ | N_Procedure_Call_Statement
+ | N_Entry_Call_Statement
or else (Nkind (N) = N_Full_Type_Declaration
and then not Is_Record_Type (Defining_Identifier (N)))
Collect_Identifiers (Right_Opnd (N));
end if;
- if Nkind_In (N, N_In, N_Not_In)
+ if Nkind (N) in N_In | N_Not_In
and then Present (Alternatives (N))
then
Expr := First (Alternatives (N));
Formal := First_Formal (Id);
Actual := First_Actual (N);
while Present (Actual) and then Present (Formal) loop
- if Ekind_In (Formal, E_Out_Parameter,
- E_In_Out_Parameter)
+ if Ekind (Formal) in E_Out_Parameter | E_In_Out_Parameter
then
Collect_Identifiers (Actual);
end if;
-- Count several components
- elsif Nkind_In (Choice, N_Range,
- N_Subtype_Indication)
+ elsif Nkind (Choice) in
+ N_Range | N_Subtype_Indication
or else (Is_Entity_Name (Choice)
and then Is_Type (Entity (Choice)))
then
while Present (Assoc) loop
Choice := First (Choices (Assoc));
while Present (Choice) loop
- if Nkind_In (Choice, N_Range,
- N_Subtype_Indication)
+ if Nkind (Choice) in
+ N_Range | N_Subtype_Indication
or else (Is_Entity_Name (Choice)
and then Is_Type (Entity (Choice)))
then
elsif Nkind (P) = N_Parameter_Specification
and then Scope (Current_Scope) = Scope (Nam)
- and then Nkind_In (Parent (P), N_Entry_Declaration,
- N_Subprogram_Declaration)
+ and then Nkind (Parent (P)) in
+ N_Entry_Declaration | N_Subprogram_Declaration
then
Error_Msg_N
("internal call cannot appear in default for formal of "
-- Loop through sequence of basic declarative items
Outer : while Present (Decl) loop
- if not Nkind_In (Decl, N_Subprogram_Body, N_Package_Body, N_Task_Body)
+ if Nkind (Decl) not in
+ N_Subprogram_Body | N_Package_Body | N_Task_Body
and then Nkind (Decl) not in N_Body_Stub
then
Next (Decl);
Scop : Entity_Id;
begin
- pragma Assert (Ekind_In (Id, E_Abstract_State, E_Variable));
+ pragma Assert (Ekind (Id) in E_Abstract_State | E_Variable);
-- Nothing to do for internally-generated abstract states and variables
-- because they do not represent the hidden state of the source unit.
-- or a task.
elsif Is_Subprogram_Or_Entry (Context)
- or else Ekind_In (Context, E_Block, E_Task_Type)
+ or else Ekind (Context) in E_Block | E_Task_Type
then
return;
end if;
-- Initial_Condition and Initializes as this is part of the
-- elaboration checks for the constituent (SPARK RM 9(3)).
- if Nam_In (Prag_Nam, Name_Initial_Condition, Name_Initializes) then
+ if Prag_Nam in Name_Initial_Condition | Name_Initializes then
return;
-- When the reference appears within pragma Depends or Global,
-- that the pragma may not encapsulated by the type definition,
-- but this is still a valid context.
- elsif Nam_In (Prag_Nam, Name_Depends, Name_Global)
+ elsif Prag_Nam in Name_Depends | Name_Global
and then Is_Single_Task_Pragma (Par, Conc_Obj)
then
return;
-- The reference appears somewhere in the definition of a single
-- concurrent type (SPARK RM 9(3)).
- elsif Nkind_In (Par, N_Single_Protected_Declaration,
- N_Single_Task_Declaration)
+ elsif Nkind (Par) in
+ N_Single_Protected_Declaration | N_Single_Task_Declaration
and then Defining_Entity (Par) = Conc_Obj
then
return;
-- The reference appears within the declaration or body of a single
-- concurrent type (SPARK RM 9(3)).
- elsif Nkind_In (Par, N_Protected_Body,
- N_Protected_Type_Declaration,
- N_Task_Body,
- N_Task_Type_Declaration)
+ elsif Nkind (Par) in N_Protected_Body
+ | N_Protected_Type_Declaration
+ | N_Task_Body
+ | N_Task_Type_Declaration
and then Is_Single_Declaration_Or_Body (Par, Conc_Obj)
then
return;
-- real check was already performed in the original context of the
-- reference.
- elsif Nkind_In (Par, N_Package_Body,
- N_Package_Declaration,
- N_Subprogram_Body,
- N_Subprogram_Declaration)
+ elsif Nkind (Par) in N_Package_Body
+ | N_Package_Declaration
+ | N_Subprogram_Body
+ | N_Subprogram_Declaration
and then Is_Internal_Declaration_Or_Body (Par)
then
return;
-- Empty list (no global items) or single global item
-- declaration (only input items).
- if Nkind_In (List, N_Null,
- N_Expanded_Name,
- N_Identifier,
- N_Selected_Component)
+ if Nkind (List) in N_Null
+ | N_Expanded_Name
+ | N_Identifier
+ | N_Selected_Component
then
return False;
Param := First_Formal (Subp);
while Present (Param) loop
- if Ekind_In (Param, E_Out_Parameter, E_In_Out_Parameter) then
+ if Ekind (Param) in E_Out_Parameter | E_In_Out_Parameter then
return False;
end if;
procedure Check_Conjuncts (Expr : Node_Id) is
begin
- if Nkind_In (Expr, N_Op_And, N_And_Then) then
+ if Nkind (Expr) in N_Op_And | N_And_Then then
Check_Conjuncts (Left_Opnd (Expr));
Check_Conjuncts (Right_Opnd (Expr));
else
Ent : Entity_Id;
begin
- if Nkind_In (N, N_Explicit_Dereference, N_Function_Call) then
+ if Nkind (N) in N_Explicit_Dereference | N_Function_Call then
Post_State_Seen := True;
return Abandon;
- elsif Nkind_In (N, N_Expanded_Name, N_Identifier) then
+ elsif Nkind (N) in N_Expanded_Name | N_Identifier then
Ent := Entity (N);
-- Treat an undecorated reference as OK
-- A reference to an assignable entity is considered a
-- change in the post-state of a subprogram.
- or else Ekind_In (Ent, E_Generic_In_Out_Parameter,
- E_In_Out_Parameter,
- E_Out_Parameter,
- E_Variable)
+ or else Ekind (Ent) in E_Generic_In_Out_Parameter
+ | E_In_Out_Parameter
+ | E_Out_Parameter
+ | E_Variable
-- The reference may be modified through a dereference
-- Examine the expression of a postcondition
- else pragma Assert (Nam_In (Nam, Name_Postcondition,
- Name_Refined_Post));
+ else pragma Assert (Nam in Name_Postcondition | Name_Refined_Post);
Check_Expression (Expr);
end if;
end Check_Result_And_Post_State_In_Pragma;
Prag := Pre_Post_Conditions (Items);
while Present (Prag) loop
- if Nam_In (Pragma_Name_Unmapped (Prag),
- Name_Postcondition, Name_Refined_Post)
+ if Pragma_Name_Unmapped (Prag)
+ in Name_Postcondition | Name_Refined_Post
and then not Error_Posted (Prag)
then
Post_Prag := Prag;
-- Do not emit any errors if the subprogram is not a function
- if not Ekind_In (Spec_Id, E_Function, E_Generic_Function) then
+ if Ekind (Spec_Id) not in E_Function | E_Generic_Function then
null;
-- Regardless of whether the function has postconditions or contract
if Present (Decls) then
Decl := First (Decls);
while Present (Decl) loop
- if Nkind_In (Decl, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ if Nkind (Decl) in N_Generic_Package_Declaration
+ | N_Package_Declaration
then
Check_Package (Decl);
end if;
-- An entry, protected, subprogram, or task body may declare a nested
-- package.
- elsif Nkind_In (Context, N_Entry_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ elsif Nkind (Context) in N_Entry_Body
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
-- Do not verify proper state refinement when the body is subject to
-- pragma SPARK_Mode Off because this disables the requirement for
-- A library level [generic] package may declare a nested package
- elsif Nkind_In (Context, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ elsif Nkind (Context) in
+ N_Generic_Package_Declaration | N_Package_Declaration
and then Is_Main_Unit
then
Check_Package (Context);
-- For indexed and selected components, recursively check the prefix
- if Nkind_In (Obj, N_Indexed_Component, N_Selected_Component) then
+ if Nkind (Obj) in N_Indexed_Component | N_Selected_Component then
return Enclosing_Protected_Type (Prefix (Obj));
-- The object does not denote a protected component
Constit_Id := Entity_Of (Constit);
if Present (Constit_Id)
- and then Ekind_In (Constit_Id, E_Abstract_State,
- E_Constant,
- E_Variable)
+ and then Ekind (Constit_Id) in
+ E_Abstract_State | E_Constant | E_Variable
then
Remove (States, Constit_Id);
end if;
elsif Ekind (Item_Id) = E_Abstract_State then
Append_New_Elmt (Item_Id, States);
- elsif Ekind_In (Item_Id, E_Constant, E_Variable)
+ elsif Ekind (Item_Id) in E_Constant | E_Variable
and then Is_Visible_Object (Item_Id)
then
Append_New_Elmt (Item_Id, States);
function Denotes_Same_Prefix (A1, A2 : Node_Id) return Boolean is
begin
if Is_Entity_Name (A1) then
- if Nkind_In (A2, N_Selected_Component, N_Indexed_Component)
+ if Nkind (A2) in N_Selected_Component | N_Indexed_Component
and then not Is_Access_Type (Etype (A1))
then
return Denotes_Same_Object (A1, Prefix (A2))
elsif Is_Entity_Name (A2) then
return Denotes_Same_Prefix (A1 => A2, A2 => A1);
- elsif Nkind_In (A1, N_Selected_Component, N_Indexed_Component, N_Slice)
+ elsif Nkind (A1) in N_Selected_Component | N_Indexed_Component | N_Slice
and then
- Nkind_In (A2, N_Selected_Component, N_Indexed_Component, N_Slice)
+ Nkind (A2) in N_Selected_Component | N_Indexed_Component | N_Slice
then
declare
Root1, Root2 : Node_Id;
begin
Root1 := Prefix (A1);
while not Is_Entity_Name (Root1) loop
- if not Nkind_In
- (Root1, N_Selected_Component, N_Indexed_Component)
+ if Nkind (Root1) not in
+ N_Selected_Component | N_Indexed_Component
then
return False;
else
Root2 := Prefix (A2);
while not Is_Entity_Name (Root2) loop
- if not Nkind_In (Root2, N_Selected_Component,
- N_Indexed_Component)
+ if Nkind (Root2) not in
+ N_Selected_Component | N_Indexed_Component
then
return False;
else
-- Start of processing for Designate_Same_Unit
begin
- if Nkind_In (K1, N_Identifier, N_Defining_Identifier)
+ if K1 in N_Identifier | N_Defining_Identifier
and then
- Nkind_In (K2, N_Identifier, N_Defining_Identifier)
+ K2 in N_Identifier | N_Defining_Identifier
then
return Chars (Name1) = Chars (Name2);
- elsif Nkind_In (K1, N_Expanded_Name,
- N_Selected_Component,
- N_Defining_Program_Unit_Name)
- and then
- Nkind_In (K2, N_Expanded_Name,
- N_Selected_Component,
- N_Defining_Program_Unit_Name)
+ elsif K1 in N_Expanded_Name
+ | N_Selected_Component
+ | N_Defining_Program_Unit_Name
+ and then
+ K2 in N_Expanded_Name
+ | N_Selected_Component
+ | N_Defining_Program_Unit_Name
then
return
(Chars (Select_Node (Name1)) = Chars (Select_Node (Name2)))
end if;
if (Is_Formal (E)
- or else Ekind_In (E, E_Variable, E_Constant))
+ or else Ekind (E) in E_Variable | E_Constant)
and then Present (Get_Accessibility (E))
then
return New_Occurrence_Of (Get_Accessibility (E), Loc);
-- Handle a constant-folded conditional expression by avoiding use of
-- the original node.
- if Nkind_In (Expr, N_Case_Expression, N_If_Expression) then
+ if Nkind (Expr) in N_Case_Expression | N_If_Expression then
Expr := N;
end if;
begin
Par := Parent (N);
while Present (Par) loop
- if Nkind_In (Par, N_Package_Body, N_Subprogram_Body) then
+ if Nkind (Par) in N_Package_Body | N_Subprogram_Body then
Spec_Id := Corresponding_Spec (Par);
if Present (Spec_Id)
- and then Nkind_In (Unit_Declaration_Node (Spec_Id),
- N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration)
+ and then Nkind (Unit_Declaration_Node (Spec_Id)) in
+ N_Generic_Package_Declaration |
+ N_Generic_Subprogram_Declaration
then
return Par;
end if;
begin
Par := Parent (N);
while Present (Par) loop
- if Nkind_In (Par, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration)
+ if Nkind (Par) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
then
return Par;
- elsif Nkind_In (Par, N_Package_Body, N_Subprogram_Body) then
+ elsif Nkind (Par) in N_Package_Body | N_Subprogram_Body then
Spec_Id := Corresponding_Spec (Par);
if Present (Spec_Id) then
Spec_Decl := Unit_Declaration_Node (Spec_Id);
- if Nkind_In (Spec_Decl, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration)
+ if Nkind (Spec_Decl) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
then
return Spec_Decl;
end if;
elsif Dynamic_Scope = Empty then
return Empty;
- elsif Ekind_In (Dynamic_Scope, E_Generic_Package,
- E_Package,
- E_Package_Body)
+ elsif Ekind (Dynamic_Scope) in
+ E_Generic_Package | E_Package | E_Package_Body
then
return Dynamic_Scope;
elsif Ekind (Dyn_Scop) = E_Subprogram_Body then
return Corresponding_Spec (Parent (Parent (Dyn_Scop)));
- elsif Ekind_In (Dyn_Scop, E_Block, E_Loop, E_Return_Statement) then
+ elsif Ekind (Dyn_Scop) in E_Block | E_Loop | E_Return_Statement then
return Enclosing_Subprogram (Dyn_Scop);
- elsif Ekind_In (Dyn_Scop, E_Entry, E_Entry_Family) then
+ elsif Ekind (Dyn_Scop) in E_Entry | E_Entry_Family then
-- For a task entry or entry family, return the enclosing subprogram
-- of the task itself.
-- The scope may appear as a private type or as a private extension
-- whose completion is a task or protected type.
- elsif Ekind_In (Dyn_Scop, E_Limited_Private_Type,
- E_Record_Type_With_Private)
+ elsif Ekind (Dyn_Scop) in
+ E_Limited_Private_Type | E_Record_Type_With_Private
and then Present (Full_View (Dyn_Scop))
- and then Ekind_In (Full_View (Dyn_Scop), E_Task_Type, E_Protected_Type)
+ and then Ekind (Full_View (Dyn_Scop)) in E_Task_Type | E_Protected_Type
then
return Get_Task_Body_Procedure (Full_View (Dyn_Scop));
-- Start of processing for End_Keyword_Location
begin
- if Nkind_In (N, N_Block_Statement,
- N_Entry_Body,
- N_Package_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (N) in N_Block_Statement
+ | N_Entry_Body
+ | N_Package_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
Owner := Handled_Statement_Sequence (N);
elsif Nkind (N) = N_Protected_Body then
Owner := N;
- elsif Nkind_In (N, N_Protected_Type_Declaration,
- N_Single_Protected_Declaration)
+ elsif Nkind (N) in N_Protected_Type_Declaration
+ | N_Single_Protected_Declaration
then
Owner := Protected_Definition (N);
- elsif Nkind_In (N, N_Single_Task_Declaration,
- N_Task_Type_Declaration)
+ elsif Nkind (N) in N_Single_Task_Declaration | N_Task_Type_Declaration
then
Owner := Task_Definition (N);
-- Avoid cascaded messages with duplicate components in
-- derived types.
- if Ekind_In (E, E_Component, E_Discriminant) then
+ if Ekind (E) in E_Component | E_Discriminant then
return;
end if;
end if;
-- of inheriting components in a derived record definition. Preserve
-- their Ekind and Etype.
- if Ekind_In (Def_Id, E_Discriminant, E_Component) then
+ if Ekind (Def_Id) in E_Discriminant | E_Component then
null;
-- If a type is already set, leave it alone (happens when a type
-- Unless the Itype is for a record type with a corresponding remote
-- type (what is that about, it was not commented ???)
- if Ekind_In (Def_Id, E_Discriminant, E_Component)
+ if Ekind (Def_Id) in E_Discriminant | E_Component
or else
((not Is_Record_Type (Def_Id)
or else No (Corresponding_Remote_Type (Def_Id)))
elsif Comes_From_Source (Decl)
or else
- (Nkind_In (Decl, N_Subprogram_Body,
- N_Subprogram_Declaration)
+ (Nkind (Decl) in N_Subprogram_Body | N_Subprogram_Declaration
and then Is_Expression_Function (Defining_Entity (Decl)))
then
exit;
Call_Nam : Node_Id;
begin
- if Nkind_In (Context, N_Indexed_Component, N_Selected_Component)
+ if Nkind (Context) in N_Indexed_Component | N_Selected_Component
and then N = Prefix (Context)
then
Find_Actual (Context, Formal, Call);
then
Call := Parent (Context);
- elsif Nkind_In (Context, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ elsif Nkind (Context) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
Call := Context;
-- we exclude overloaded calls, since we don't know enough to be sure
-- of giving the right answer in this case.
- if Nkind_In (Call, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ if Nkind (Call) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
Call_Nam := Name (Call);
-- Check for components
- elsif
- Nkind_In (Expr, N_Selected_Component, N_Indexed_Component)
+ elsif Nkind (Expr) in N_Selected_Component | N_Indexed_Component
then
Expr := Prefix (Expr);
Off := True;
-- Single global item declaration (only input items)
- elsif Nkind_In (List, N_Expanded_Name, N_Identifier) then
+ elsif Nkind (List) in N_Expanded_Name | N_Identifier then
if Global_Mode = Name_Input then
return List;
else
-- Start of processing for First_Global
begin
- pragma Assert (Nam_In (Global_Mode, Name_In_Out,
- Name_Input,
- Name_Output,
- Name_Proof_In));
+ pragma Assert (Global_Mode in Name_In_Out
+ | Name_Input
+ | Name_Output
+ | Name_Proof_In);
-- Retrieve the suitable pragma Global or Refined_Global. In the second
-- case, it can only be located on the body entity.
function Fix_Msg (Id : Entity_Id; Msg : String) return String is
Is_Task : constant Boolean :=
- Ekind_In (Id, E_Task_Body, E_Task_Type)
+ Ekind (Id) in E_Task_Body | E_Task_Type
or else Is_Single_Task_Object (Id);
Msg_Last : constant Natural := Msg'Last;
Msg_Index : Natural;
pragma Assert
(Is_Type (Typ)
and then
- Nam_In (Nam, Name_Element,
- Name_First,
- Name_Has_Element,
- Name_Last,
- Name_Next,
- Name_Previous));
+ Nam in Name_Element
+ | Name_First
+ | Name_Has_Element
+ | Name_Last
+ | Name_Next
+ | Name_Previous);
Funcs : constant Node_Id := Find_Value_Of_Aspect (Typ, Aspect_Iterable);
Assoc : Node_Id;
-- Strip the subprogram call
loop
- if Nkind_In (Subp, N_Explicit_Dereference,
- N_Indexed_Component,
- N_Selected_Component)
+ if Nkind (Subp) in N_Explicit_Dereference
+ | N_Indexed_Component
+ | N_Selected_Component
then
Subp := Prefix (Subp);
- elsif Nkind_In (Subp, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ elsif Nkind (Subp) in N_Type_Conversion
+ | N_Unchecked_Type_Conversion
then
Subp := Expression (Subp);
UFull_Typ := Underlying_Full_View (Full_Typ);
if Present (UFull_Typ)
- and then Ekind_In (UFull_Typ, E_Protected_Type, E_Task_Type)
+ and then Ekind (UFull_Typ) in E_Protected_Type | E_Task_Type
then
CRec_Typ := Corresponding_Record_Type (UFull_Typ);
end if;
else
if Present (Full_Typ)
- and then Ekind_In (Full_Typ, E_Protected_Type, E_Task_Type)
+ and then Ekind (Full_Typ) in E_Protected_Type | E_Task_Type
then
CRec_Typ := Corresponding_Record_Type (Full_Typ);
end if;
function Has_Declarations (N : Node_Id) return Boolean is
begin
- return Nkind_In (Nkind (N), N_Accept_Statement,
- N_Block_Statement,
- N_Compilation_Unit_Aux,
- N_Entry_Body,
- N_Package_Body,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body,
- N_Package_Specification);
+ return Nkind (N) in N_Accept_Statement
+ | N_Block_Statement
+ | N_Compilation_Unit_Aux
+ | N_Entry_Body
+ | N_Package_Body
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
+ | N_Package_Specification;
end Has_Declarations;
---------------------------------
-- Inspect the return type of functions
- if Ekind_In (Subp_Id, E_Function, E_Generic_Function)
+ if Ekind (Subp_Id) in E_Function | E_Generic_Function
and then Is_Effectively_Volatile (Etype (Subp_Id))
then
return True;
-- Synchronous (SPARK RM 7.1.4(9)).
elsif Has_Synchronous then
- return Nam_In (Property, Name_Async_Readers, Name_Async_Writers);
+ return Property in Name_Async_Readers | Name_Async_Writers;
end if;
return False;
elsif Nkind (N) in N_Has_Entity then
return Present (Entity (N))
- and then Ekind_In (Entity (N), E_Variable,
- E_Constant,
- E_Enumeration_Literal,
- E_In_Parameter,
- E_Out_Parameter,
- E_In_Out_Parameter)
+ and then
+ Ekind (Entity (N)) in
+ E_Variable | E_Constant | E_Enumeration_Literal |
+ E_In_Parameter | E_Out_Parameter | E_In_Out_Parameter
and then not Is_Volatile (Entity (N));
else
Node := First (L);
loop
- if not Nkind_In (Node, N_Null_Statement, N_Call_Marker) then
+ if Nkind (Node) not in N_Null_Statement | N_Call_Marker then
return True;
end if;
function Has_Prefix (N : Node_Id) return Boolean is
begin
- return
- Nkind_In (N, N_Attribute_Reference,
- N_Expanded_Name,
- N_Explicit_Dereference,
- N_Indexed_Component,
- N_Reference,
- N_Selected_Component,
- N_Slice);
+ return Nkind (N) in
+ N_Attribute_Reference | N_Expanded_Name | N_Explicit_Dereference |
+ N_Indexed_Component | N_Reference | N_Selected_Component |
+ N_Slice;
end Has_Prefix;
---------------------------
function Denotes_Relaxed_Parameter
(Expr : Node_Id;
- Param : Entity_Id)
- return Boolean
- is
+ Param : Entity_Id) return Boolean is
begin
- if Nkind_In (Expr, N_Identifier, N_Expanded_Name) then
+ if Nkind (Expr) in N_Identifier | N_Expanded_Name then
return Entity (Expr) = Param;
else
pragma Assert (Is_Attribute_Result (Expr));
begin
pragma Assert (Relaxed_RM_Semantics);
- pragma Assert (Nkind_In (N, N_Null,
- N_Op_Eq,
- N_Op_Ge,
- N_Op_Gt,
- N_Op_Le,
- N_Op_Lt,
- N_Op_Ne));
+ pragma Assert
+ (Nkind (N) in
+ N_Null | N_Op_Eq | N_Op_Ge | N_Op_Gt | N_Op_Le | N_Op_Lt | N_Op_Ne);
if Nkind (N) = N_Null then
Rewrite (N, New_Occurrence_Of (RTE (RE_Null_Address), Sloc (N)));
begin
S := Current_Scope;
while Present (S) and then S /= Standard_Standard loop
- if Ekind_In (S, E_Function, E_Procedure)
+ if Ekind (S) in E_Function | E_Procedure
and then Is_Generic_Instance (S)
then
return True;
begin
S := Current_Scope;
while Present (S) and then S /= Standard_Standard loop
- if Ekind_In (S, E_Function, E_Procedure)
+ if Ekind (S) in E_Function | E_Procedure
and then Is_Generic_Instance (S)
then
return True;
if Nod = Cont then
return True;
- elsif Nkind_In (Nod, N_Accept_Statement,
- N_Block_Statement,
- N_Compilation_Unit,
- N_Entry_Body,
- N_Package_Body,
- N_Package_Declaration,
- N_Protected_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ elsif Nkind (Nod) in N_Accept_Statement
+ | N_Block_Statement
+ | N_Compilation_Unit
+ | N_Entry_Body
+ | N_Package_Body
+ | N_Package_Declaration
+ | N_Protected_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
return False;
-- declaration hold the partial view and the full view is an
-- itype.
- elsif Nkind_In (Decl, N_Full_Type_Declaration,
- N_Private_Extension_Declaration,
- N_Private_Type_Declaration)
+ elsif Nkind (Decl) in N_Full_Type_Declaration
+ | N_Private_Extension_Declaration
+ | N_Private_Type_Declaration
then
Match := Defining_Identifier (Decl);
end if;
-- For a retrieval of a subcomponent of some composite object,
-- retrieve the ultimate entity if there is one.
- elsif Nkind_In (New_Prefix, N_Selected_Component,
- N_Indexed_Component)
+ elsif Nkind (New_Prefix) in N_Selected_Component | N_Indexed_Component
then
Pref := Prefix (New_Prefix);
while Present (Pref)
- and then Nkind_In (Pref, N_Selected_Component,
- N_Indexed_Component)
+ and then Nkind (Pref) in
+ N_Selected_Component | N_Indexed_Component
loop
Pref := Prefix (Pref);
end loop;
Par := Parent (N);
while Present (Par)
- and then Nkind_In (Par, N_Case_Expression,
- N_If_Expression,
- N_Parameter_Association)
+ and then Nkind (Par) in N_Case_Expression
+ | N_If_Expression
+ | N_Parameter_Association
loop
Par := Parent (Par);
end loop;
and then Has_Aliased_Components
(Designated_Type (Etype (Prefix (Obj)))));
- elsif Nkind_In (Obj, N_Unchecked_Type_Conversion, N_Type_Conversion) then
+ elsif Nkind (Obj) in N_Unchecked_Type_Conversion | N_Type_Conversion then
return Is_Tagged_Type (Etype (Obj))
and then Is_Aliased_View (Expression (Obj));
Context_Id : Entity_Id) return Boolean
is
begin
- pragma Assert (Ekind_In (Ref_Id, E_Protected_Type, E_Task_Type));
+ pragma Assert (Ekind (Ref_Id) in E_Protected_Type | E_Task_Type);
if Is_Single_Task_Object (Context_Id) then
return Scope_Within_Or_Same (Etype (Context_Id), Ref_Id);
else
- pragma Assert (Ekind_In (Context_Id, E_Entry,
- E_Entry_Family,
- E_Function,
- E_Package,
- E_Procedure,
- E_Protected_Type,
- E_Task_Type)
- or else
- Is_Record_Type (Context_Id));
+ pragma Assert
+ (Ekind (Context_Id) in
+ E_Entry | E_Entry_Family | E_Function | E_Package |
+ E_Procedure | E_Protected_Type | E_Task_Type
+ or else Is_Record_Type (Context_Id));
return Scope_Within_Or_Same (Context_Id, Ref_Id);
end if;
end Is_CCT_Instance;
elsif Nkind (Parent (Par)) = N_Object_Renaming_Declaration then
return False;
- elsif Nkind_In
- (Nkind (Parent (Par)), N_Function_Call,
- N_Procedure_Call_Statement,
- N_Entry_Call_Statement)
+ elsif Nkind (Parent (Par)) in
+ N_Function_Call |
+ N_Procedure_Call_Statement |
+ N_Entry_Call_Statement
then
-- Check that the element is not part of an actual for an
-- in-out parameter.
P := Parent (N);
while Present (P) loop
- if Nkind_In (P, N_Full_Type_Declaration,
- N_Private_Type_Declaration,
- N_Subtype_Declaration)
+ if Nkind (P) in N_Full_Type_Declaration
+ | N_Private_Type_Declaration
+ | N_Subtype_Declaration
and then Comes_From_Source (P)
and then Defining_Entity (P) = Typ
then
if Is_Entity_Name (N) then
return Present (Entity (N))
and then Ekind (Entity (N)) = E_In_Parameter
- and then Ekind_In (Scope (Entity (N)), E_Function, E_Procedure)
+ and then Ekind (Scope (Entity (N))) in E_Function | E_Procedure
and then
(Is_Predicate_Function (Scope (Entity (N)))
or else Is_Predicate_Function_M (Scope (Entity (N)))
begin
-- Find the dereference node if any
- while Nkind_In (Deref, N_Indexed_Component,
- N_Selected_Component,
- N_Slice)
+ while Nkind (Deref) in
+ N_Indexed_Component | N_Selected_Component | N_Slice
loop
Deref := Prefix (Deref);
end loop;
-- False (it could be a function selector in a prefix form call
-- occurring in an iterator specification).
- if not Ekind_In (Entity (Selector_Name (Object)), E_Component,
- E_Discriminant)
+ if Ekind (Entity (Selector_Name (Object))) not in
+ E_Component | E_Discriminant
then
return False;
end if;
function Is_Dereferenced (N : Node_Id) return Boolean is
P : constant Node_Id := Parent (N);
begin
- return Nkind_In (P, N_Selected_Component,
- N_Explicit_Dereference,
- N_Indexed_Component,
- N_Slice)
+ return Nkind (P) in N_Selected_Component
+ | N_Explicit_Dereference
+ | N_Indexed_Component
+ | N_Slice
and then Prefix (P) = N;
end Is_Dereferenced;
return Is_Object (Entity (N))
and then Is_Effectively_Volatile (Entity (N));
- elsif Nkind_In (N, N_Indexed_Component, N_Slice) then
+ elsif Nkind (N) in N_Indexed_Component | N_Slice then
return Is_Effectively_Volatile_Object (Prefix (N));
elsif Nkind (N) = N_Selected_Component then
or else
Is_Effectively_Volatile_Object (Selector_Name (N));
- elsif Nkind_In (N, N_Qualified_Expression,
- N_Unchecked_Type_Conversion,
- N_Type_Conversion)
+ elsif Nkind (N) in N_Qualified_Expression
+ | N_Unchecked_Type_Conversion
+ | N_Type_Conversion
then
return Is_Effectively_Volatile_Object (Expression (N));
function Is_Expression_Function (Subp : Entity_Id) return Boolean is
begin
- if Ekind_In (Subp, E_Function, E_Subprogram_Body) then
+ if Ekind (Subp) in E_Function | E_Subprogram_Body then
return
Nkind (Original_Node (Unit_Declaration_Node (Subp))) =
N_Expression_Function;
-- A qualified expression or a type conversion is an EVF expression when
-- its operand is an EVF expression.
- elsif Nkind_In (N, N_Qualified_Expression,
- N_Unchecked_Type_Conversion,
- N_Type_Conversion)
+ elsif Nkind (N) in N_Qualified_Expression
+ | N_Unchecked_Type_Conversion
+ | N_Type_Conversion
then
return Is_EVF_Expression (Expression (N));
-- their prefix denotes an EVF expression.
elsif Nkind (N) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (N), Name_Loop_Entry,
- Name_Old,
- Name_Update)
+ and then Attribute_Name (N) in Name_Loop_Entry
+ | Name_Old
+ | Name_Update
then
return Is_EVF_Expression (Prefix (N));
end if;
begin
-- Package/subprogram body
- if Nkind_In (Decl, N_Package_Body, N_Subprogram_Body)
+ if Nkind (Decl) in N_Package_Body | N_Subprogram_Body
and then Present (Corresponding_Spec (Decl))
then
Spec_Decl := Unit_Declaration_Node (Corresponding_Spec (Decl));
-- Package/subprogram body stub
- elsif Nkind_In (Decl, N_Package_Body_Stub, N_Subprogram_Body_Stub)
+ elsif Nkind (Decl) in N_Package_Body_Stub | N_Subprogram_Body_Stub
and then Present (Corresponding_Spec_Of_Stub (Decl))
then
Spec_Decl :=
-- calls.
return
- Nkind_In (Spec_Decl, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration);
+ Nkind (Spec_Decl) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration;
end Is_Generic_Declaration_Or_Body;
---------------------------
-- a predefined unit, i.e the one that declares iterator interfaces.
return
- Nam_In (Chars (Iter_Typ), Name_Forward_Iterator,
- Name_Reversible_Iterator)
+ Chars (Iter_Typ) in Name_Forward_Iterator | Name_Reversible_Iterator
and then In_Predefined_Unit (Root_Type (Iter_Typ));
end Denotes_Iterator;
-- Case of prefix of indexed or selected component or slice
- elsif Nkind_In (P, N_Indexed_Component, N_Selected_Component, N_Slice)
+ elsif Nkind (P) in N_Indexed_Component | N_Selected_Component | N_Slice
and then N = Prefix (P)
then
-- Here we have the case where the parent P is N.Q or N(Q .. R).
Ent : constant Entity_Id := Entity (Expr);
Sub : constant Entity_Id := Enclosing_Subprogram (Ent);
begin
- if not Ekind_In (Ent, E_Variable, E_In_Out_Parameter) then
+ if Ekind (Ent) not in E_Variable | E_In_Out_Parameter then
return False;
else
return Present (Sub) and then Sub = Current_Subprogram;
-- Attributes 'Input, 'Old and 'Result produce objects
when N_Attribute_Reference =>
- return
- Nam_In (Attribute_Name (N), Name_Input, Name_Old, Name_Result);
+ return Attribute_Name (N) in Name_Input | Name_Old | Name_Result;
when N_Selected_Component =>
return
if Ekind (Id) = E_Discriminant then
null;
- elsif Ekind_In (Id, E_Constant, E_In_Parameter)
+ elsif Ekind (Id) in E_Constant | E_In_Parameter
and then Present (Discriminal_Link (Id))
then
null;
when N_Attribute_Reference =>
return
- Nam_In (Attribute_Name (N), Name_Loop_Entry,
- Name_Old,
- Name_Priority,
- Name_Result)
+ Attribute_Name (N) in Name_Loop_Entry
+ | Name_Old
+ | Name_Priority
+ | Name_Result
or else Is_Function_Attribute_Name (Attribute_Name (N));
when N_Selected_Component =>
-- names.
when N_Explicit_Dereference =>
- return not Nkind_In (Original_Node (N), N_Case_Expression,
- N_If_Expression);
+ return Nkind (Original_Node (N)) not in
+ N_Case_Expression | N_If_Expression;
-- A view conversion of a tagged object is an object reference
-- expansion of a packed array aggregate).
elsif Nkind (AV) = N_Unchecked_Type_Conversion then
- if Nkind_In (Original_Node (AV), N_Function_Call, N_Aggregate) then
+ if Nkind (Original_Node (AV)) in N_Function_Call | N_Aggregate then
return False;
elsif Comes_From_Source (AV)
and then Is_Protected_Type (Etype (Pref))
and then Is_Entity_Name (Subp)
and then Present (Entity (Subp))
- and then Ekind_In (Entity (Subp), E_Entry,
- E_Entry_Family,
- E_Function,
- E_Procedure);
+ and then Ekind (Entity (Subp)) in
+ E_Entry | E_Entry_Family | E_Function | E_Procedure;
else
return False;
end if;
Func_Id := Id;
while Present (Func_Id) and then Func_Id /= Standard_Standard loop
- if Ekind_In (Func_Id, E_Function, E_Generic_Function) then
+ if Ekind (Func_Id) in E_Function | E_Generic_Function then
return Is_Volatile_Function (Func_Id);
end if;
-- The volatile object appears as the prefix of a name occurring in a
-- non-interfering context.
- elsif Nkind_In (Context, N_Attribute_Reference,
- N_Explicit_Dereference,
- N_Indexed_Component,
- N_Selected_Component,
- N_Slice)
+ elsif Nkind (Context) in
+ N_Attribute_Reference |
+ N_Explicit_Dereference |
+ N_Indexed_Component |
+ N_Selected_Component |
+ N_Slice
and then Prefix (Context) = Obj_Ref
and then Is_OK_Volatile_Context
(Context => Parent (Context),
elsif Nkind (Context) = N_Attribute_Reference
and then Prefix (Context) = Obj_Ref
- and then Nam_In (Attribute_Name (Context), Name_Address,
- Name_Alignment,
- Name_Component_Size,
- Name_First,
- Name_First_Bit,
- Name_Last,
- Name_Last_Bit,
- Name_Length,
- Name_Position,
- Name_Size,
- Name_Storage_Size)
+ and then Attribute_Name (Context) in Name_Address
+ | Name_Alignment
+ | Name_Component_Size
+ | Name_First
+ | Name_First_Bit
+ | Name_Last
+ | Name_Last_Bit
+ | Name_Length
+ | Name_Position
+ | Name_Size
+ | Name_Storage_Size
then
return True;
-- The volatile object appears as the expression of a type conversion
-- occurring in a non-interfering context.
- elsif Nkind_In (Context, N_Qualified_Expression,
- N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ elsif Nkind (Context) in N_Qualified_Expression
+ | N_Type_Conversion
+ | N_Unchecked_Type_Conversion
and then Expression (Context) = Obj_Ref
and then Is_OK_Volatile_Context
(Context => Parent (Context),
elsif Nkind (Par) = N_Case_Expression then
return Expr /= Expression (Par);
- elsif Nkind_In (Par, N_And_Then, N_Or_Else) then
+ elsif Nkind (Par) in N_And_Then | N_Or_Else then
return Expr = Right_Opnd (Par);
- elsif Nkind_In (Par, N_In, N_Not_In) then
+ elsif Nkind (Par) in N_In | N_Not_In then
-- If the membership includes several alternatives, only the first
-- is definitely evaluated.
TSS_Name_Type
(Name_Buffer (Name_Len - TSS_Name'Length + 1 .. Name_Len));
- if Nam_In (Chars (E), Name_uAssign, Name_uSize)
+ if Chars (E) in Name_uAssign | Name_uSize
or else
(Chars (E) = Name_Op_Eq
and then Etype (First_Formal (E)) = Etype (Last_Formal (E)))
-- these primitives.
return (Ada_Version >= Ada_2005 or else not Tagged_Type_Expansion)
- and then Nam_In (Chars (E), Name_uDisp_Asynchronous_Select,
- Name_uDisp_Conditional_Select,
- Name_uDisp_Get_Prim_Op_Kind,
- Name_uDisp_Get_Task_Id,
- Name_uDisp_Requeue,
- Name_uDisp_Timed_Select);
+ and then Chars (E) in Name_uDisp_Asynchronous_Select
+ | Name_uDisp_Conditional_Select
+ | Name_uDisp_Get_Prim_Op_Kind
+ | Name_uDisp_Get_Task_Id
+ | Name_uDisp_Requeue
+ | Name_uDisp_Timed_Select;
end Is_Predefined_Interface_Primitive;
---------------------------------------
TSS_Name_Type
(Name_Buffer (Name_Len - TSS_Name'Length + 1 .. Name_Len));
- if Nam_In (Chars (E), Name_uSize, Name_uAssign)
+ if Chars (E) in Name_uSize | Name_uAssign
or else
(Chars (E) = Name_Op_Eq
and then Etype (First_Formal (E)) = Etype (Last_Formal (E)))
begin
-- Aggregates
- if Nkind_In (N, N_Aggregate, N_Extension_Aggregate) then
+ if Nkind (N) in N_Aggregate | N_Extension_Aggregate then
return Is_Preelaborable_Aggregate (N);
-- Attributes are allowed in general, even if their prefix is a formal
and then Present (Entity (N))
and then
(Ekind (Entity (N)) = E_Discriminant
- or else (Ekind_In (Entity (N), E_Constant, E_In_Parameter)
+ or else (Ekind (Entity (N)) in E_Constant | E_In_Parameter
and then Present (Discriminal_Link (Entity (N)))))
then
return True;
begin
if not Is_List_Member (N) then
declare
- P : constant Node_Id := Parent (N);
+ P : constant Node_Id := Parent (N);
begin
- return Nkind_In (P, N_Expanded_Name,
- N_Generic_Association,
- N_Parameter_Association,
- N_Selected_Component)
+ return Nkind (P) in N_Expanded_Name
+ | N_Generic_Association
+ | N_Parameter_Association
+ | N_Selected_Component
and then Selector_Name (P) = N;
end;
function Is_Single_Concurrent_Type (Id : Entity_Id) return Boolean is
begin
return
- Ekind_In (Id, E_Protected_Type, E_Task_Type)
+ Ekind (Id) in E_Protected_Type | E_Task_Type
and then Is_Single_Concurrent_Type_Declaration
(Declaration_Node (Id));
end Is_Single_Concurrent_Type;
(N : Node_Id) return Boolean
is
begin
- return Nkind_In (Original_Node (N), N_Single_Protected_Declaration,
- N_Single_Task_Declaration);
+ return Nkind (Original_Node (N)) in
+ N_Single_Protected_Declaration | N_Single_Task_Declaration;
end Is_Single_Concurrent_Type_Declaration;
---------------------------------------------
and then Is_Aliased (Entity (P_Ult))
and then Is_Formal (Entity (P_Ult))
and then Scope (Entity (P_Ult)) = Scop
- and then Ekind_In (Scop, E_Function,
- E_Operator,
- E_Subprogram_Type)
+ and then Ekind (Scop) in
+ E_Function | E_Operator | E_Subprogram_Type
and then Needs_Result_Accessibility_Level (Scop);
end;
end Is_Special_Aliased_Formal_Access;
begin
R := Get_Referenced_Object (N);
- while Nkind_In (R, N_Indexed_Component, N_Selected_Component, N_Slice)
+ while Nkind (R) in N_Indexed_Component | N_Selected_Component | N_Slice
loop
R := Get_Referenced_Object (Prefix (R));
function Is_Volatile_Function (Func_Id : Entity_Id) return Boolean is
begin
- pragma Assert (Ekind_In (Func_Id, E_Function, E_Generic_Function));
+ pragma Assert (Ekind (Func_Id) in E_Function | E_Generic_Function);
-- A function declared within a protected type is volatile
begin
pragma Assert (Is_Itype (Id));
return Present (Parent (Id))
- and then Nkind_In (Parent (Id), N_Full_Type_Declaration,
- N_Subtype_Declaration)
+ and then Nkind (Parent (Id)) in
+ N_Full_Type_Declaration | N_Subtype_Declaration
and then Defining_Entity (Parent (Id)) = Id;
end Itype_Has_Declaration;
-- Obj := new ...'(new Coextension ...);
if Nkind (Context_Nod) = N_Assignment_Statement then
- Is_Dynamic :=
- Nkind_In (Expression (Context_Nod), N_Allocator,
- N_Qualified_Expression);
+ Is_Dynamic := Nkind (Expression (Context_Nod)) in
+ N_Allocator | N_Qualified_Expression;
-- An allocator that appears within the expression of a simple return
-- statement is treated as a potentially dynamic coextension when the
-- return new ...'(new Coextension ...);
elsif Nkind (Context_Nod) = N_Simple_Return_Statement then
- Is_Dynamic :=
- Nkind_In (Expression (Context_Nod), N_Aggregate,
- N_Allocator,
- N_Qualified_Expression);
+ Is_Dynamic := Nkind (Expression (Context_Nod)) in
+ N_Aggregate | N_Allocator | N_Qualified_Expression;
-- An alloctor that appears within the initialization expression of an
-- object declaration is considered a potentially dynamic coextension
-- return Obj : ... := (new Coextension ...);
elsif Nkind (Context_Nod) = N_Object_Declaration then
- Is_Dynamic :=
- Nkind_In (Root_Nod, N_Allocator, N_Qualified_Expression)
- or else
- Nkind (Parent (Context_Nod)) = N_Extended_Return_Statement;
+ Is_Dynamic := Nkind (Root_Nod) in N_Allocator | N_Qualified_Expression
+ or else Nkind (Parent (Context_Nod)) = N_Extended_Return_Statement;
-- This routine should not be called with constructs that cannot contain
-- coextensions.
-- suppressed. As a result the elaboration checks of the call must
-- be disabled in order to preserve this dependency.
- if Nkind_In (N, N_Entry_Call_Statement,
- N_Function_Call,
- N_Function_Instantiation,
- N_Package_Instantiation,
- N_Procedure_Call_Statement,
- N_Procedure_Instantiation)
+ if Nkind (N) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Function_Instantiation
+ | N_Package_Instantiation
+ | N_Procedure_Call_Statement
+ | N_Procedure_Instantiation
then
Nam := Extract_Name (N);
-- Obtain the complimentary unit of the main unit
- if Nkind_In (Main_Unit, N_Generic_Package_Declaration,
- N_Generic_Subprogram_Declaration,
- N_Package_Declaration,
- N_Subprogram_Declaration)
+ if Nkind (Main_Unit) in N_Generic_Package_Declaration
+ | N_Generic_Subprogram_Declaration
+ | N_Package_Declaration
+ | N_Subprogram_Declaration
then
Aux_Id := Corresponding_Body (Main_Unit);
- elsif Nkind_In (Main_Unit, N_Package_Body,
- N_Subprogram_Body,
- N_Subprogram_Renaming_Declaration)
+ elsif Nkind (Main_Unit) in N_Package_Body
+ | N_Subprogram_Body
+ | N_Subprogram_Renaming_Declaration
then
Aux_Id := Corresponding_Spec (Main_Unit);
end if;
function Process (N : Node_Id) return Traverse_Result is
begin
- if Nkind_In (N, N_Procedure_Call_Statement,
- N_Function_Call,
- N_Raise_Statement,
- N_Raise_Constraint_Error,
- N_Raise_Program_Error,
- N_Raise_Storage_Error)
+ if Nkind (N) in N_Procedure_Call_Statement
+ | N_Function_Call
+ | N_Raise_Statement
+ | N_Raise_xxx_Error
then
Result := True;
return Abandon;
-- subprogram call, and the caller requests this behavior.
elsif not Calls_OK
- and then Nkind_In (Par, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ and then Nkind (Par) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
return False;
-- Only references warrant a marker
- elsif not Nkind_In (N, N_Expanded_Name, N_Identifier) then
+ elsif Nkind (N) not in N_Expanded_Name | N_Identifier then
return False;
-- Only source references warrant a marker
Decl := Specification (Decl);
end if;
- if Nkind_In (Decl, N_Function_Instantiation,
- N_Function_Specification,
- N_Generic_Function_Renaming_Declaration,
- N_Generic_Package_Renaming_Declaration,
- N_Generic_Procedure_Renaming_Declaration,
- N_Package_Body,
- N_Package_Instantiation,
- N_Package_Renaming_Declaration,
- N_Package_Specification,
- N_Procedure_Instantiation,
- N_Procedure_Specification)
+ if Nkind (Decl) in N_Function_Instantiation
+ | N_Function_Specification
+ | N_Generic_Function_Renaming_Declaration
+ | N_Generic_Package_Renaming_Declaration
+ | N_Generic_Procedure_Renaming_Declaration
+ | N_Package_Body
+ | N_Package_Instantiation
+ | N_Package_Renaming_Declaration
+ | N_Package_Specification
+ | N_Procedure_Instantiation
+ | N_Procedure_Specification
then
Set_Chars (New_E, Chars (Defining_Unit_Name (Decl)));
Set_Defining_Unit_Name (Decl, New_E);
function Has_More_Ids (N : Node_Id) return Boolean is
begin
- if Nkind_In (N, N_Component_Declaration,
- N_Discriminant_Specification,
- N_Exception_Declaration,
- N_Formal_Object_Declaration,
- N_Number_Declaration,
- N_Object_Declaration,
- N_Parameter_Specification,
- N_Use_Package_Clause,
- N_Use_Type_Clause)
+ if Nkind (N) in N_Component_Declaration
+ | N_Discriminant_Specification
+ | N_Exception_Declaration
+ | N_Formal_Object_Declaration
+ | N_Number_Declaration
+ | N_Object_Declaration
+ | N_Parameter_Specification
+ | N_Use_Package_Clause
+ | N_Use_Type_Clause
then
return More_Ids (N);
else
-- Update the First/Next_Named_Association chain for a replicated
-- call.
- if Nkind_In (N, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ if Nkind (N) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
Update_Named_Associations
(Old_Call => N,
-- an entity declaration that must be replaced when the expander is
-- active if the expression has been preanalyzed or analyzed.
- elsif not Ekind_In (Id, E_Block,
- E_Constant,
- E_Label,
- E_Loop_Parameter,
- E_Procedure,
- E_Variable)
+ elsif Ekind (Id) not in
+ E_Block | E_Constant | E_Label | E_Loop_Parameter |
+ E_Procedure | E_Variable
and then not Is_Type (Id)
then
return;
-- shared. Thus cloned_Subtype must be set to indicate the sharing.
-- ??? What does this do?
- if Ekind_In (Itype, E_Class_Wide_Subtype, E_Record_Subtype) then
+ if Ekind (Itype) in E_Class_Wide_Subtype | E_Record_Subtype then
Set_Cloned_Subtype (New_Itype, Itype);
end if;
EWA_Level := EWA_Level + 1;
elsif EWA_Level > 0
- and then Nkind_In (N, N_Block_Statement,
- N_Subprogram_Body,
- N_Subprogram_Declaration)
+ and then Nkind (N) in N_Block_Statement
+ | N_Subprogram_Body
+ | N_Subprogram_Declaration
then
EWA_Inner_Scope_Level := EWA_Inner_Scope_Level + 1;
end if;
Par_Nod => N);
if EWA_Level > 0
- and then Nkind_In (N, N_Block_Statement,
- N_Subprogram_Body,
- N_Subprogram_Declaration)
+ and then Nkind (N) in N_Block_Statement
+ | N_Subprogram_Body
+ | N_Subprogram_Declaration
then
EWA_Inner_Scope_Level := EWA_Inner_Scope_Level - 1;
-- In case of a build-in-place call, the call will no longer be a
-- call; it will have been rewritten.
- if Nkind_In (Par, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ if Nkind (Par) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
return First_Named_Actual (Par);
function No_Heap_Finalization (Typ : Entity_Id) return Boolean is
begin
- if Ekind_In (Typ, E_Access_Type, E_General_Access_Type)
+ if Ekind (Typ) in E_Access_Type | E_General_Access_Type
and then Is_Library_Level_Entity (Typ)
then
-- A global No_Heap_Finalization pragma applies to all library-level
then
if No (Actuals)
and then
- Nkind_In (Parent (N), N_Procedure_Call_Statement,
- N_Function_Call,
- N_Parameter_Association)
+ Nkind (Parent (N)) in N_Procedure_Call_Statement
+ | N_Function_Call
+ | N_Parameter_Association
and then Ekind (S) /= E_Function
then
Set_Etype (N, Etype (S));
end if;
end;
- elsif Nkind_In (Exp, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ elsif Nkind (Exp) in N_Type_Conversion | N_Unchecked_Type_Conversion
then
Exp := Expression (Exp);
goto Continue;
- elsif Nkind_In (Exp, N_Slice,
- N_Indexed_Component,
- N_Selected_Component)
+ elsif Nkind (Exp) in
+ N_Slice | N_Indexed_Component | N_Selected_Component
then
-- Special check, if the prefix is an access type, then return
-- since we are modifying the thing pointed to, not the prefix.
-- Follow renaming chain
- if Ekind_In (Ent, E_Variable, E_Constant)
+ if Ekind (Ent) in E_Variable | E_Constant
and then Present (Renamed_Object (Ent))
then
Exp := Renamed_Object (Ent);
-- a modification of the container.
elsif Comes_From_Source (Original_Node (Exp))
- and then Nkind_In (Original_Node (Exp), N_Selected_Component,
- N_Indexed_Component)
+ and then Nkind (Original_Node (Exp)) in
+ N_Selected_Component | N_Indexed_Component
then
Exp := Prefix (Original_Node (Exp));
goto Continue;
function Is_Null_Excluding_Def (Def : Node_Id) return Boolean is
begin
- return
- Nkind_In (Def, N_Access_Definition,
- N_Access_Function_Definition,
- N_Access_Procedure_Definition,
- N_Access_To_Object_Definition,
- N_Component_Definition,
- N_Derived_Type_Definition)
+ return Nkind (Def) in N_Access_Definition
+ | N_Access_Function_Definition
+ | N_Access_Procedure_Definition
+ | N_Access_To_Object_Definition
+ | N_Component_Definition
+ | N_Derived_Type_Definition
and then Null_Exclusion_Present (Def);
end Is_Null_Excluding_Def;
if Is_Imported (Id) or else Is_Exported (Id) then
return Unknown;
- elsif Nkind_In (Decl, N_Component_Declaration,
- N_Discriminant_Specification,
- N_Formal_Object_Declaration,
- N_Object_Declaration,
- N_Object_Renaming_Declaration,
- N_Parameter_Specification)
+ elsif Nkind (Decl) in N_Component_Declaration
+ | N_Discriminant_Specification
+ | N_Formal_Object_Declaration
+ | N_Object_Declaration
+ | N_Object_Renaming_Declaration
+ | N_Parameter_Specification
then
-- A component declaration yields a non-null value when either
-- its component definition or access definition carries a null
-- Taking the 'Access of something yields a non-null value
elsif Nkind (N) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (N), Name_Access,
- Name_Unchecked_Access,
- Name_Unrestricted_Access)
+ and then Attribute_Name (N) in Name_Access
+ | Name_Unchecked_Access
+ | Name_Unrestricted_Access
then
return Is_Non_Null;
if Nkind (N) = N_Null then
return Present (Typ) and then Is_Descendant_Of_Address (Typ);
- elsif Nkind_In (N, N_Op_Eq, N_Op_Ge, N_Op_Gt, N_Op_Le, N_Op_Lt, N_Op_Ne)
+ elsif Nkind (N) in
+ N_Op_Eq | N_Op_Ge | N_Op_Gt | N_Op_Le | N_Op_Lt | N_Op_Ne
then
declare
L : constant Node_Id := Left_Opnd (N);
return Scope_Depth (Enclosing_Dynamic_Scope (E));
end if;
- elsif Nkind_In (Orig_Obj, N_Indexed_Component, N_Selected_Component) then
+ elsif Nkind (Orig_Obj) in N_Indexed_Component | N_Selected_Component then
Orig_Pre := Original_Node (Prefix (Orig_Obj));
if Is_Access_Type (Etype (Orig_Pre)) then
return Type_Access_Level (Etype (Prefix (Orig_Obj)));
end if;
- elsif Nkind_In (Orig_Obj, N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ elsif Nkind (Orig_Obj) in N_Type_Conversion | N_Unchecked_Type_Conversion
then
return Object_Access_Level (Expression (Orig_Obj));
-- we are trying to implement here.
elsif Nkind (Orig_Obj) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Orig_Obj),
- Name_Old,
- Name_Loop_Entry)
+ and then Attribute_Name (Orig_Obj) in Name_Old | Name_Loop_Entry
then
return Object_Access_Level (Current_Scope);
-- Move up the attribute reference when we encounter a 'Access variation
elsif Nkind (Orig_Obj) = N_Attribute_Reference
- and then Nam_In (Attribute_Name (Orig_Obj), Name_Access,
- Name_Unchecked_Access,
- Name_Unrestricted_Access)
+ and then Attribute_Name (Orig_Obj) in Name_Access
+ | Name_Unchecked_Access
+ | Name_Unrestricted_Access
then
return Object_Access_Level (Prefix (Orig_Obj));
Item_Nam : Name_Id;
begin
- pragma Assert (Nkind_In (N, N_Aspect_Specification, N_Pragma));
+ pragma Assert (Nkind (N) in N_Aspect_Specification | N_Pragma);
Item := N;
elsif Item_Nam = Name_Pre then
Item_Nam := Name_uPre;
- elsif Nam_In (Item_Nam, Name_Type_Invariant,
- Name_Type_Invariant_Class)
+ elsif Item_Nam in Name_Type_Invariant | Name_Type_Invariant_Class
then
Item_Nam := Name_uType_Invariant;
-- The current Check_Policy pragma matches the requested policy or
-- appears in the single argument form (Assertion, policy_id).
- if Nam_In (Chars (Arg1), Name_Assertion, Policy) then
+ if Chars (Arg1) in Name_Assertion | Policy then
return Chars (Arg2);
end if;
-- assertions, unless they are disabled. Force Name_Check on
-- ignored assertions.
- if Nam_In (Kind, Name_Ignore, Name_Off)
+ if Kind in Name_Ignore | Name_Off
and then (CodePeer_Mode or GNATprove_Mode)
then
Kind := Name_Check;
-- The entity denotes a primitive subprogram. Remove it from the list of
-- primitives of the associated controlling type.
- if Ekind_In (Id, E_Function, E_Procedure) and then Is_Primitive (Id) then
+ if Ekind (Id) in E_Function | E_Procedure and then Is_Primitive (Id) then
Formal := First_Formal (Id);
while Present (Formal) loop
if Is_Controlling_Formal (Formal) then
while R_Scope /= Standard_Standard loop
exit when R_Scope = E_Scope;
- if not Ekind_In (R_Scope, E_Package, E_Block, E_Loop) then
+ if Ekind (R_Scope) not in E_Package | E_Block | E_Loop then
return False;
else
R_Scope := Scope (R_Scope);
EN2 : constant Entity_Id := Entity (N2);
begin
if Present (EN1) and then Present (EN2)
- and then (Ekind_In (EN1, E_Variable, E_Constant)
+ and then (Ekind (EN1) in E_Variable | E_Constant
or else Is_Formal (EN1))
and then EN1 = EN2
then
Typ : constant Entity_Id := Etype (E);
begin
- if Ekind_In (Typ, E_Anonymous_Access_Type,
- E_Anonymous_Access_Subprogram_Type)
+ if Ekind (Typ) in E_Anonymous_Access_Type
+ | E_Anonymous_Access_Subprogram_Type
and then not Has_Convention_Pragma (Typ)
then
Basic_Set_Convention (Typ, Val);
if No (N) then
return False;
- elsif Nkind_In (N, N_Handled_Sequence_Of_Statements,
- N_If_Statement)
+ elsif Nkind (N) in
+ N_Handled_Sequence_Of_Statements | N_If_Statement
then
return True;
end if;
-- never needs to be made public and furthermore, making it public can
-- cause back end problems.
- elsif Nkind_In (Parent (Id), N_Object_Declaration,
- N_Function_Specification)
+ elsif Nkind (Parent (Id)) in
+ N_Object_Declaration | N_Function_Specification
and then Within_HSS_Or_If (Id)
then
return;
begin
-- Deal with indexed or selected component where prefix is modified
- if Nkind_In (N, N_Indexed_Component, N_Selected_Component) then
+ if Nkind (N) in N_Indexed_Component | N_Selected_Component then
Pref := Prefix (N);
-- If prefix is access type, then it is the designated object that is
return False;
end if;
- if not Ekind_In (Entity (Selector_Name (N)), E_Component,
- E_Discriminant)
+ if Ekind (Entity (Selector_Name (N))) not in
+ E_Component | E_Discriminant
then
return False;
end if;
-- 'Loop_Entry attribute into a conditional block. Infinite loops lack
-- the conditional part.
- if Nkind_In (Stmt, N_Block_Statement, N_If_Statement)
+ if Nkind (Stmt) in N_Block_Statement | N_If_Statement
and then Nkind (Original_Node (N)) = N_Loop_Statement
then
Stmt := Original_Node (N);
begin
Pref := N;
- while Nkind_In (Pref, N_Explicit_Dereference,
- N_Indexed_Component,
- N_Selected_Component,
- N_Slice)
+ while Nkind (Pref) in N_Explicit_Dereference
+ | N_Indexed_Component
+ | N_Selected_Component
+ | N_Slice
loop
Pref := Prefix (Pref);
end loop;
-- Recurse to handle unlikely case of multiple levels of qualification
-- and/or conversion.
- if Nkind_In (Expr, N_Qualified_Expression,
- N_Type_Conversion,
- N_Unchecked_Type_Conversion)
+ if Nkind (Expr) in N_Qualified_Expression
+ | N_Type_Conversion
+ | N_Unchecked_Type_Conversion
then
return Unqual_Conv (Expression (Expr));
Par := N;
while Present (Par) loop
- if Nkind_In (Par, N_Entry_Call_Statement,
- N_Function_Call,
- N_Procedure_Call_Statement)
+ if Nkind (Par) in N_Entry_Call_Statement
+ | N_Function_Call
+ | N_Procedure_Call_Statement
then
return True;
if No (E) then
return False;
- elsif not Ekind_In (E, E_Discriminant, E_Component)
- or else Nam_In (Chars (E), Name_uTag, Name_uParent)
+ elsif Ekind (E) not in E_Discriminant | E_Component
+ or else Chars (E) in Name_uTag | Name_uParent
then
Next_Entity (E);
elsif Is_Integer_Type (Expec_Type)
and then Is_RTE (Found_Type, RE_Address)
- and then Nkind_In (Parent (Expr), N_Op_Add, N_Op_Subtract)
+ and then Nkind (Parent (Expr)) in N_Op_Add | N_Op_Subtract
and then Expr = Left_Opnd (Parent (Expr))
and then Is_Integer_Type (Etype (Right_Opnd (Parent (Expr))))
then
Error_Msg_N ("\\found package name!", Expr);
elsif Is_Entity_Name (Expr)
- and then Ekind_In (Entity (Expr), E_Procedure, E_Generic_Procedure)
+ and then Ekind (Entity (Expr)) in E_Procedure | E_Generic_Procedure
then
if Ekind (Expec_Type) = E_Access_Subprogram_Type then
Error_Msg_N
if Expec_Type = Standard_Boolean
and then Is_Modular_Integer_Type (Found_Type)
- and then Nkind_In (Parent (Expr), N_Op_And, N_Op_Or, N_Op_Xor)
+ and then Nkind (Parent (Expr)) in N_Op_And | N_Op_Or | N_Op_Xor
and then Nkind (Right_Opnd (Parent (Expr))) in N_Op_Compare
then
declare
begin
-- Integer and real literals are of a universal type
- if Nkind_In (N, N_Integer_Literal, N_Real_Literal) then
+ if Nkind (N) in N_Integer_Literal | N_Real_Literal then
return True;
-- The values of certain attributes are of a universal type
if Ekind (E1) = E_Variable
or else
- (Ekind_In (E1, E_Out_Parameter, E_In_Out_Parameter)
+ (Ekind (E1) in E_Out_Parameter | E_In_Out_Parameter
and then not Is_Protected_Type (Current_Scope))
then
-- If the formal has a class-wide type, retrieve its type
UR := Original_Node (UR);
loop
- if Nkind_In (UR, N_Expression_With_Actions,
- N_Qualified_Expression,
- N_Type_Conversion)
+ if Nkind (UR) in N_Expression_With_Actions
+ | N_Qualified_Expression
+ | N_Type_Conversion
then
UR := Expression (UR);
and then (Is_Object (E1)
or else Is_Type (E1)
or else Ekind (E1) = E_Label
- or else Ekind_In (E1, E_Exception,
- E_Named_Integer,
- E_Named_Real)
+ or else Ekind (E1) in E_Exception
+ | E_Named_Integer
+ | E_Named_Real
or else Is_Overloadable (E1)
-- Package case, if the main unit is a package spec
E : constant Entity_Id := Entity (N);
begin
- if Ekind_In (E, E_Variable, E_Out_Parameter)
+ if Ekind (E) in E_Variable | E_Out_Parameter
and then Never_Set_In_Source_Check_Spec (E)
and then not Has_Initial_Value (E)
and then (No (Unset_Reference (E))
Nod := Parent (N);
while Present (Nod) loop
if Nkind (Nod) = N_Pragma
- and then Nam_In (Pragma_Name_Unmapped (Nod),
- Name_Postcondition,
- Name_Refined_Post,
- Name_Contract_Cases)
+ and then
+ Pragma_Name_Unmapped (Nod)
+ in Name_Postcondition
+ | Name_Refined_Post
+ | Name_Contract_Cases
then
return True;
P := Parent (P);
exit when No (P);
- if Nkind_In (P, N_If_Statement, N_Elsif_Part)
+ if Nkind (P) in N_If_Statement | N_Elsif_Part
and then Ref_In (Condition (P))
then
return;
-- Reference to obsolescent component
- elsif Ekind_In (E, E_Component, E_Discriminant) then
+ elsif Ekind (E) in E_Component | E_Discriminant then
Error_Msg_NE
("??reference to obsolescent component& declared#", N, E);
-- node, since assert pragmas get rewritten at analysis time.
elsif Nkind (Original_Node (P)) = N_Pragma
- and then Nam_In (Pragma_Name_Unmapped (Original_Node (P)),
- Name_Assert, Name_Check)
+ and then
+ Pragma_Name_Unmapped (Original_Node (P))
+ in Name_Assert | Name_Check
then
return;
end if;
-- Only process if warnings activated
if Warn_On_Suspicious_Contract then
- if Nkind_In (Par, N_Op_Eq, N_Op_Ne) then
+ if Nkind (Par) in N_Op_Eq | N_Op_Ne then
if N = Left_Opnd (Par) then
Arg := Right_Opnd (Par);
else
B : constant Node_Id := Parent (Parent (Scope (E)));
S : Entity_Id := Empty;
begin
- if Nkind_In (B,
- N_Expression_Function,
- N_Subprogram_Body,
- N_Subprogram_Renaming_Declaration)
+ if Nkind (B) in
+ N_Expression_Function |
+ N_Subprogram_Body |
+ N_Subprogram_Renaming_Declaration
then
S := Corresponding_Spec (B);
end if;
-- When we hit a package/subprogram body, issue warning and exit
- elsif Nkind_In (P, N_Entry_Body,
- N_Package_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ elsif Nkind (P) in N_Entry_Body
+ | N_Package_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
-- Case of assigned value never referenced
-- Give appropriate message, distinguishing between
-- assignment statements and out parameters.
- if Nkind_In (Parent (LA), N_Parameter_Association,
- N_Procedure_Call_Statement)
+ if Nkind (Parent (LA)) in N_Parameter_Association
+ | N_Procedure_Call_Statement
then
Error_Msg_NE
("?m?& modified by call, but value might not be "
-- Give appropriate message, distinguishing between
-- assignment statements and out parameters.
- if Nkind_In (Parent (LA), N_Procedure_Call_Statement,
- N_Parameter_Association)
+ if Nkind (Parent (LA)) in N_Procedure_Call_Statement
+ | N_Parameter_Association
then
Error_Msg_NE
("?m?& modified by call, but value overwritten #!",
-- not generate the warning, since the variable in question
-- may be accessed after an exception in the outer block.
- if not Nkind_In (Parent (P), N_Entry_Body,
- N_Package_Body,
- N_Subprogram_Body,
- N_Task_Body)
+ if Nkind (Parent (P)) not in N_Entry_Body
+ | N_Package_Body
+ | N_Subprogram_Body
+ | N_Task_Body
then
Set_Last_Assignment (Ent, Empty);
return;
UI_From_Int (Int (S) - Int (Sloc (N))));
end Set_End_Location;
- --------------
- -- Nkind_In --
- --------------
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10 or else
- T = V11;
- end Nkind_In;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind;
- V12 : Node_Kind;
- V13 : Node_Kind;
- V14 : Node_Kind;
- V15 : Node_Kind;
- V16 : Node_Kind;
- V17 : Node_Kind) return Boolean
- is
- begin
- return T = V1 or else
- T = V2 or else
- T = V3 or else
- T = V4 or else
- T = V5 or else
- T = V6 or else
- T = V7 or else
- T = V8 or else
- T = V9 or else
- T = V10 or else
- T = V11 or else
- T = V12 or else
- T = V13 or else
- T = V14 or else
- T = V15 or else
- T = V16 or else
- T = V17;
- end Nkind_In;
-
--------------------------
-- Pragma_Name_Unmapped --
--------------------------
-- for the argument. This is Arg itself, or, in the case where Arg is a
-- pragma argument association node, the expression from this node.
- --------------------------------
- -- Node_Kind Membership Tests --
- --------------------------------
-
- -- The following functions allow a convenient notation for testing whether
- -- a Node_Kind value matches any one of a list of possible values. In each
- -- case True is returned if the given T argument is equal to any of the V
- -- arguments. Note that there is a similar set of functions defined in
- -- Atree where the first argument is a Node_Id whose Nkind field is tested.
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind) return Boolean;
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind) return Boolean;
-
- -- 12..16-parameter versions are not yet needed
-
- function Nkind_In
- (T : Node_Kind;
- V1 : Node_Kind;
- V2 : Node_Kind;
- V3 : Node_Kind;
- V4 : Node_Kind;
- V5 : Node_Kind;
- V6 : Node_Kind;
- V7 : Node_Kind;
- V8 : Node_Kind;
- V9 : Node_Kind;
- V10 : Node_Kind;
- V11 : Node_Kind;
- V12 : Node_Kind;
- V13 : Node_Kind;
- V14 : Node_Kind;
- V15 : Node_Kind;
- V16 : Node_Kind;
- V17 : Node_Kind) return Boolean;
-
- pragma Inline (Nkind_In);
- -- Inline all above functions
-
-----------------------
-- Utility Functions --
-----------------------
-- We do not know the actual end location in the generated code and
-- it could be much closer than in the source code, so play safe.
- if Nkind_In (Dump_Node, N_Case_Statement, N_If_Statement) then
+ if Nkind (Dump_Node) in N_Case_Statement | N_If_Statement then
Set_End_Location (Dump_Node, Debug_Sloc + Source_Ptr (Column - 1));
end if;
-- where the aspects are printed inside the package specification.
if Has_Aspects (Node)
- and then not Nkind_In (Node, N_Generic_Package_Declaration,
- N_Package_Declaration)
+ and then Nkind (Node) not in
+ N_Generic_Package_Declaration | N_Package_Declaration
and then not Is_Empty_List (Aspect_Specifications (Node))
then
Sprint_Aspect_Specifications (Node, Semicolon => True);
-- See if we have extra formals
- if Nkind_In (N, N_Function_Specification,
- N_Procedure_Specification)
- then
+ if Nkind (N) in N_Function_Specification | N_Procedure_Specification then
Ent := Defining_Entity (N);
-- Loop to write extra formals (if any)
function OK_Boolean_Operand (N : Node_Id) return Boolean is
begin
- if Nkind_In (N, N_Identifier, N_Expanded_Name) then
+ if Nkind (N) in N_Identifier | N_Expanded_Name then
return True;
elsif Nkind (N) = N_Op_Not then
return OK_Boolean_Operand (Original_Node (Right_Opnd (N)));
- elsif Nkind_In (N, N_Op_And, N_Op_Or) then
+ elsif Nkind (N) in N_Op_And | N_Op_Or then
return OK_Boolean_Operand (Original_Node (Left_Opnd (N)))
and then
OK_Boolean_Operand (Original_Node (Right_Opnd (N)));
Orig : constant Node_Id := Original_Node (Node);
begin
- if Nkind_In (Orig, N_Op_And, N_Op_Or) then
+ if Nkind (Orig) in N_Op_And | N_Op_Or then
declare
L : constant Node_Id := Original_Node (Left_Opnd (Orig));
R : constant Node_Id := Original_Node (Right_Opnd (Orig));
Attribute_Name => Attribute_Name);
begin
- pragma Assert (Nam_In (Attribute_Name, Name_Address,
- Name_Unrestricted_Access));
+ pragma Assert
+ (Attribute_Name in Name_Address | Name_Unrestricted_Access);
Set_Must_Be_Byte_Aligned (N, True);
return N;
end Make_Byte_Aligned_Attribute_Reference;
-- Special case End_Span = Uint5
when F_Field5 =>
- if Nkind_In (N, N_Case_Statement, N_If_Statement) then
+ if Nkind (N) in N_Case_Statement | N_If_Statement then
Print_End_Span (N);
else
Print_Field (Field5 (N), Fmt);
projects / thirdparty / gcc.git / commitdiff
