One DCL capability is command recall. There are two forms of recall and UCL will support both. The first kind is the Control-B recall. We will discuss the second kind in the next article.

As commands are entered, they are stored in a buffer, called the "recall buffer". I don't know the VMS implementation details, but I suspect that it was implemented in the terminal driver in the VMS kernel. As you hopefully know by now, the UOS philosophy is to only include in the executive those things that must be in the executive for security purposes, or because of some mitigating circumstance. Command recall doesn't fit either criteria, so we will implement it in Starlet. There are ramifications to this approach. The most important one is that any call to LIB_Get_Command can use the recall buffer, even if the call is made from within an application. In other words, this is a feature that is available to applications as well as UCL. Note that an application can bypass command recall by going directly to the equivalent RMS call, which would be necessary for binary input (ie passthru mode). Second, because the buffer is not in ring 0 space, there isn't a single system-wide limit for each process' recall buffer as there is in VMS. Instead, the user can choose how much of his ring 3 virtual memory can be allocated to the recall buffer.

Command recall uses Control-B to recall a previously-entered command. Each time it is pressed, it displays the previously entered command, or does nothing if there is no previous command. Pressing Control-B multiple times will step back through the entered commands starting with the most recent and moving back toward the first with each Control-B. A recalled command is shown on the input line and it can be executed by pressing ENTER. The line is in the input buffer and can be edited with line editing keystrokes as if you had typed the command from the keyboard.

How do we get from the user pressing Control-B, which is then processed in the terminal input filter, to the starlet routine? Since this is a feature outside of the executive (and thus outside of the input filter), we will now treat Control-B as a delimiter, just as if the user pressed ENTER. LIB_Get_Command will detect this and handle it properly without UCL or the calling application being aware of the feature's use.

var Commands : TStringList = nil ; // Recall buffer
    Max_Recall : integer = 254 ; // Recall command limit
    Recall_Position : integer = 0 ; // Recall buffer position

    if( Commands = nil ) then
    begin
        Commands := TStringList.Create ;
    end ;
    while( true ) do
    begin
        Res := RMS.Get_Command( RAB ) ;
        if( SRB.Length < length( Res ) ) then
        begin
            setlength( Res, SRB.Length ) ;
        end ;

//NEW--->
        // Handle command recall...
        if( pos( Control_B, Res ) > 0 ) then // Recall command
        begin
            SYS_QIOW( 0, RH_SysCommand, IO_SETMODE or IOM_CLEAR_BUFFER,
                integer( @IOSB ), 0, 0, 0, 0, 0, 0, 0, 0 ) ; // Clear any pending input
            LIB_Put_Output( CRLF ) ;
            if( Commands.Count > 0 ) then
            begin
                if( Recall_Position >= 0 ) then
                begin
                    Res := Commands[ Recall_Position ] ;
                    dec( Recall_Position ) ;
                    Set_String( Res, Recall ) ;
                    SYS_QIOW( 0, RH_SysCommand, IO_SETMODE or IOM_FORCE_INPUT,
                        integer( @IOSB ), 0, 0, integer( @Recall ), 0, 0, 0, 0, 0 ) ;
                end ;
                continue ;
            end ;
        end ;
        break ;
    end ; // while( true )
//<---NEW
    PInt64( Len )^ := length( Res ) ;
    move( PChar( Res )[ 0 ], PChar( pointer( SRB.Buffer ) )[ 0 ], length( Res ) ) ;
//NEW--->
    while( Is_Delimiter( copy( Res, length( Res ), 1 ) ) ) do
    begin
        setlength( Res, length( Res ) - 1 ) ;
    end ;
    Add_Recall( Res ) ;
//<---NEW
end ; // LIB_Get_Command

At the end of the routine, we store the command in the buffer. We don't store the delimiter with the command, so we first remove it.

function Is_Delimiter( const S : string ) : boolean ;

begin
    Result := ( S = CR ) or ( S = LF ) or ( S = ESC ) or ( S = Control_C ) or
        ( S = Control_Y ) or ( S = FF ) or ( S = Control_Z ) ;
end ;

procedure Add_Recall( Res : string ) ;

begin
    if( trim( Res ) = '' ) then
    begin
        exit ;
    end ;
    Commands.Add( Res ) ;
    Recall_Position := Commands.Count - 1 ;
    while( Commands.Count > Max_Recall ) do
    begin
        Commands.Delete( 0 ) ;
    end ;
end ;

            IOM_CLEAR_BUFFER :
                begin
                    if( TFiP_Terminal_File( Resource._File ).Terminal <> nil ) then
                    begin
                        TFiP_Terminal_File( Resource._File ).Terminal.Input_Filter.Clear_Input ;
                    end ;
                end ;
            IOM_FORCE_INPUT :
                begin
                    if( TFiP_Terminal_File( Resource._File ).Terminal <> nil ) then
                    begin
                        _SRB := PSRB( pointer( p1 ) ) ;
                        Prompt := Get_User_String( Kernel, Kernel.PID, _SRB^, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_Error ) then
                        begin
                            exit ;
                        end ;
                        TFiP_Terminal_File( Resource._File ).Terminal.Input_Filter.Force_Input( Prompt.Contents ) ;
                    end ;
                end ;

const CCC_STX = $8000 ; // ^B

  _Controls[ _STX ] := CCC_STX ;

procedure TDefault_Input_Filter.Clear_Input ;

begin
    _Buffer.Clear ;
end ;

function TDefault_Input_Filter.Force_Input( const S : string ) : TUnified_Exception ;

var I : integer ;

begin
    for I := 1 to length( S ) do
    begin
        New_Character( ord( S[ I ] ) ) ;
    end ;
    Result := nil ;
end ;