CbC/CbC_gcc: gcc/ada/libgnarl/s-tassta.adb comparison

comparison gcc/ada/libgnarl/s-tassta.adb @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 --                                                                          --
 --                 S Y S T E M . T A S K I N G . S T A G E S                --
 --                                                                          --
 --                                  B o d y                                 --
 --                                                                          --
---         Copyright (C) 1992-2017, Free Software Foundation, Inc.          --
+--         Copyright (C) 1992-2018, Free Software Foundation, Inc.          --
 --                                                                          --
 -- GNARL is free software; you can  redistribute it  and/or modify it under --
 -- terms of the  GNU General Public License as published  by the Free Soft- --
 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
 --  need to worry about them here. In fact, it would be wrong to abort
 --  indirect dependents here, because we can't distinguish between
 --  duplicate master ids. For example, suppose we have three nested
 --  task bodies T1,T2,T3. And suppose T1 also calls P which calls Q (and
 --  both P and Q are task masters). Q will have the same master id as
---  Master_of_Task of T3. Previous versions of this would abort T3 when
+--  Master_Of_Task of T3. Previous versions of this would abort T3 when
 --  Q calls Complete_Master, which was completely wrong.
 begin
 C := All_Tasks_List;
 while C /= null loop
 P := C.Common.Parent;
 if P = Self_ID then
-if C.Master_of_Task = Self_ID.Master_Within then
+if C.Master_Of_Task = Self_ID.Master_Within then
 pragma Debug
 (Debug.Trace (Self_ID, "Aborting", 'X', C));
 Utilities.Abort_One_Task (Self_ID, C);
 C.Dependents_Aborted := True;
 end if;
 C.Alive_Count := 1;
 P.Awake_Count := P.Awake_Count + 1;
 P.Alive_Count := P.Alive_Count + 1;
 if P.Common.State = Master_Completion_Sleep and then
-C.Master_of_Task = P.Master_Within
+C.Master_Of_Task = P.Master_Within
 then
 pragma Assert (Self_ID /= P);
 P.Common.Wait_Count := P.Common.Wait_Count + 1;
 end if;
 begin
 --  If Master is greater than the current master, it means that Master
 --  has already awaited its dependent tasks. This raises Program_Error,
 --  by 4.8(10.3/2). See AI-280. Ignore this check for foreign threads.
-if Self_ID.Master_of_Task /= Foreign_Task_Level
+if Self_ID.Master_Of_Task /= Foreign_Task_Level
 and then Master > Self_ID.Master_Within
 then
 raise Program_Error with
 "create task after awaiting termination";
 end if;
 --  access type is at library level, so the parent of the Server_Task
 --  is Environment_Task.
 P := Self_ID;
-if P.Master_of_Task <= Independent_Task_Level then
+if P.Master_Of_Task <= Independent_Task_Level then
 P := Environment_Task;
 else
-while P /= null and then P.Master_of_Task >= Master loop
+while P /= null and then P.Master_Of_Task >= Master loop
 P := P.Common.Parent;
 end loop;
 end if;
 Initialization.Defer_Abort_Nestable (Self_ID);
 --  This should not happen, except when a foreign task creates non
 --  library-level Ada tasks. In this case, we pretend the master is
 --  a regular library level task, otherwise the run-time will get
 --  confused when waiting for these tasks to terminate.
-T.Master_of_Task := Library_Task_Level;
+T.Master_Of_Task := Library_Task_Level;
 else
-T.Master_of_Task := Master;
+T.Master_Of_Task := Master;
 end if;
-T.Master_Within := T.Master_of_Task + 1;
+T.Master_Within := T.Master_Of_Task + 1;
 for L in T.Entry_Calls'Range loop
 T.Entry_Calls (L).Self := T;
 T.Entry_Calls (L).Level := L;
 end loop;
 end loop;
 T.Common.Task_Image_Len := Len;
 end if;
---  Note: we used to have code here to initialize T.Commmon.Domain, but
+--  Note: we used to have code here to initialize T.Common.Domain, but
 --  that is not needed, since this is initialized in System.Tasking.
 Unlock (Self_ID);
 Unlock_RTS;
 Created_Task := T;
 Initialization.Undefer_Abort_Nestable (Self_ID);
 pragma Debug
 (Debug.Trace
-(Self_ID, "Created task in " & T.Master_of_Task'Img, 'C', T));
+(Self_ID, "Created task in " & T.Master_Of_Task'Img, 'C', T));
 end Create_Task;
 --------------------
 -- Current_Master --
 --------------------
 return;
 end if;
 Initialization.Defer_Abort_Nestable (Self_ID);
---  Loop through the From chain, changing their Master_of_Task fields,
+--  Loop through the From chain, changing their Master_Of_Task fields,
 --  and to find the end of the chain.
 loop
-C.Master_of_Task := New_Master;
+C.Master_Of_Task := New_Master;
 exit when C.Common.Activation_Link = null;
 C := C.Common.Activation_Link;
 end loop;
 --  Hook From in at the start of To
 begin
 pragma Assert (Self_ID.Deferral_Level = 1);
 Debug.Master_Hook
-(Self_ID, Self_ID.Common.Parent, Self_ID.Master_of_Task);
+(Self_ID, Self_ID.Common.Parent, Self_ID.Master_Of_Task);
 if Use_Alternate_Stack then
 Self_ID.Common.Task_Alternate_Stack := Task_Alternate_Stack'Address;
 end if;
 --  Independent tasks should not call the Fall_Back_Handler (of the
 --  environment task), because they are implementation artifacts that
 --  should be invisible to Ada programs.
-elsif Self_ID.Master_of_Task /= Independent_Task_Level then
+elsif Self_ID.Master_Of_Task /= Independent_Task_Level then
 --  Look for a fall-back handler following the master relationship
 --  for the task. As specified in ARM C.7.3 par. 9/2, "the fall-back
 --  handler applies only to the dependent tasks of the task". Hence,
 --  if the terminating tasks (Self_ID) had a fall-back handler, it
 --  the data of the new task that reused the ATCB. To solve this problem, we
 --  introduced the new operation Final_Task_Unlock.
 procedure Terminate_Task (Self_ID : Task_Id) is
 Environment_Task : constant Task_Id := STPO.Environment_Task;
-Master_of_Task   : Integer;
+Master_Of_Task   : Integer;
 Deallocate       : Boolean;
 begin
 Debug.Task_Termination_Hook;
 if Single_Lock then
 Lock_RTS;
 end if;
-Master_of_Task := Self_ID.Master_of_Task;
+Master_Of_Task := Self_ID.Master_Of_Task;
 --  Check if the current task is an independent task If so, decrement
 --  the Independent_Task_Count value.
-if Master_of_Task = Independent_Task_Level then
+if Master_Of_Task = Independent_Task_Level then
 if Single_Lock then
 Utilities.Independent_Task_Count :=
 Utilities.Independent_Task_Count - 1;
 else
 if Deallocate then
 Free_Task (Self_ID);
 end if;
-if Master_of_Task > 0 then
+if Master_Of_Task > 0 then
 STPO.Exit_Task;
 end if;
 end Terminate_Task;
 ----------------
 Write_Lock (Self_ID);
 C := All_Tasks_List;
 while C /= null loop
-if C.Common.Activator = Self_ID and then C.Master_of_Task = CM then
+if C.Common.Activator = Self_ID and then C.Master_Of_Task = CM then
 return False;
 end if;
-if C.Common.Parent = Self_ID and then C.Master_of_Task = CM then
+if C.Common.Parent = Self_ID and then C.Master_Of_Task = CM then
 Write_Lock (C);
 if C.Common.State = Unactivated then
 return False;
 end if;
 C := All_Tasks_List;
 while C /= null loop
 --  Terminate unactivated (never-to-be activated) tasks
-if C.Common.Activator = Self_ID and then C.Master_of_Task = CM then
+if C.Common.Activator = Self_ID and then C.Master_Of_Task = CM then
---  Usually, C.Common.Activator = Self_ID implies C.Master_of_Task
+--  Usually, C.Common.Activator = Self_ID implies C.Master_Of_Task
 --  = CM. The only case where C is pending activation by this
 --  task, but the master of C is not CM is in Ada 2005, when C is
 --  part of a return object of a build-in-place function.
 pragma Assert (C.Common.State = Unactivated);
 Unlock (C);
 end if;
 --  Count it if directly dependent on this master
-if C.Common.Parent = Self_ID and then C.Master_of_Task = CM then
+if C.Common.Parent = Self_ID and then C.Master_Of_Task = CM then
 Write_Lock (C);
 if C.Awake_Count /= 0 then
 Self_ID.Common.Wait_Count := Self_ID.Common.Wait_Count + 1;
 end if;
 Write_Lock (Self_ID);
 C := All_Tasks_List;
 while C /= null loop
-if C.Common.Parent = Self_ID and then C.Master_of_Task = CM then
+if C.Common.Parent = Self_ID and then C.Master_Of_Task = CM then
 Write_Lock (C);
 pragma Assert (C.Awake_Count = 0);
 if C.Alive_Count > 0 then
 --  task free itself if not already done, otherwise we risk a race
 --  condition where Vulnerable_Free_Task is called in the loop below,
 --  while the task calls Free_Task itself, in Terminate_Task.
 if C.Common.Parent = Self_ID
-and then C.Master_of_Task >= CM
+and then C.Master_Of_Task >= CM
 and then not C.Free_On_Termination
 then
 if P /= null then
 P.Common.All_Tasks_Link := C.Common.All_Tasks_Link;
 else
 end;
 end if;
 if (T.Common.Parent /= null
 and then T.Common.Parent.Common.Parent /= null)
-or else T.Master_of_Task > Library_Task_Level
+or else T.Master_Of_Task > Library_Task_Level
 then
 Initialization.Task_Lock (Self_ID);
 --  If Sec_Stack_Ptr is not null, it means that Destroy_TSD
 --  has not been called yet (case of an unactivated task).
 (Self_ID.Deferral_Level > 0
 or else not System.Restrictions.Abort_Allowed);
 pragma Assert (Self_ID = Self);
 pragma Assert
 (Self_ID.Master_Within in
-Self_ID.Master_of_Task + 1 ..  Self_ID.Master_of_Task + 3);
+Self_ID.Master_Of_Task .. Self_ID.Master_Of_Task + 3);
 pragma Assert (Self_ID.Common.Wait_Count = 0);
 pragma Assert (Self_ID.Open_Accepts = null);
 pragma Assert (Self_ID.ATC_Nesting_Level = 1);
 pragma Debug (Debug.Trace (Self_ID, "V_Complete_Task", 'C'));
 if Single_Lock then
 Unlock_RTS;
 end if;
---  If Self_ID.Master_Within = Self_ID.Master_of_Task + 2 we may have
+--  If Self_ID.Master_Within = Self_ID.Master_Of_Task + 2 we may have
 --  dependent tasks for which we need to wait. Otherwise we just exit.
-if Self_ID.Master_Within = Self_ID.Master_of_Task + 2 then
+if Self_ID.Master_Within = Self_ID.Master_Of_Task + 2 then
 Vulnerable_Complete_Master (Self_ID);
 end if;
 end Vulnerable_Complete_Task;
 --------------------------

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ada/libgnarl/s-tassta.adb @ 131:84e7813d76e9