pragma Assert (not No_Dynamic_Accessibility_Checks_Enabled (N));
if Ada_Version >= Ada_2012
- and then not Present (Param_Ent)
+ and then No (Param_Ent)
and then Is_Entity_Name (N)
and then Ekind (Entity (N)) in E_Constant | E_Variable
and then Present (Effective_Extra_Accessibility (Entity (N)))
-- Note: Expr is empty if the address-clause is applied to in-mode
-- actuals (allowed by 13.1(22)).
- if not Present (Expr)
+ if No (Expr)
or else
(Is_Entity_Name (Expression (AC))
and then Ekind (Entity (Expression (AC))) = E_Constant
if not Is_Predefined_Dispatching_Operation (Prim)
and then not Is_Predefined_Dispatching_Operation (E)
- and then not Present (Interface_Alias (Prim))
+ and then No (Interface_Alias (Prim))
and then not Is_Abstract_Subprogram (E)
and then not Is_Eliminated (E)
and then Prim_Pos <= CPP_Nb_Prims
-- If Storage_Size wasn't found (can only occur in the simple
-- storage pool case), then simply use zero for the result.
- if not Present (Alloc_Op) then
+ if No (Alloc_Op) then
Rewrite (N, Make_Integer_Literal (Loc, 0));
-- Otherwise, rewrite the allocator as a call to pool type's
-- Skip this for predicated types, where such expressions are a
-- reasonable way of testing if something meets the predicate.
- and then not Present (Predicate_Function (Ltyp))
+ and then No (Predicate_Function (Ltyp))
then
Substitute_Valid_Check;
return;
if Is_Entity_Name (Lop) then
Expr_Entity := Param_Entity (Lop);
- if not Present (Expr_Entity) then
+ if No (Expr_Entity) then
Expr_Entity := Entity (Lop);
end if;
end if;
-- If no return object is provided, then pass null
- if not Present (Return_Object) then
+ if No (Return_Object) then
Obj_Address := Make_Null (Loc);
Set_Parent (Obj_Address, Function_Call);
loop
Aspect_Bearer := Nearest_Ancestor (Aspect_Bearer);
- if not Present (Aspect_Bearer) then
+ if No (Aspect_Bearer) then
return False;
end if;
begin
if Is_Derived_Type (Typ)
and then Comes_From_Source (E)
- and then not Present (Overridden_Operation (E))
+ and then No (Overridden_Operation (E))
then
-- We know that the explicit operation on the type does not override
-- the inherited operation of the parent, and that the derivation
| N_Identifier
=>
if No (Entity (Ren))
- or else not Present (Renamed_Entity_Or_Object (Entity (Ren)))
+ or else No (Renamed_Entity_Or_Object (Entity (Ren)))
then
exit;
end if;
and then not Is_Abstract_Subprogram (Prim)
and then not Is_Eliminated (Prim)
and then not Generate_SCIL
- and then not
- Present (Prim_Table (UI_To_Int (DT_Position (Prim))))
+ and then No (Prim_Table (UI_To_Int (DT_Position (Prim))))
then
if not Build_Thunks then
E := Ultimate_Alias (Prim);
E : Entity_Id;
begin
- if not Present (Def)
+ if No (Def)
or else Entity (Name (Def)) /= First_Subtype (Typ)
then
New_Node :=
and then not Is_Abstract_Subprogram (Prim)
and then not Is_Eliminated (Prim)
and then not Generate_SCIL
- and then not Present (Prim_Table
- (UI_To_Int (DT_Position (Prim))))
+ and then No (Prim_Table (UI_To_Int (DT_Position (Prim))))
then
E := Ultimate_Alias (Prim);
pragma Assert (not Is_Abstract_Subprogram (E));
-- those are only required to build secondary dispatch
-- tables.
- and then not Present (Interface_Alias (Prim))
+ and then No (Interface_Alias (Prim))
-- Skip abstract and eliminated primitives
-- Primitive associated with a tagged type
- if not Present (Interface_Alias (Prim)) then
+ if No (Interface_Alias (Prim)) then
Tag_Typ := Scope (DTC_Entity (Prim));
Pos := DT_Position (Prim);
Tag := First_Tag_Component (Tag_Typ);
-- same dispatch table slot, but if it renames an operation in a
-- nested package it's a new primitive and will have its own slot.
- elsif not Present (Interface_Alias (Prim))
+ elsif No (Interface_Alias (Prim))
and then Present (Alias (Prim))
and then Chars (Prim) = Chars (Alias (Prim))
and then Nkind (Unit_Declaration_Node (Prim)) /=
and then Present (Alias (Prim))
and then not Is_Interface
(Find_Dispatching_Type (Ultimate_Alias (Prim)))
- and then not Present (Interface_Alias (Prim))
+ and then No (Interface_Alias (Prim))
and then Is_Derived_Type (Typ)
and then In_Private_Part (Current_Scope)
and then
if No (UPJ.Ref)
or else not Is_Entity_Name (UPJ.Ref)
- or else not Present (Entity (UPJ.Ref))
+ or else No (Entity (UPJ.Ref))
or else not Opt.Generate_C_Code
then
goto Continue;
-- type attributes.
begin
- if not Present (Priv_Typ) and then not Present (Full_Typ) then
+ if No (Priv_Typ) and then No (Full_Typ) then
return;
end if;
-- full type doesn't have its own DIC, but is inherited from
-- a type with DIC), get the full DIC procedure.
- if not Present (Par_Proc) then
+ if No (Par_Proc) then
Par_Proc := DIC_Procedure (Par_Typ);
end if;
-- type attributes.
begin
- if not Present (Priv_Typ) and then not Present (Full_Typ) then
+ if No (Priv_Typ) and then No (Full_Typ) then
return;
end if;
Prag_Typ_Arg : Node_Id;
begin
- if not Present (T) then
+ if No (T) then
return;
end if;
-- Set component size if not already set by a component
-- size clause.
- if not Present (Comp_Size_C) then
+ if No (Comp_Size_C) then
Set_Component_Size (Arr, Csiz);
end if;
-- explicitly, then generate a warning.
if Has_Pragma_Pack (Arr)
- and then not Present (Comp_Size_C)
+ and then No (Comp_Size_C)
and then (Csiz = 7 or else Csiz = 15 or else Csiz = 31)
and then Known_Esize (Base_Type (Ctyp))
and then Esize (Base_Type (Ctyp)) = Csiz + 1
-- end of a declarative part.
if Is_Library_Level_Tagged_Type (E)
- and then not Present (Full_View (E))
+ and then No (Full_View (E))
then
Set_Is_Frozen (E, False);
goto Leave;
-- If no formal is passed in, then issue an error for a
-- missing formal.
- elsif not Present (Pool_Op_Formal) then
+ elsif No (Pool_Op_Formal) then
Error_Msg_NE
("simple storage pool op missing formal " &
Formal_Name & " of type&", Pool_Op, Expected_Type);
-- and no excess formals are present, then this
-- operation has been validated, so record it.
- if not Present (Formal) and then Is_OK then
+ if No (Formal) and then Is_OK then
Found_Op := Op;
end if;
end if;
-- so issue an error if none was found.
if Op_Name = Name_Allocate
- and then not Present (Found_Op)
+ and then No (Found_Op)
then
Error_Msg_N ("missing % operation for simple " &
"storage pool type", Pool_Type);
if Is_Array_Type (E)
and then Present (First_Index (E)) -- Skip types in error
and then Number_Dimensions (E) = 1
- and then not Present (Packed_Array_Impl_Type (E))
+ and then No (Packed_Array_Impl_Type (E))
and then Has_Pragma_Pack (E)
and then Is_Constrained (E)
and then Compile_Time_Known_Bounds (E)
Num : Natural := 1) return String
is
begin
- if not Present (List) then
+ if No (List) then
if First or else not Add_Paren then
return "";
else
-- is not prepared to deal with a zero-length result.
elsif Null_Record_Present (Expr)
- or else not Present (First (Component_Associations (Expr)))
+ or else No (First (Component_Associations (Expr)))
then
return ("(null record)");
-- Load unit if unit not previously loaded
- if not Present (U.Entity) then
+ if No (U.Entity) then
Load_RTU (U_Id, Id => E);
end if;
E1 := First_Entity (Pkg_Ent);
while Present (E1) loop
if Ename = Chars (E1) then
- pragma Assert (not Present (Found_E));
+ pragma Assert (No (Found_E));
Found_E := E1;
end if;
-- duplicate the expression tree to analyze the copy and
-- perform the required check.
- elsif not Present (Etype (Expression (Assoc))) then
+ elsif No (Etype (Expression (Assoc))) then
declare
Save_Analysis : constant Boolean := Full_Analysis;
Expr : constant Node_Id :=
-- Ignore hidden components associated with the position of the
-- interface tags: these are initialized dynamically.
- if not Present (Related_Type (Component)) then
+ if No (Related_Type (Component)) then
Error_Msg_NE
("no value supplied for component &!", N, Component);
end if;
-- type to the pool object's type.
else
- if not Present (Get_Rep_Pragma (Etype (Entity (N)),
+ if No (Get_Rep_Pragma (Etype (Entity (N)),
Name_Simple_Storage_Pool_Type))
then
Error_Attr_P
begin
while Present (Comp) loop
if Chars (First (Choices (Comp))) = Orig_Name then
- pragma Assert (not Present (Matching_Comp));
+ pragma Assert (No (Matching_Comp));
Matching_Comp := Comp;
end if;
-- a full view, then we'll retrieve that.
if Ekind (A_Gen_T) = E_Incomplete_Type
- and then not Present (Full_View (Act_T))
+ and then No (Full_View (Act_T))
then
null;
| Aspect_Full_Access_Only
| Aspect_Import
and then (A_Id /= Aspect_Preelaborable_Initialization
- or else not Present (Expression (ASN)))
+ or else No (Expression (ASN)))
then
Make_Pragma_From_Boolean_Aspect (ASN);
end if;
if not Is_Entity_Name (Expression (ASN))
or else not Is_Object (Entity (Expression (ASN)))
or else
- not Present (Find_Aspect (Etype (Expression (ASN)),
+ No (Find_Aspect (Etype (Expression (ASN)),
Aspect_Storage_Model_Type))
then
Error_Msg_N
-- aspects are replaced with pragmas at the freeze point in
-- Make_Pragma_From_Boolean_Aspect.
- if not Present (Expr)
+ if No (Expr)
or else Is_True (Static_Boolean (Expr))
then
if A_Id = Aspect_Import then
else
Analyze_And_Resolve (Expr);
- if not Present (Get_Rep_Pragma
+ if No (Get_Rep_Pragma
(Etype (Expr), Name_Simple_Storage_Pool_Type))
then
Error_Msg_N
begin
for FP of Profiles loop
- if not Present (Formal) then
+ if No (Formal) then
Is_Error := True;
Report_Argument_Error ("missing formal of }", Subt => FP.Subt);
exit;
-- If Addr_Type is not present as the first association, then we default
-- it to System.Address.
- elsif not Present (Addr_Type) then
+ elsif No (Addr_Type) then
Addr_Type := RTE (RE_Address);
end if;
Param_Type := Standard_String;
end if;
- if not Overloaded and then not Present (Entity (Func_Name)) then
+ if not Overloaded and then No (Entity (Func_Name)) then
-- The aspect is specified by a subprogram name, which
-- may be an operator name given originally by a string.
-- Is_Conjunction_Of_Formal_Preelab_Init_Attributes goes to
-- Original_Node if needed, hence test for Standard_False.)
- if not Present (Expr)
+ if No (Expr)
or else (Is_Entity_Name (Expr)
and then Entity (Expr) = Standard_True)
or else
-- with the aliased entity (otherwise we generate a duplicated
-- error message).
- and then not Present (Interface_Alias (Subp))
+ and then No (Interface_Alias (Subp))
then
if Present (Alias_Subp) then
-- in various places for an Empty upper bound, and in any case it
-- accurately characterizes the index's range of values.
- if Nkind (S) = N_Range and then not Present (High_Bound (S)) then
+ if Nkind (S) = N_Range and then No (High_Bound (S)) then
Is_FLB_Index := True;
Set_High_Bound (S, Type_High_Bound (T));
end if;
-- have such primitives.
if Present (Generic_Actual)
- and then not Present (Act_Subp)
+ and then No (Act_Subp)
and then Is_Limited_Interface (Parent_Base)
and then Is_Predefined_Interface_Primitive (Subp)
then
if Ekind (Comp_Id) = E_Component
and then Nkind (Parent (Comp_Id))
= N_Component_Declaration
- and then
- not Present (Expression (Parent (Comp_Id)))
+ and then No (Expression (Parent (Comp_Id)))
then
return True;
end if;
elsif Warn_On_Redundant_Constructs
and then not Is_Dispatching_Operation (Subp_Id)
- and then not Present (Overridden_Operation (Subp_Id))
+ and then No (Overridden_Operation (Subp_Id))
and then (not Is_Operator_Symbol_Name (Chars (Subp_Id))
or else Scop /= Scope (Etype (First_Formal (Subp_Id))))
then
-- an instance that may have manipulated the flag during
-- expansion. As a result, we add an exception for this case.
- elsif not Present (Overridden_Operation (Spec_Id))
+ elsif No (Overridden_Operation (Spec_Id))
and then not (Chars (Spec_Id) in Name_Adjust
| Name_Finalize
| Name_Initialize
Error_Msg_Sloc := Sloc (Op);
if Comes_From_Source (Op) or else No (Alias (Op)) then
- if not Present (Overridden_Operation (Op)) then
+ if No (Overridden_Operation (Op)) then
Error_Msg_N ("\\primitive % defined #", Typ);
else
Error_Msg_N
or else not Is_Overloadable (Subp)
or else not Is_Primitive (Subp)
or else not Is_Dispatching_Operation (Subp)
- or else not Present (Find_Dispatching_Type (Subp))
+ or else No (Find_Dispatching_Type (Subp))
or else not Is_Interface (Find_Dispatching_Type (Subp))
then
null;
return False;
end if;
- if not Present (Partial_View) then
+ if No (Partial_View) then
return True;
end if;
begin
loop
H := Homonym (H);
- exit when not Present (H) or else Scope (H) /= Scope (S);
+ exit when No (H) or else Scope (H) /= Scope (S);
if Nkind (Parent (H)) in
N_Private_Extension_Declaration |
if ((Present (Partial_View)
and then Is_Tagged_Type (Partial_View))
- or else (not Present (Partial_View)
+ or else (No (Partial_View)
and then Is_Tagged_Type (T)))
and then T = Base_Type (Etype (S))
then
-- No need to continue if we already notified errors
- if not Present (Formal_Type) then
+ if No (Formal_Type) then
return;
end if;
Set_Etype (Nam, T);
end if;
elsif Present (Subtype_Mark (N))
- or else not Present (Access_Definition (N))
+ or else No (Access_Definition (N))
then
if Present (Subtype_Mark (N)) then
Find_Type (Subtype_Mark (N));
-- want to deal with AST_Handler in ZFP mode.
if not Configurable_Run_Time_Mode
- and then not Present (Corresponding_Formal_Spec (N))
+ and then No (Corresponding_Formal_Spec (N))
and then not Is_RTE (Etype (Nam), RE_AST_Handler)
then
declare
Scope1 := Scope (Scope1);
Scope2 := Scope (Scope2);
- if not Present (Scope1) then
+ if No (Scope1) then
return Clause1;
- elsif not Present (Scope2) then
+ elsif No (Scope2) then
return Clause2;
end if;
end loop;
-- Look at the named components right after the positional components
- if not Present (Next (Comp))
+ if No (Next (Comp))
and then List_Containing (Comp) = Exps
then
Comp := First (Comp_Ass);
-- aspect/pragma from parent types (see Build_DIC_Procedure_Body),
-- though that extra argument isn't documented for the pragma.
- if not Present (Arg2) then
+ if No (Arg2) then
-- When the pragma has no arguments, create an argument with
-- the value Empty, so the type name argument can be appended
-- following it (since it's expected as the second argument).
- if not Present (Arg1) then
+ if No (Arg1) then
Set_Pragma_Argument_Associations (N, New_List (
Make_Pragma_Argument_Association (Sloc (Typ),
Expression => Empty)));
-- been generated when one should have ???
elsif Is_Formal (E)
- and then not Present (Get_Dynamic_Accessibility (E))
+ and then No (Get_Dynamic_Accessibility (E))
and then Ekind (Etype (E)) = E_Anonymous_Access_Type
then
return Make_Level_Literal (Scope_Depth (Standard_Standard));
end if;
return
- not Present (Etype (Constr)) -- previous error
+ No (Etype (Constr)) -- previous error
or else not Is_Discrete_Type (Etype (Constr))
or else Is_OK_Static_Expression (Constr);
pragma Assert (Present (Ifc_Ancestors (Idx)));
Ifc := Next (Ifc);
end loop;
- pragma Assert (not Present (Ifc));
+ pragma Assert (No (Ifc));
if Present (Parent_Type) then
return Parent_Type & Ifc_Ancestors;
else
-- entry families with no Max_Queue_Length aspect or pragma default to
-- it.
- if not Present (Prag) then
+ if No (Prag) then
return Uint_0;
end if;
Typ := Corresponding_Record_Type (Typ);
end if;
- if not Present (Typ)
+ if No (Typ)
or else not Is_Record_Type (Typ)
or else not Is_Tagged_Type (Typ)
then
return True;
elsif Present (Variant_Part (Component_List (Record_Def))) then
return False;
- elsif not Present (Component_List (Record_Def)) then
+ elsif No (Component_List (Record_Def)) then
return True;
end if;
Next (Range_Or_Expr);
end loop;
- pragma Assert (not Present (Range_Or_Expr));
+ pragma Assert (No (Range_Or_Expr));
Check_Consistency (Result);
return Result;
end;
and then Is_Non_Empty_List (Alternatives (Par))
and then Trailer /= First (Alternatives (Par))
then
- pragma Assert (not Present (Right_Opnd (Par)));
+ pragma Assert (No (Right_Opnd (Par)));
pragma Assert
(Is_List_Member (Trailer)
and then List_Containing (Trailer)
if Ekind (Form) = E_Out_Parameter
and then Never_Set_In_Source_Check_Spec (Form)
and then Is_Scalar_Type (Etype (Form))
- and then not Present (Unset_Reference (Form))
+ and then No (Unset_Reference (Form))
then
-- Here all conditions are met, record possible unset reference