Lexical Functions - F$STRING, F$TIME, and F$TYPE

The F$STRING lexical function converts a number to a string. Because UCL is typeless, this function effectively does nothing but evaluate the parameter and return the result. Since DCL symbols are typed, this has utility on VMS that is irrelevant on UOS. Here is the definition.

F$STRING is provided for compatibility with VMS. UCL returns the parameter (evaluating any integer or string expressions).

Format
F$STRING(expression)

Return Value
Returns the evaluated expression.

Arguments
expression

A string or integer symbol, literal, value, or expression.

Description
The F$STRING lexical function evaluates the passed expression and returns the result.

Example
$ A = F$STRING(A - 2)

In this example, A is set to the evaluated value of A minus 2. This is equivalent to the following:
$ A = A - 2

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

This code is added to the Function_Reference function.

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

var S : string ;

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

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

This new function simply gets the parameter and returns it (unless there was an error getting the parameter).

The F$TIME lexical function is another simple function. Here is the definition:

F$TIME returns the current date and time in absolute time format. The function takes no parameters, but must be followed by parentheses.

Format
F$TIME()

Return Value
Returns a character string containing the current date and time in the following format:
dd-mmm-yyyy hh:mm:ss.cc

Arguments
none

Description
The day of month is space-padded if the day is less than 10. Thus, the time portion always begins at the 13th character. Note that if assigning to a symbol using string assignment (:=), the leading space (if any) is trimmed.

Example
$ A = F$TIME()

In this example, A is set to the current date and time string.

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

This code is added to the Function_Reference.

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

var Default_Context, New_Context : TDate_Time_Context ;

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

    // Save current context and create new one...
    Default_Context := Default_Time_Context ;
    New_Context := TDate_Time_Context.Create ;
    New_Context.Component[ LIB_K_OUTPUT_FORMAT ] := '|!DB-!MAAU-!Y4 | !H04:!M0:!S0.!C2|' ;
    Set_Default_Time_Context( New_Context ) ;

    // Do the call...
    try
        Context := ASCTIM( LIB_Get_Timestamp ) ;
    finally
        Set_Default_Time_Context( Default_Context ) ; // Restore previous context
        New_Context.Free ;
    end ;
end ;

Because the default date/time format may not match the specific format returned by this function, we save the current default time context, create one with the format we want, call ASCTIM to get the date/time string, and then reset the current default time context and free our temporary date/time context.

The F$TYPE lexical function returns the data type of a symbol. Again, DCL has typed data, whereas UCL does not. Because UCL is typeless, this function returns "INTEGER" if the contents is a valid integer, and "STRING" otherwise. Here is the definition.

The F$TYPE lexical function returns the data type of a symbol.

Format
F$TYPE(symbol)

Return Value
F$TYPE returns the data type of a symbol. If the symbol is a process context from the F$PID function, "PROCESS_CONTEXT" is returned. If the symbol is a cluster context from F$CSID, "CLUSTER_SYSTEM_CONTEXT" is returned. Otherwise, "INTEGER" is returned if the contents of the symbol represents a valid integer or "STRING" if not. If the symbol is undefined, a null string is returned.

Arguments
symbol

The symbol name whose type is returned.

Description
The F$TYPE lexical function returns the data type of a symbol. An expression can be passed as well, and the result of that expression is used to determine the type returned.

Example
$ A = F$TYPE(B)

In this example, A is set to the type of symbol B.

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

This code is added to the Function_Reference function.

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

var I : integer ;
    S : string ;

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

    // Get parameter...
    S := Get_Parameter( Err, Context ) ;
    if( Err <> 0 ) then
    begin
        exit ;
    end ;
    if( S = '' ) then
    begin
        Context := '' ;
        exit ;
    end ;
    if( trystrtoint( S, I ) ) then
    begin
        if( ( Contexts_List <> nil ) and ( Contexts_List.IndexOf( pointer( I ) ) <> -1 ) ) then
        begin
            Context := 'PROCESS_CONTEXT' ;
        end else
        begin
            Context := 'INTEGER' ;
        end ;
    end else
    begin
        Context := 'STRING' ;
    end ;
end ; // Process_Type

This function gets the value and checks to see if it is an integer. If not, it returns "STRING". Otherwise, if the integer is one of the process contexts, we return "PROCESS_CONTEXT", otherwise we return "INTEGER".

In the next article, we will examine extensions to UOS symbols.