Let's briefly review how symbol tables work in UOS. As we've discussed in the distant past, DCL uses local symbol tables and VMS only supports logical name tables. In UOS, we've combined these into system symbol tables. So, though we use the VMS system services names (such as CRELNT for Create Logical Name Table), remember that logical names are equivalent to symbol names in UOS. Logical name tables are equivalent to symbol name tables in UOS.

We have used the LN_* constants to reference the process/job/system/cluster symbol table names. That was fine for our uses up to this point, but with the need to dynamically create and delete tables, we need a means of refer to specific tables within the process name space. Thus, we have modified the code to handle actual table names, as does VMS. We translate the LN_* codes to actual names. For instance, LN_PROCESS is converted to "lnm$process". There is little change to behavior since lnm$process will almost always refer to the default process symbol table, no matter what the table's actual name is. However, there are certain cases, where we will need to look up the table that is literally named "lnm$process". I'll point those out when appropriate. Allowing tables by names means that we can create as many different concurrent tables as we need.

To keep track of the burgeoning number of potential tables, the tables are gathered into parent "tables", which are implemented as lists. but these tables also need names. For instance, the "lnm$process_directory" table is the collection of all process-private tables. It is necessary to refer to these parent tables to indicate where a table to be created/deleted is located, so we will use these parent table names in our code. CRELNT is the system service that we use to create a table. Here is the documentation:

Format
SYS_CRELNT( Attr, Resnam, Reslen, Quota, Promsk, Tabnam, Partab, AcMode )

function CRELNT( Attr : int64 ; var Resnam : string ; Quota : int64 ;
    Promsk : int64 ; Tabnam, Partab : string ;
    AcMode : int64 ) : int64 ;

var S_Resname, S_Tabnam, S_Partab : TSRB ;
    Reslen : int64 ;

begin
    Resnam := '                                ' ;
    Set_String( Resnam, S_Resname ) ;
    Set_String( Tabnam, S_Tabnam ) ;
    Set_String( Partab, S_Partab ) ;
    Result := SYS_CRELNT( int64( @Attr ), int64( @S_Resname ), int64( @Reslen ),
        int64( @Quota ), int64( @Promsk ), int64( @S_Tabnam ), int64( @S_Partab ),
        int64( @AcMode ) ) ;
    setlength( Resnam, Reslen ) ;
end ;

function SYS_CRELNT( Attr, Resnam, Reslen, Quota, Promsk, Tabnam, Partab,
    AcMode : int64 ) : int64 ;

var SysRequest : TS3I5_Request ;
    Resname_SRB : PSRB ;
    Tabnam_SRB : PSRB ;
    Partab_SRB : PSRB ;

begin
    Resname_SRB := PSRB( pointer( Resnam ) ) ;
    Tabnam_SRB := PSRB( pointer( Tabnam ) ) ;
    Partab_SRB := PSRB( pointer( Partab ) ) ;

    SysRequest.Request.Subsystem :=  UOS_Subsystem_SSC ;
    SysRequest.Request.Request := UOS_SSC_CRELNT ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( Sysrequest.Request ) ;
    SysRequest.Request.Status := 0 ;
    SysRequest.SRB1.Buffer := Resname_SRB.Buffer ;
    SysRequest.SRB2.Buffer := Tabnam_SRB.Buffer ;
    SysRequest.SRB3.Buffer := Partab_SRB.Buffer ;
    SysRequest.SRB1.Length := Resname_SRB.Length ;
    SysRequest.SRB2.Length := Tabnam_SRB.Length ;
    SysRequest.SRB3.Length := Partab_SRB.Length ;
    SysRequest.Integer1 := Attr ;
    SysRequest.Integer2 := Reslen ;
    SysRequest.Integer3 := Quota ;
    SysRequest.Integer4 := Promsk ;
    SysRequest.Integer5 := AcMode ;

    Call_To_Ring0( integer( @SysRequest ) ) ;

    Result := SysRequest.Request.Status ;
end ;

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

                try
                    PS3I5 := PS3I5_Request( Base ) ;
                    PS3I5.Request.Status := CRELNT( Kernel, PID, PS3I5.SRB2, PS3I5.SRB3,
                        PS3I5.SRB1, PS3I5.Integer2, PS3I5.Integer1,
                        PS3I5.Integer3, PS3I5.Integer4, PS3I5.Integer5 ) ;
                finally
                    Exit_System_Call( Base, PID, MMC, sizeof( TS3I5_Request ) ) ;
                end ;
            end ;

function TUOS_SSC.CRELNT( Kernel : TUOS_Kernel ; PID : TPID ;
    TableName, ParentName, Return_Name : TSRB ;
    Reslen, _Attr, _Quota, _Promsk, _AcMode : int64 ) : int64 ;

var Table_Name, Parent_Name : string ;
    Status : integer ;
    Attr, Quota, Promsk, AcMode : int64 ;
    US : TUOS_String ;

begin
    // Get the values and validate...
    if( ParentName.Buffer = 0 ) then
    begin
        Result := SS_BADPARAM ;
        exit ;
    end ;
    US := Get_User_String( Kernel, PID, TableName, Status ) ;
    if( Status = UE_Error ) then
    begin
        Result := Status ;
        exit ;
    end ;
    Table_Name := trim( US.Contents ) ;

    US := Get_User_String( Kernel, PID, ParentName, Status ) ;
    if( Status = UE_Error ) then
    begin
        Result := Status ;
        exit ;
    end ;
    Parent_Name := US.Contents ;

    Attr := Get_User_Integer( Kernel, PID, _Attr, Status ) ;
    if( Status = UE_Error ) then // Error reading user value
    begin
        Result := Status ;
        exit ;
    end ;
    Quota := Get_User_Integer( Kernel, PID, _Quota, Status ) ;
    if( Status = UE_Error ) then // Error reading user value
    begin
        Result := Status ;
        exit ;
    end ;
    Promsk := Get_User_Integer( Kernel, PID, _Promsk, Status ) ;
    if( Status = UE_Error ) then // Error reading user value
    begin
        Result := Status ;
        exit ;
    end ;
    if( _AcMode = 0 ) then
    begin
        _AcMode := USC.Access_Mode( PID ) ;
    end else
    begin
        AcMode := Get_User_Integer( Kernel, PID, _AcMode, Status ) ;
        if( Status = UE_Error ) then // Error reading user value
        begin
            Result := Status ;
            exit ;
        end ;
        if( ( AcMode > 3 ) or ( AcMode < 0 ) ) then
        begin
            Result := SS_BADPARAM ;
            exit ;
        end ;
        if( AcMode < USC.Access_Mode( PID ) ) then
        begin
            AcMode := USC.Access_Mode( PID ) ;
        end ;
    end ;
    if( ( PID <> 0 ) and ( AcMode < PSL_C_SUPER ) ) then
    begin
        if( ( USC.Get_Process_Info( PID, JPI_CURPRIV ) and SYSNAM ) = 0 ) then
        begin
            Result := SS_NOPRIV ; // User must have SYSNAM to use KERNEL or EXECUTIVE access mode
            exit ;
        end ;
    end ;

    // Create the table...
    Result := Create_Symbol_Table( Kernel, PID, Table_Name, Parent_Name, Return_Name,
        Reslen, Attr, Quota, Promsk, AcMode ) ;

    if( ( Result <> 0 ) and ( Result <> SS_SUPERSEDE ) ) then
    begin
        Generate_Exception( Result ) ;
    end ;
end ; // TUOS_SSC.CRELNT

function TUOS_SSC.Create_Symbol_Table( Kernel : TUOS_Kernel ; PID : TPID ;
    var Table_Name, Parent_Name : string ;
    Return_Name : TSRB ; Reslen : int64 ;
    Attr, Quota, Promsk, AcMode : int64 ) : int64 ;

var I : integer ;
    Table : TUOS_Symbol_Table ;

begin
    // Setup...
    Result := 0 ;
    Table_Name := trim( lowercase( Table_Name ) ) ;
    Parent_Name := trim( lowercase( Parent_Name ) ) ;

    // Default the name...
    if( Table_Name = '' ) then
    begin
        Table_Name := 'lnm$' + lowercase( CVTB( 10, 16, inttostr( LIB_Get_Timestamp ) ) ) ;
    end ;

    // Create table...
    if( Parent_Name = 'lnm$process_directory' ) then
    begin
        if( PID = 0 ) then
        begin
            Result := SS_NOLOGTAB ;
            exit ;
        end ;
        Table := USC.Resolve_Table( PChar( Table_Name ), PID, nil, True, 3 ) ;
        if( Table <> nil ) then // Table exists
        begin
            if( ( Attr and LNM_M_CREATE_IF ) <> 0 ) then // Create if not exists
            begin
                Result := 0 ;
                exit ;
            end ;
            Table.Clear ;
            Result := SS_SUPERSEDE ;
        end else
        begin
            Table := USC.Create_Symbol_Table( Kernel, PID, PChar( Table_Name ),
                Attr, Quota, Promsk, AcMode ) ; // Create table
        end ;
    end else

    if( Parent_Name = 'lnm$system_directory' ) then
    begin
        if( ( PID <> 0 )
            and
            not USC.Validate_Protection( PID, FAB_V_UPD, 0, 
                PROTECTION_SYSTEM_WRITE or PROTECTION_SYSTEM_DELETE, 0 )
          ) then 
        begin
            Result := SS_NOPRIV ;
            exit ;
        end ;
        I := Symbols.IndexOf( Table_Name ) ;
        if( I <> -1 ) then // Table already exists
        begin
            if( ( Attr and LNM_M_CREATE_IF ) <> 0 ) then // Create if not exists
            begin
                Result := 0 ;
                exit ;
            end ;
            Table := TUOS_Symbol_Table( Symbols.Objects[ I ] ) ;
            Table.Clear ;
            Result := SS_SUPERSEDE ;
        end else
        begin
            Symbols.AddObject( Table_Name, TSymbol_Table.Create( Table_Name ) ) ;
        end ;
    end else

    begin
        Result := SS_NOLOGTAB ;
        exit ;
    end ;

    // Return table name...
    if( Return_Name.Buffer <> 0 ) then
    begin
        Table_Name := Table.Name ;
        if( Return_Name.Length < length( Table_Name ) ) then
        begin
            setlength( Table_Name, Return_Name.Length ) ;
            Result := SS_RESULTOVF ;
        end ;
        Set_User_String( Kernel, PID, Return_Name, Table_Name ) ;
        if( ResLen <> 0 ) then
        begin
            Write_User_int64( Kernel, PID, ResLen, length( Table_Name ) ) ;
        end ;
    end ; // if( Return_Name.Buffer <> 0 )
end ; // TUOS_SSC.Create_Symbol_Table

function TUSC.Create_Symbol_Table( Kernel : TUOS_Kernel ; PID : TPID ;
    Table_Name : PChar ; Attr, Quota, Promsk, AcMode : int64 ) : TUOS_Symbol_Table ;

var Process : TProcess ;
    T : string ;

begin
    Result := nil ;
    Process := Get_Process( PID ) ;
    if( Process = nil ) then // Process doesn't exist
    begin
        Generate_Exception( UOSErr_Nonexistent_Process ) ;
        exit ;
    end ;
    T := lowercase( trim( string( Table_Name ) ) ) ;
    if( T = '' ) then
    begin
        exit ;
    end ;
    if( Process.Symbol_Table_Directory.Indexof( T ) <> -1 ) then
    begin
        exit ;
    end ;
    Result := TSymbol_Table.Create( T ) ;
    Process.Symbol_Table_Directory.AddObject( T, Result ) ;
    if( ( Attr and LNM_M_MAKE_DEFAULT ) <> 0 ) then
    begin
        Process._Symbols := Result ;
    end ;
end ; // TUSC.Create_Symbol_Table

function TProcess.Create_Symbol_Table( Name : string ) : int64 ;

var ST : TSymbol_Table ;

begin
    Name := uppercase( Name ) ;
    if( Symbol_Table_Directory.Indexof( Name ) <> -1 ) then // Already exists
    begin
        exit ;
    end ;
    Result := 0 ;
    ST := TSymbol_Table.Create( Name ) ;
    Symbol_Table_Directory.AddObject( ST.Name, ST ) ;
end ;

function TUSC.Resolve_Table( LNTable : PChar ; PID : TPID ; N : PChar ;
    CS : boolean ; Access : integer ) : TUOS_Symbol_Table ;

var I : integer ;
    Process : TProcess ;
    Name, Table : string ;

begin
    Result := nil ;
    Process := Get_Process( PID ) ;
    if( Process = nil ) then
    begin
        exit ;
    end ;
    Table := LNTable ;
    Name := N ;

    if( Table = 'lnm$process' ) then
    begin
        Result := Process._Symbols ;
        exit ;
    end ;
    if( Table = 'lnm$job' ) then
    begin
        Result := Process._Job_Symbols ;
        exit ;
    end ;

    if( Table = '' ) then
    begin
        Result := Process._Symbols ;
        if( Result.Exists( N, CS, Access ) ) then
        begin
            exit ;
        end ;
        Result := nil ;
        if( Process._Job_Symbols <> nil ) then
        begin
            Result := Process._Job_Symbols ;
            if( Result.Exists( N, CS, Access ) ) then
            begin
                exit ;
            end ;
            Result := nil ;
        end ;
    end ; // if( Table = '' )

    for I := 0 to Process.Symbol_Table_Directory.Count - 1 do
    begin
        if( Table = Process.Symbol_Table_Directory[ I ] ) then
        begin
            Result := TUOS_Symbol_Table( Process.Symbol_Table_Directory.Objects[ I ] ) ;
            exit ;
        end ;
    end ;
end ; // TUSC.Resolve_Table