-- Move to next subscript
- Sub := Next (Sub);
+ Next (Sub);
end loop;
end Apply_Subscript_Validity_Checks;
exit;
end if;
- Result := Next (Result);
+ Next (Result);
end loop;
return Result;
if No_Initialization (Decl) then
if No (Expression (Last_Init)) then
loop
- Last_Init := Next (Last_Init);
+ Next (Last_Init);
exit when No (Last_Init);
exit when Nkind (Last_Init) = N_Object_Declaration
and then Nkind (Expression (Last_Init)) = N_Reference
if Present (First_Formal (Iface_Op))
and then Is_Controlling_Formal (First_Formal (Iface_Op))
then
- Iface_Op_Param := Next (Iface_Op_Param);
+ Next (Iface_Op_Param);
end if;
Wrapper_Param := First (Wrapper_Params);
if Is_Private_Primitive_Subprogram (Subp_Id)
and then not Has_Controlling_Result (Subp_Id)
then
- Formal := Next (Formal);
+ Next (Formal);
end if;
while Present (Formal) loop
begin
while Next (Nod) /= After loop
- Nod := Next (Nod);
+ Next (Nod);
end loop;
return Nod;
and then (Nkind (Context_Item) /= N_With_Clause
or else Limited_Present (Context_Item))
loop
- Context_Item := Next (Context_Item);
+ Next (Context_Item);
end loop;
if Present (Context_Item) then
Write_Eol;
end if;
- Context_Item := Next (Context_Item);
+ Next (Context_Item);
end loop;
Outdent;
N := F;
loop
Set_List_Link (N, To);
- N := Next (N);
+ Next (N);
exit when No (N);
end loop;
loop
Set_List_Link (N, LC);
exit when N = L;
- N := Next (N);
+ Next (N);
end loop;
if Present (Before) then
loop
Set_List_Link (N, LC);
exit when N = L;
- N := Next (N);
+ Next (N);
end loop;
if Present (After) then
Node := First (List);
while Present (Node) loop
Result := Result + 1;
- Node := Next (Node);
+ Next (Node);
end loop;
return Result;
while Present (E) loop
Append (New_Copy (E), NL);
- E := Next (E);
+ Next (E);
end loop;
return NL;
Append (New_Copy (E), NL);
end if;
- E := Next (E);
+ Next (E);
end loop;
return NL;
begin
N := Node;
loop
- N := Next (N);
+ Next (N);
exit when not Nkind_In (N, N_Pragma, N_Null_Statement);
end loop;
begin
Elmt := First (List);
for J in 1 .. Index - 1 loop
- Elmt := Next (Elmt);
+ Next (Elmt);
end loop;
return Elmt;
Action (Lib_Unit);
end if;
- Context_Item := Next (Context_Item);
+ Next (Context_Item);
end loop;
end Walk_Withs_Immediate;
raise Unrecoverable_Error;
end if;
- Assoc := Next (Assoc);
+ Next (Assoc);
end loop;
end;
end if;
Param := First (Parameter_Specifications (Def));
while Present (Param) loop
Check_For_Premature_Usage (Parameter_Type (Param));
- Param := Next (Param);
+ Next (Param);
end loop;
end if;
-- rest of the parameters.
if not In_Scope then
- Prim_Param := Next (Prim_Param);
+ Next (Prim_Param);
end if;
- Iface_Param := Next (Iface_Param);
+ Next (Iface_Param);
while Present (Iface_Param) and then Present (Prim_Param) loop
Iface_Id := Defining_Identifier (Iface_Param);
Iface_Typ := Find_Parameter_Type (Iface_Param);
return True;
end if;
- Clause := Next (Clause);
+ Next (Clause);
end loop;
return False;
-- Skip the symbol expression when present
if Present (Symbol_Expr) and then Num_Choices = 0 then
- Expr := Next (Expr);
+ Next (Expr);
end if;
Position := Low_Position_Bound;
Expr := Next (First (Expressions (Disc_Exp)));
if Present (Expr) then
Check_Allocator_Discrim_Accessibility_Exprs (Expr, Alloc_Typ);
- Expr := Next (Expr);
+ Next (Expr);
if Present (Expr) then
Check_Allocator_Discrim_Accessibility_Exprs
(Expr, Alloc_Typ);
end loop;
end if;
- Alt := Next (Alt);
+ Next (Alt);
end loop;
end;
end if;
return Entity (Expression (Assoc));
end if;
- Assoc := Next (Assoc);
+ Next (Assoc);
end loop;
return Empty;
Defining_Identifier (Decl));
end if;
- Decl := Next (Decl);
+ Next (Decl);
end loop;
end Inspect_Deferred_Constant_Completion;
while Present (E) loop
Append (New_Copy_Tree (E), NL);
- E := Next (E);
+ Next (E);
end loop;
return NL;
begin
for Idx in Result'Range loop
Result (Idx) := Chosen_Interval (Range_Or_Expr);
- Range_Or_Expr := Next (Range_Or_Expr);
+ Next (Range_Or_Expr);
end loop;
pragma Assert (not Present (Range_Or_Expr));
Check_Consistency (Result);
Count := Count + 1; -- an ordinary expression or range
end if;
- Choice := Next (Choice);
+ Next (Choice);
end loop;
return Count;
end Unmerged_Choice_Count;
while Present (Others_Choice) loop
Count := Count + 1;
Result (Count) := Chosen_Interval (Others_Choice);
- Others_Choice := Next (Others_Choice);
+ Next (Others_Choice);
end loop;
end;
else
Count := Count + 1;
Result (Count) := Chosen_Interval (Choice);
end if;
- Choice := Next (Choice);
+ Next (Choice);
end loop;
pragma Assert (Count = Result'Last);
Normalize_Interval_List (Result, Count);
return;
end if;
- X := Next (X);
+ Next (X);
end loop;
end if;
end if;