Addendum to previous article
I overlooked one aspect of the PROCESS_SCAN system call that we covered in the previous article. The call needs to handle a reset of a context by passing a null item list to it. So, we will modify it slightly, as follows.

    if( ContextAdr = 0 ) then // Invalid address
    begin
        Generate_Exception( UOSErr_Bad_Parameter ) ;
        exit ;
    end ;

TProcess updates
In this article, we will look at some support code, modifications to the TProcess class, and how the TContext class is used in the GETJPI system call.

                        Contexts_List : TList ; // Process contexts

                        function Child_Count : integer ;
                        function Job : TProcess ; virtual ;
                        function Parent : TProcess ; virtual ;
                        procedure Free_Remote ; virtual ;
                        function Hardware_Description : string ; virtual ;
                        function Hardware_Code : int64 ; virtual ;
                        function CSID : int64 ; virtual ;
                        function NodeName : string ; virtual ;
                        procedure Assign_Device( D : Devices.TDevice ) ; virtual ;
                        function Terminal_Name : string ; virtual ;
                        function KThread_Count : int64 ; virtual ;
                        function MaxK_Threads : int64 ; virtual ;
                        
                    public // Contexts...
                        function Get_Context( Adr : int64 ) : TContext ;
                        procedure Add_Context( Value : TContext ) ;
                        procedure Delete_Context( Adr : int64 ) ;

function TProcess.Child_Count : integer ;

begin
    Result := 0 ;
    if( _Children = nil ) then
    begin
        exit ;
    end ;
    Result := _Children.Count ;
end ;


function TProcess.Job : TProcess ;

begin
    Result := self ;
    if( _Parent = 0 ) then
    begin
        exit ;
    end ;
    while( Result._Parent <> 0 ) do
    begin
        Result := Get_Process( _Parent ) ;
    end ;
end ;


function TProcess.Parent : TProcess ;

begin
    Result := nil ;
    if( _Parent <> 0 ) then
    begin
        Result := Get_Process( _Parent ) ;
    end ;
end ;


procedure TProcess.Free_Remote ;

begin
    // Do nothing for local processes
end ;


function TProcess.Hardware_Description : string ;

begin
    Result := _Kernel.HAL.Hardware_Description ;
end ;


function TProcess.Hardware_Code : int64 ;

begin
    Result := _Kernel.HAL.Hardware_Code
end ;


function TProcess.CSID : int64 ;

begin
    Result := _Kernel.Cluster_ID ;
end ;


function TProcess.NodeName : string ;

begin
    Result := _Kernel.Node_Name ;
end ;


function TProcess.Terminal_Name : string ;

begin
    Result := '' ;
    if( Attached_Device = nil ) then // Detached process
    begin
        exit ;
    end ;
    Result := Device_Name( Attached_Device.Info ) ;
end ;


function TProcess.KThread_Count : int64 ;

begin
    Result := 0 ; // Thread count
end ;


function TProcess.MaxK_Threads : int64 ;

begin
    Result := 0 ; // Max threads
end ;

Of special note here are Free_Remote which does nothing (it will be overridden in the descendent class as mentioned above). The Job method follows the chain of parent IDs to the topmost parent, which is the job ID. The Child_Count method simply returns the count from the _Children list. If the list hasn't been created yet (is nil), it returns 0.

// Contexts...

function TProcess.Get_Context( Adr : int64 ) : TContext ;

begin
    if( Contexts_List.Indexof( pointer( Adr ) ) = -1 ) then
    begin
        Result := nil ; // Not a valid contextx
    end else
    begin
        Result := TContext( pointer( Adr ) ) ;
    end ;
end ;


procedure TProcess.Add_Context( Value : TContext ) ;

begin
    Delete_Context( int64( Value ) ) ;
    Contexts_List.Add( Value ) ;
end ;


procedure TProcess.Delete_Context( Adr : int64 ) ;

var I : integer ;

begin
    I := Contexts_List.Indexof( pointer( Adr ) ) ;
    if( I <> -1 ) then
    begin
        Contexts_List.Delete( I ) ;
    end ;
end ;

GETJPI
Now we'll look at the changes to the Get_Job_Process_Info method. We add this to the local variables:

    if( pidadr = -1 ) then
    begin
        if( Process.Wildcard_Context = nil ) then
        begin
            Process.Wildcard_Context := TContext.Create ;
        end ;
        Process_Context := Process.Wildcard_Context ;
    end else
    if( pidadr <> 0 ) then
    begin
        if( ( pidadr and 1 ) <> 0 ) then // A context
        begin
            Process_Context := Process.Get_Context( pidadr and ( not 1 ) ) ;
        end else
        begin
            Target_PID := Get_User_Integer( Kernel, PID, pidadr, Status ) ;
            if( Status = UE_Error ) then
            begin
                IOSB.r_io_64.w_status := Status ;
                if( MMC.Last_Error = nil ) then
                begin
                    Generate_Exception( UOSErr_Memory_Address_Error ) ;
                end ;
                exit ;
            end ;
        end ;
    end else
    if( prcnam <> '' ) then
    begin
        prcnam := lowercase( prcnam ) ;
        for I := 0 to Processes.Count - 1 do
        begin
            Process := TProcess( Processes[ I ] ) ;
            if( Process <> nil ) then
            begin
                if( prcnam = lowercase( Process.Name ) ) then
                begin
                    Target_PID := Process._PID ;
                    break ;
                end ; // if( prcnam = lowercase( Process.Name ) )
            end ; // if( Process <> nil )
        end ; // for I := 0 to Processes.Count - 1
    end ;

If pidadr is a context, we take the context object for that context. Process contexts are always odd. We'll discuss how the contexts get assigned in a later article. But, they are the address of the actual context with the low bit set. The reason we do this is because we have to distinguish between an address from the user and an address in the executive for the context. It is possible, because these are two separate virtual address domains, that there is no way to determine if an address is the address of a PID in the user address space or a context address in the executive space. We could have implemented some scheme where we have indirect context references (maybe something like the index into a list) that exist at the top or bottom of the address range. However, there are no assumptions we can make about the CPU architecture and whether a index in a list might collide with a user address. So, we will simply declare that, for the GETJPI system call, non-context values for pidadr must be even addresses. It should be easy for the calling code to make sure that constraint is met. The Get_Context method will return the process context instance (or nil if the context is not valid). Note that we mask off the low bit before we request the the context instance.
Note: VMS doesn't have this problem because it stores the context in the user's virtual address space. UOS keeps the context in the executive.

On the other hand, a value of 0 indicates that we should return data for the current process (unless prcnam is specified). In all other cases, we get the ID from the specified address.

    if( Process_Context <> nil ) then
    begin
        Target_PID := Process_Context.Next_PID ;
        if( Target_PID = 0 ) then
        begin
            if( Process_Context = Process.Wildcard_Context ) then
            begin
                Process.Wildcard_Context.Free ;
                Process.Wildcard_Context := nil ;
            end ;
            Generate_Exception( UOSErr_Nonexistent_Process ) ;
            exit ;
        end ;
    end ; // if( Process_Context <> nil )

In the next article, we will review unicode, including the Compare function we used in the code from the previous article.