In this article, we are going to cover the SETIMR system service, which was used in the code we covered in the previous article. First, the user documentation.

function Set_Timer( efn, time, astafr, reqidt, flags : int64 ) : int64 ;

begin
    Result := SYS_SETIMR( efn, int64( @time ), astafr, int64( @reqidt ), int64( @Flags ) ) ;
end ;

function SYS_SETIMR( efn, tim : int64 ; astadr : int64 = 0 ;
    reqidt : int64 = 0 ; flags : int64 = 0 ) : int64 ;

var Status : int64 ;
    SysRequest : TInteger5_Request ;
    Sname : PSRB ;

begin
    Status := 0 ;
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_SSC ;
    SysRequest.Request.Request := UOS_SSC_Setimr ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( TSystem_Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    SysRequest.Int1 := efn ;
    SysRequest.Int2 := tim ;
    SysRequest.Int3 := astadr ;
    SysRequest.Int4 := reqidt ;
    SysRequest.Int5 := flags ;

    Call_To_Ring0( integer( @SysRequest ) ) ;

    Result := Status ;
end ;

        UOS_SSC_Setimr:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC, sizeof( TInteger5_Request ) - 
                    sizeof( TSystem_Request ), Base ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;

                try
                    Integer5_Request := PInteger5_Request( Base ) ;
                    PS2I3.Request.Status := Set_Timer( PID, Integer5_Request.Int1,
                            Integer5_Request.Int2, Integer5_Request.Int3,
                            Integer5_Request.Int4, Integer5_Request.Int5 ) ;
                finally
                    Exit_System_Call( Base, PID, MMC, sizeof( TS2I3_Request ) ) ;
                end ;
            end ;

function TUOS_SSC.Set_Timer( PID : TPID ; efn, time, astadr, reqidt, flags : int64 ) : int64 ;

var Status : integer ;

begin
    // Get and validate parameters...
    if( ( efn < 0 ) or ( efn > 128 ) ) then
    begin
        Result := SS_ILLEFC ;
        exit ;
    end ;
    if( Time <> 0 ) then
    begin
        Time := Get_User_Integer( Kernel, PID, Time, Status ) ;
        if( Status = UE_Error ) then // Error reading user value
        begin
            Result := Status ;
            exit ;
        end ;
    end ;
    if( reqidt <> 0 ) then
    begin
        reqidt := Get_User_Integer( Kernel, PID, reqidt, Status ) ;
        if( Status = UE_Error ) then // Error reading user value
        begin
            Result := Status ;
            exit ;
        end ;
    end ;
    if( Flags <> 0 ) then
    begin
        Flags := Get_User_Integer( Kernel, PID, Flags, Status ) ;
        if( Status = UE_Error ) then // Error reading user value
        begin
            Result := Status ;
            exit ;
        end ;
    end ;
    if( ( Flags <> 0 ) and ( Flags <> 1 ) ) then
    begin
        Result := Generate_Exception( SS_ILLEFC ) ;
        exit ;
    end ;
    if( USC.Check_Quota( PID, Quota_ENQLM, 1 ) ) then
    begin
        Result := Generate_Exception( UOSErr_Quota_Exceeded ) ;
        exit ;
    end ;
    if( ( Flags and 1 ) <> 0 ) then
    begin
        Time := Kernel.HAL.Timestamp + Kernel.HAL.CPU_Time_Quantum ;
    end ;
    
    Kernel.USC.Reset_EF( PID, efn ) ; // Clear the event flag

    // Create timer...
    Create_Timer( 0, Time, efn, astadr, reqidt ) ;
end ; // TUOS_SSC.Set_Timer

Finally we reset the requested flag and create the timer. We will look at Reset_EF in a bit, but first we need to look at the changes we made to the timer.

var _Timers : TList = nil ;

function Timers : TList ;

begin
    if( _Timers = nil ) then
    begin
        _Timers := TList.Create ;
    end ;
    Result := _Timers ;
end ;

type TUOS_Timer = class( TGeneric_Timer )
                      public // Constructor and destructor...
                          constructor Create ;
                          destructor Destroy ; override ;

                      public // API...
                          function Get_PID : TPID ; override ;
                          procedure Set_PID( Value : TPID ) ; override ;

                      public // API...
                          Context : int64 ;
                          Time : int64 ;
                          EFC, EFB : integer ; // Event flag cluster, bit
                          AST : int64 ;
                          Reqidt : int64 ;
                          _PID : TPID ;
                  end ;


constructor TUOS_Timer.Create ;

begin
    inherited Create ;

    EFC := -1 ; // Disable event flag handling by default
    // Note: We do not add ourselves to the list because the list is in sorted order.
    // The insertion is done by the code that creates the timer.
end ;


destructor TUOS_Timer.Destroy ;

begin
    Timers.Remove( self ) ;

    inherited Destroy ;
end ;


// API...

function TUOS_Timer.Get_PID : TPID ;

begin
    Result := _PID ;
end ;


procedure TUOS_Timer.Set_PID( Value : TPID ) ;

begin
    _PID := Value ;
end ;

type TGeneric_Timer = class
                      public // Destructor...
                          destructor Destroy ;
                              virtual ; abstract ;

                      public // API...
                          function Get_PID : TPID ;
                              virtual ; stdcall ; abstract ;
                          procedure Set_PID( Value : TPID ) ;
                              virtual ; stdcall ; abstract ;

                      public // Properties...
                          property PID : TPID
                              read Get_PID
                              write Set_PID ;
                  end ;

function TUOS_SSC.Create_Timer( Context, Time : int64 ; efn : int64 = -1 ;
    astadr : int64 = 0 ; reqidt : int64 = 0 ) : int64 ;

var I : integer ;
    Timer, tTimer : TUOS_Timer ;

begin
    // Create the timer...
    Timer := TUOS_Timer.Create ;
    Result := int64( Timer ) ;
    Timer.Context := Context ;
    if( efn > 128 ) then
    begin
        efn := -1 ;
    end ;
    if( efn >= 0 ) then
    begin
        Timer.EFC := efn shr 5 ;
        Timer.EFB := efn and 31 ;
        Timer.EFB := 1 shl Timer.EFB ;
    end ;
    Timer.PID := Kernel.PID ;
    Timer.AST := astadr ;
    Timer.Reqidt := reqidt ;
    Timer.Time := Time ;

    // Insert into queue...
    for I := 0 to Timers.Count - 1 do
    begin
        tTimer := TUOS_Timer( _Timers[ I ] ) ;
        if( Time < tTimer.Time ) then
        begin
            _Timers.Insert( I, Timer ) ;
            exit ;
        end ;
    end ;
    Timers.Add( Timer ) ; // Goes at end of the list
end ; // TUOS_SSC.Create_Timer

procedure TUSC.Reset_EF( PID : TPID ; efn : cardinal ) ;

var Bit, EF, EFC : integer ;
    P : TProcess ;

begin
    P := Get_Process( PID ) ;
    if( P = nil ) then // Process doesn't exist
    begin
        exit ;
    end ;
    if( ( efn < 0 ) or ( efn > 128 ) ) then
    begin
        exit ;
    end ;
    EFC := efn shr 5 ; // Event flag cluster
    EF := efn and 31 ; // Event flag within cluster
    Bit := 1 shl EF ; // Convert to bit flag
    P.Event_Flags[ EFC ] := P.Event_Flags[ EFC ] and ( not Bit ) ;
end ;

procedure TUSC._Delete_Process( TargetPID : TPID ) ;

var I : integer ;
    SSC : TUOS_System_Services ;
    Target_Process : TProcess ;
    Timer : TGeneric_Timer ;

begin
    SSC := Kernel.SSC ;

    // Delete timers...
    for I := SSC.Timer_Count - 1 downto 0 do
    begin
        Timer := TGeneric_Timer( SSC.Get_Timer_By_Index( I ) ) ;
        if( Timer.PID = TargetPID ) then
        begin
            Timer.Free ;
        end ;
    end ;

    // Final cleanup...
    Terminate_Image( TargetPID ) ;
    Target_Process := Get_Process( TargetPID ) ;
    if( Target_Process = nil ) then // Already deleted
    begin
        exit ;
    end ;
    Target_Process.Free ;
end ; // TUSC._Delete_Process

    USC := _Kernel.USC ;

    // Delete all children processes...
    for I := _Children.Count - 1  downto 0 do
    begin
        TUSC( USC )._Delete_Process( _Children[ I ] ) ;
    end ;