In the previous article, we looked at the documentation for the APPEND CUSP. In this article, we look at the source code. We also look at the CONTINUE command in UCL. These two things are unrelated, but we include them together here because this would be a very short article if I only did one of them. First we'll look at the APPEND code. The reason this is so simple is that the APPEND CUSP is merely a wrapper for the COPY CUSP. COPY does append operations, so there is no need to copy that functionality in another CUSP when we can just tell the COPY CUSP to do the work for us. The only difference between the two is that APPEND allows the use of plus signs (+) instead of commas between the list of files to append. So we merely translate the command line into a comma-delimited list and pass it on to COPY for the actual work.

function Run : int64 ;

var C : string ;
    E : int64 ;
    OS : POS_UOS ;

begin
    Result := 0 ;
    OS := new( POS_UOS, Init ) ;
    C := Get_Symbol( 'append$defaults' ) ;
    E := _Append( PChar( OS^.Command_Line ), PChar( C ), True ) ;
    if( E <> 0 ) then
    begin
        OS^.OutputLn( 0, LIB_Get_Exception_Text( 0, E ) ) ;
    end ;
    OS.Free ;
    SYS_EXIT( 0 ) ;
end ;

function _Append( Command, Defaults : PChar ; Standalone : boolean ) : int64 ;

var C, S : string ;
    P : integer ;

begin
    // Prepend command line with defaults...
    P := Switch_Present( Command ) ;
    if( P = 0 ) then
    begin
        P := length( Command ) + 1 ;
    end ;
    C := copy( Command, 1, P - 1 ) + Defaults + copy( Command, P, length( Command ) ) ;

    // Convert plus sign delimiters with commas...
    S := '' ;
    while( C <> '' ) do
    begin
        S := S + Parse_Parameter( '+', C ) ;
        if( C <> '' ) then
        begin
            S := S + ',' ;
        end ;
    end ;
    Result := PasStarlet.Run( 'SYS$SYSTEM:COPY', S ) ;
end ; // _Append

Now we cover the CONTINUE command. The idea is to allow the user to interrupt a script or program using Control-C or Control-Y, and then continue the interrupted script/program thereafter. Like DCL, UCL will terminate the interrupted script or program if the user starts another script or program. However, there is a difference between UOS and VMS to be aware of. All of the DCL commands are inherent to DCL and using them will not stop an interrupted script/program. However, in UCL some of these commands are implemented via CUSPs (to allow them to be used by other shells). Thus, while use of something like SET SYMBOL in DCL is allowed, in UCL, it would terminate the interrupted code/script. This is one reason we've been careful to distinguish between UCL commands and CUSPs.

One last note before we look at the documentation and code: we don't include the code necessary to resume an interrupted program - just an interrupted script for now. There is more involved in continuing an interrupted program and we will cover that in the future. I had actually planned to hold off on CONTINUE until then, but I needed the ability to interrupt/continue scripts as a part of current development efforts.

procedure CC_AST( P : int64 ) ; stdcall ;

begin
    CC_Interrupt := True ;
    Enter_Interrupt ;
end ;


procedure CY_AST( P : int64 ) ; stdcall ;

begin
    CY_Interrupt := True ;
    Enter_Interrupt ;
end ;

var Interrupt_Context : TUCL_Context = nil ;

procedure CC_AST( P : int64 ) ; stdcall ; forward ;
procedure CY_AST( P : int64 ) ; stdcall ; forward ;

procedure Enter_Interrupt ;

var S : string ;

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
    Waiting_For_Label := False ; // Cancel any input wait
    SYS_Cancel( RH_SysCommand ) ; // Cancel any I/O operation
    SYS_Cancel( RH_SysInput ) ;
    SYS_Cancel( RH_SysOutput ) ;
    Output( RH_SYSOutput, CRLF + '*INTERRUPT*' + CRLF ) ;

    SYS_QIOW( 0, RH_SysCommand, IO_SETMODE or IOM_CLI_CTRLCAST, integer( @IOSB ),
        0, 0, integer( @CC_AST ), 0, 0, 0, 0, 0 ) ;
    SYS_QIOW( 0, RH_SysCommand, IO_SETMODE or IOM_CLI_CTRLYAST, integer( @IOSB ),
        0, 0, integer( @CY_AST ), 0, 0, 0, 0, 0 ) ;
    if( Interrupt_Context = nil ) then // Not already interrupted
    begin
        { The following shouldn't be done if we are not interactive.  However,
          we shouldn't get an interrupt if we aren't, so we should never get
          here under that circumstance. }
        Interrupt_Context := TUCL_Context.Create ;
        Interrupt_Context.Nest ;
        S := GetJPI( 0, JPI_TERMINAL ) ;
        Set_Symbol( 'sys$command', S, LNM_PROCESS ) ;
        Set_Symbol( 'sys$input', S, LNM_PROCESS ) ;
        Set_Symbol( 'sys$output', S, LNM_PROCESS ) ;
        Set_Symbol( 'sys$error', S, LNM_PROCESS ) ;
    end ;
    //TODO: Interrupt program
end ;

procedure Cancel_Interruption ;

var X : int64 ;

begin
    if( Interrupt_Context <> nil ) then
    begin
        while( Contexts.Count > 1 ) do // While nested
        begin
            Process_Exit( X ) ;
        end ;
        Interrupt_Context.Free ;
        Interrupt_Context := nil ;
    end ;
end ;

procedure Process_Continue ;

begin
    if( Interrupt_Context <> nil ) then
    begin
        Interrupt_Context.Unnest ;
        Interrupt_Context.Free ;
        Interrupt_Context := nil ;
    end ;
end ;