VMS dealt with allocations on storage by "blocks", which were essentially sectors on the disks. The hardware used by VMS had a block size of 512 bytes. F$CUNITS was provided to convert from a number of blocks to a number of bytes. This has little use on UOS, but for the sake of compatibility, we will implement it as well.

Here is the description of the function:
F$CUNITS converts a number from one specified unit of measure to another.

Return Value
The converted value. If the value is greater than 1,000, the value is adjusted and suffixed with "KB", "MB, "GB", or "TB".

from
Optional unit of measure from which to convert. The only supported option for this field is "BLOCKS".

to
Optional unit of measure to which to convert. The only supported option for this field is "BYTES".

Example

$ A = F$CUNITS(100, "BLOCKS", "BYTES")

This example converts 100 blocks to the equivalent number of bytes. The result is "51.2KB".

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

const KB = $400 ; // 1024
const MB = $100000 ; // 1048576
const GB = $40000000 ; // 1073741824
const TB = $10000000000 ; // 1024 * GB

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

var N : int64 ;
    S, Suffix : string ;

begin
    Result := False ; // Assume no problems
    Err := 0 ;
    Context := '' ;
    N := Get_Numeric_Parameter( Err, Context ) ;
    if( Err <> 0 ) then
    begin
        Result := True ;
        exit ;
    end ;

    if( Parser.Peek <> ')' ) then
    begin
        Result := Missing_Comma( Err ) ;
        if( Result ) then
        begin
            exit ;
        end ;
        S := lowercase( Get_Parameter( Err, Context ) ) ;
        if( Err <> 0 ) then
        begin
            Result := True ;
            exit ;
        end ;
        if( S <> 'blocks' ) then
        begin
            Result := True ;
            Err := UCL_IVKEYW ; // Unrecognized keyword
            Context := S ;
            exit ;
        end ;
        if( Parser.Peek <> ')' ) then
        begin
            Result := Missing_Comma( Err ) ;
            if( Result ) then
            begin
                exit ;
            end ;
            S := lowercase( Get_Parameter( Err, Context ) ) ;
            if( Err <> 0 ) then
            begin
                Result := True ;
                exit ;
            end ;
            if( S <> 'bytes' ) then
            begin
                Result := True ;
                Err := UCL_IVKEYW ; // Unrecognized keyword
                Context := S ;
                exit ;
            end ;
        end ; // if( Parser.Peek <> ')' )
    end ; // if( Parser.Peek <> ')' )

    N := N * 512 ; // Blocks to bytes

    // Determine suffix
    Suffix := '' ;
    if( N >= TB ) then // Tb
    begin
        if( N < $7FFFFFFFFFFFFFFF - 512 ) then // Only if no overflow
        begin
            N := N + 512 ;
        end ;
        N := N div 1024 ; // Convert to Gb
        N := ( N + 512 ) div 1024 ; // Convert to Mb
        N := ( N + 512 ) div 1024 ; // Convert to Kb
        N := N + 5 ;
        N := N div 10 ;
        S := inttostr( N ) ;
        Suffix := 'TB' ;
    end else
    if( N >= GB ) then // Gb
    begin
        N := ( N + 512 ) div 1024 ; // Convert to Mb
        N := ( N + 512 ) div 1024 ; // Convert to Kb
        N := N + 5 ;
        N := N div 10 ;
        S := inttostr( N ) ;
        Suffix := 'GB' ;
    end else
    if( N >= MB ) then // Mb
    begin
        N := ( N + 512 ) div 1024 ; // Convert to Kb
        N := N + 5 ;
        N := N div 10 ;
        S := inttostr( N ) ;
        Suffix := 'MB' ;
    end else
    if( N >= KB ) then // Kb
    begin
        N := N + 5 ;
        N := N div 10 ;
        S := inttostr( N ) ;
        Suffix := 'KB' ;
    end else
    begin
        S := inttostr( N ) ;
    end ;

Why do we divide by 1024 instead of by 1000? Computer storage is always measured in powers of 2, and 1,024 is the power of 2 that is closest to 1,000. Thus 1,000 bytes is not exactly 1K bytes. That is why the KB constant is 1024. Likewise, 1M bytes is slightly more than one million bytes, and so on.

    if( Suffix <> '' ) then
    begin
        S := copy( S, 1, length( S ) - 2 ) + '.' + copy( S, length( S ) - 1, length( S ) ) ;
    end ;
    Context := S + Suffix ;
end ; // Parse_CUnits

function Get_Numeric_Parameter( var Err : integer ; var Context : string ) : int64 ;

var S : string ;

begin
    S := Get_Parameter( Err, Context ) ;
    if( Err <> 0 ) then
    begin
        exit ;
    end ;
    S := UCL_Strtoint( S ) ;
    if( S = '' ) then
    begin
        Err := UCL_ARGREQ ;
        exit ;
    end ;
    if( not trystrtoint64( S, Result ) ) then
    begin
        Err := UCL_EXPSYN ; // Invalid expression syntax
        Context := S ;
        exit ;
    end ;
end ;