In this article, we'll cover three lexical functions that return information about the current process.

F$MODE is a simple function that returns the process' mode as a string. Here is the definition:

F$MODE returns a character string showing the mode in which the executing process is executing. It takes no parameters, but the parentheses are required.

Description
The function returns the string INTERACTIVE for interactive processes. Otherwise is returns the character string BATCH, NETWORK, or OTHER, as appropriate. Note that the string returned is always uppercase.

This function is useful for command procedures that must operate differently when executed interactively and noninteractively.

        Function_MODE : begin
                            if( Missing_Parentheses( '(' ) ) then
                            begin
                                exit ;
                            end ;
                            if( Parse_Mode( Err, Context ) ) then
                            begin
                                exit ;
                            end ;
                            if( Missing_Parentheses( ')' ) ) then
                            begin
                                exit ;
                            end ;
                            S := Context ;
                        end ;

function Parse_Mode( var Err : integer ; var Context : string ) : boolean ;

var I : int64 ;

begin
    // Setup...
    Result := False ; // Assume no problems
    Context := '' ;

    I := Get_Integer_From_String( Get_JPI( 0, JPI_MODE ) ) ;
    case I of
        JPI_K_NETWORK: Context := 'NETWORK' ;
        JPI_K_BATCH: Context := 'BATCH' ;
        JPI_K_INTERACTIVE: Context := 'INTERACTIVE' ;
        else Context := 'OTHER' ;
    end ;
end ;

F$PRIVILEGE is used to see if the process has one or more privileges enabled. Here is the definition:

F$PRIVILEGE returns a string value of either TRUE or FALSE, depending upon whether or not the current process has the specified privileges.

Description
The function will return TRUE if the passed privilege(s) match the process' current privileges, and FALSE otherwise. Privilege names can be negated by prefixing them with "NO" - for instance, "NOBYPASS". In order for the function to return TRUE, all specified privileges must be current for the process and no negated privileges can be.

Example
$ X = F$PRIVILEGE("OPER,NOGROUP")
If the process has the OPER privilege and does not have the GROUP privilege, X will be set to TRUE. If the process has the GROUP privilege or doesn't have the OPER privilege, X is set to FALSE.

        Function_PRIVILEGE : begin
                                 if( Missing_Parentheses( '(' ) ) then
                                 begin
                                     exit ;
                                 end ;
                                 if( Process_Privilege( Err, Context ) ) then
                                 begin
                                     exit ;
                                 end ;
                                 if( Missing_Parentheses( ')' ) ) then
                                 begin
                                     exit ;
                                 end ;
                                 if( Err = 0 ) then
                                 begin
                                     S := Context ;
                                 end ;
                             end ;

function Process_Privilege( var Err : integer ; var Context : string ) : boolean ;

var I : integer ;
    F : TCOM_File ;
    N_Privs, P_Privs : int64 ; // Negative and positive privileges
    P, S : string ;
    This_Priv : int64 ;

begin
    // Setup...
    Result := False ; // Assume no problems
    Context := '' ;
    N_Privs := 0 ;
    P_Privs := 0 ;

    // Get items...
    S := Get_Parameter( Err, Context ) ;
    if( Err <> 0 ) then
    begin
        exit ;
    end ;

    // Process argument...
    I := pos( ',', S + ',' ) ;
    while( S <> '' ) do
    begin
        P := uppercase( copy( S, 1, I - 1 ) ) ;
        S := copy( S, I + 1, length( S ) ) ;
        if( copy( P, 1, 2 ) = 'NO' ) then
        begin
            This_Priv := String_To_Privilege( copy( P, 3, length( P ) ) ) ;
            if( This_Priv = 0 ) then // Not a valid privilege
            begin
                Err := UCL_IVKEYW ; // Unrecognized keyword
                Context := P ;
                exit ;
            end ;
            N_Privs := N_Privs or This_Priv ;
        end else
        begin
            This_Priv := String_To_Privilege( P ) ;
            if( This_Priv = 0 ) then // Not a valid privilege
            begin
                Err := UCL_IVKEYW ; // Unrecognized keyword
                Context := P ;
                exit ;
            end ;
            P_Privs := P_Privs or This_Priv ;
        end ;
        I := pos( ',', S + ',' ) ;
    end ;

    // Compare supplied privileges to our process privileges...
    This_Priv := Get_Integer_From_String( Get_JPI( 0, JPI_PROCPRIV ) ) ;
    if( ( ( This_Priv and P_Privs ) = P_Privs ) and ( ( This_Priv and N_Privs ) = 0 ) ) then
    begin
        Context := 'TRUE' ;
    end else
    begin
        Context := 'FALSE' ;
    end ;
end ; // Process_Privilege

const Privilege_Names : array[ 0..40 ] of string = ( 'ACNT',
                                                     'ALL',
                                                     'ALLSPOOL',
                                                     'ALTPRI',
                                                     'AUDIT',
                                                     'BUGCHK',
                                                     'BYPASS',
                                                     'CMEXEC',
                                                     'CMKRNL',
                                                     'DETACH',
                                                     'DIAGNOSE',
                                                     'DOWNGRADE',
                                                     'EXQUOTA',
                                                     'GROUP',
                                                     'GRPNAM',
                                                     'GRPPRV',
                                                     'IMPERSONATE',
                                                     'IMPORT',
                                                     'LOG_IO',
                                                     'MOUNT',
                                                     'NETMBX',
                                                     'OPER',
                                                     'PFNMAP',
                                                     'PHY_IO',
                                                     'PRMCEB',
                                                     'PRMGBL',
                                                     'PRMMBX',
                                                     'PSWARM',
                                                     'READALL',
                                                     'SECURITY',
                                                     'SETPRV',
                                                     'SHARE',
                                                     'SHMEM',
                                                     'SYSGBL',
                                                     'SYSLCK',
                                                     'SYSNAM',
                                                     'SYSPRV',
                                                     'TMPMBX',
                                                     'UPGRADE',
                                                     'VOLPRO',
                                                     'WORLD' ) ;

const Privileges : array[ 0..40 ] of int64 = ( ACNT,  
                                               -1, // ALL
                                               ALLSPOOL,
                                               ALTPRI,
                                               AUDIT,
                                               BUGCHK,
                                               BYPASS,
                                               CMEXEC,
                                               CMKRNL,
                                               DETACH,
                                               DIAGNOSE,
                                               DOWNGRADE,
                                               EXQUOTA,
                                               GROUP,
                                               GRPNAM,
                                               GRPPRV,
                                               IMPERSONATE,
                                               IMPORT,
                                               LOG_IO,
                                               MOUNT,
                                               NETMBX,
                                               OPER,
                                               PFNMAP,
                                               PHY_IO,
                                               PRMCEB,
                                               PRMGBL,
                                               PRMMBX,
                                               PSWARM,
                                               READALL,
                                               SECURITY,
                                               SETPRV,
                                               SHARE,
                                               SHMEM,
                                               SYSGBL,
                                               SYSLCK,
                                               SYSNAM,
                                               SYSPRV,
                                               TMPMBX,
                                               UPGRADE,
                                               VOLPRO,
                                               WORLD ) ;

function String_To_Privilege( const P : string ) : int64 ;

var I : integer ;

begin
    for I := low( Privilege_Names ) to high( Privilege_Names ) do
    begin
        if( P = Privilege_Names[ I ] ) then
        begin
            Result := Privileges[ I ] ;
            exit ;
        end ;
    end ;
    Result := 0 ;
end ; // String_To_Privilege

F$PROCESS returns the current process name string. It has no arguments, but must be followed by parentheses.

        Function_PROCESS : begin
                               if( Missing_Parentheses( '(' ) ) then
                               begin
                                   exit ;
                               end ;
                               if( Parse_Process( Err, Context ) ) then
                               begin
                                   exit ;
                               end ;
                               if( Missing_Parentheses( ')' ) ) then
                               begin
                                   exit ;
                               end ;
                               S := Context ;
                           end ;

function Parse_Process( var Err : integer ; var Context : string ) : boolean ;

begin
    // Setup...
    Result := False ; // Assume no problems
    Context := Get_JPI( 0, JPI_PRCNAM ) ;
end ;

In the next article, we will examine an abstracted file lookup service that works with any file system.