COPY, part 3

In this article we will continue to look at the code for the COPY CUSP.

            // Do the operation...
            OutFile := nil ;
            if( Operation = Op_Contiguous ) then
            begin
                F := Open( S, 0 ) ;
                if( F = nil ) then
                begin
                    Result := Last_Error ;
                    exit ;
                end ;
                F.Contiguous := True ;
                F.Free ;
                exit ;
            end ;
            if( Operation = Op_Noncontiguous ) then
            begin
                F := Open( S, 0 ) ;
                if( F = nil ) then
                begin
                    Result := Last_Error ;
                    exit ;
                end ;
                F.Contiguous := False ;
                F.Free ;
                exit ;
            end ;

The first two operations have to do with altering the contiguous state of a file. On VMS, one would have to copy the file to itself, creating a (non)contiguous new file. If not open elsewhere, the old file would then be deleted when COPY closed it, leaving the new copy with the desired state. This can be problematic with large files as there may not be enough space for two copies of the file, even if only for a short time. The UOS file system provides for a means of simply changing the file layout in-place. We discussed this in the past, and going from contiguous to non-contiguous might increase the store requirements slightly, but not as much as creating another copy of the file. So COPY will make use of this feature and simply change the contiguous state of the file. Note that a non-UOS native file system might have to accomplish this operation in a way similar to VMS, but such operations must be encapsulated within the file system driver.

            OS := new( POS_UOS, Init ) ;
            for Index := 0 to Inputs.Count - 1 do // Loop through input filespecs
            begin
                _Out := Inputs[ Index ] ;
                Search_Context := 0 ;

The copy and concatenate operations take up the rest of the COPY routine. We will iterate through the input file list, processing them in the order they were specified.

                S := Lookup( _Out, Search_Context ) ;
                while( S <> '' ) do // While matching input files...
                begin
                    // Skip exclusions...
                    Skip_File := False ;
                    for Index1 := 0 to Exclusions.Count - 1 do
                    begin
                        if( Filename_Match( S, Exclusions[ Index1 ] ) ) then
                        begin
                            Skip_File := True ;
                            break ;
                        end ;
                    end ;
                    if( Skip_File ) then
                    begin
                        S := Lookup( '', Search_Context ) ;
                        continue ;
                    end ;

For each input file specification, we do a wildcard lookup loop to find all matching files. For each found file, we first check to see if the filename matches any of the excluded file specifications. If a match was found, we lookup the next file and loop back to check the exclusions.

                    // Skip files not matching date criteria...
                    F := Open( S, FAB_V_GET or FAB_V_SHRALL ) ;
                    if( F = nil ) then
                    begin
                        S := Lookup( '', Search_Context ) ;
                        continue ;
                    end ;
                    if( File_Date_Mode <> Date_None ) then
                    begin
                        case File_Date_Match of
                            Date_Backup : File_Time := F.Last_Backup ;
                            Date_Created : File_Time := F.Creation ;
                            Date_Expired : File_Time := F.Expiration ;
                            Date_Modified : File_Time := F.Last_Modified ;
                        end ;
                    end ;
                    if( File_Date_Mode = Date_Since ) then
                    begin
                        if( File_Time < Comparison_Time ) then
                        begin
                            S := Lookup( '', Search_Context ) ; // File was before the after date
                            F.Free ;
                            continue ;
                        end ;
                    end else
                    if( File_Date_Mode = Date_Before ) then
                    begin
                        if( File_Time >= Comparison_Time ) then
                        begin
                            S := Lookup( '', Search_Context ) ; // File was after the before date
                            F.Free ;
                            continue ;
                        end ;
                    end ;
                    if( Owner <> 0 ) then
                    begin
                        if( Owner <> F.Owner ) then
                        begin
                            S := Lookup( '', Search_Context ) ; // File is the wrong owner
                            F.Free ;
                            continue ;
                        end ;
                    end ;
                    F.Free ;

Next we check to see if the file matches the specified date comparison (if any). But this requires that we first open the file. So we open it in read-only mode with all sharing allowed. This is so that COPY will work even if the file is opened by another process (and so it won't cause file access errors for other processes). If the open fails, it probably indicates that the file was deleted between the lookup and the open - always a potential in a pre-emptive multi-tasking system.

Now we can check the appropriate file date with the specified comparison date. If the file is excluded by this check we skip to the next file. Then we check if the file's owner matches the specified owner (if one was specified), likewise exiting if there is a mismatch. Finally, now that we've skipped files that don't match the selection criteria, we close the file.

                    // Confirm operation...
                    if( Confirm ) then // Need to confirm operation with user
                    begin
                        while( True ) do
                        begin
                            if( Operation = Op_Copy ) then
                            begin
                                C := 'Copy' ;
                            end else
                            begin
                                C := 'Append' ;
                            end ;
                            C := trim( lowercase( Get_Command_With_Timeout( C + ' ' + S + '? ' ) ) ) ;
                            if( Is_Prefix( 'yes', C )
                                or
                                Is_Prefix( 'true', C )
                                or
                                Is_Prefix( 'no', C )
                                or
                                Is_Prefix( 'false', C )
                                or
                                Is_Prefix( 'quit', C )
                                or
                                Is_Prefix( 'all', C )
                                or
                                ( C = '1' ) or ( C = '0' ) or ( C = Control_Z )
                              ) then
                            begin
                                break ; // Valid response
                            end ;
                            OS^.OutputLn( RH_SysError, 'COPY-E-COPY_IVRESP, Invalid response' ) ;
                        end ;
                        if( Is_Prefix( 'all', C ) ) then
                        begin
                            Confirm := False ; // No more confirmation required
                        end else
                        if( Is_Prefix( 'no', C ) 
                             or Is_Prefix( 'false', C ) 
                             or ( C = '' ) 
                             or ( C = '0' ) 
                          ) then
                        begin
                            S := Lookup( '', Search_Context ) ;
                            continue ;
                        end else
                        if( Is_Prefix( 'quit', C ) or ( C = Control_Z ) ) then
                        begin
                            Inputs.Clear ;
                            S := '' ;
                            break ;
                        end ;
                    end ; // if( Confirm )

Now that we have a valid candidate input file, we need to confirm the operation with the user. If confirmation was not specified, we skip this code. Otherwise, we prompt the user and get his response. We loop until a valid response is provided, showing an error if the user's response doesn't match one of the valid options. Once we have a valid response, we act on it. If ALL is specified, we clear the Confirm flag so that we no longer ask the user for confirmation. If the user QUITs, we break out of the current file lookup loop after clearing the Inputs list so that the outer loop ends immediately. If the user doesn't confirm this file, we look up the next file and loop. The only other option is that the user confirms the file and we just fall through to the following code (since all invalid responses are checked for above).

                    // Perform operation...
                    O := Substitute_Wildcards( S, Output, DefDev + DefDir ) ;
                    if( Log ) then
                    begin
                        O1 := O ;
                        S1 := S ;
                        if( Style = Style_Condensed ) then
                        begin
                            if( length( S1 ) > 255 ) then
                            begin
                                C := inttostr( Increment ) ;
                                setlength( S1, 255 - length( C ) ) ;
                                S1 := S1 + C ;
                                inc( Increment ) ;
                            end ;
                            if( length( O1 ) > 255 ) then
                            begin
                                C := inttostr( Increment ) ;
                                setlength( O1, 255 - length( C ) ) ;
                                O1 := O1 + C ;
                                inc( Increment ) ;
                            end ;
                        end ;
                        if( Operation = Op_Copy ) then
                        begin
                            C := 'Copying' ;
                        end else
                        begin
                            C := 'Appending' ;
                        end ;
                        OS^.OutputLn( RH_SysOutput, C + ' ' + S1 + ' to ' + O1 ) ;
                    end ;
                    //TODO:Handle RMS
                    //TODO:Handle serial devices
                    //TODO:Handle sequential devices

Having made it through the gauntlet of selection and confirmation, we are now ready to perform the operation. First, we construct the output file name based on the input file, defaulting the device and path if necessary. Next we log the operation to the user, if logging was requested. If condensed style was specified, we limit the filename length(s) to 255 characters. For names longer than that, we trim off some portion of the end of the filename and replace it with a numeric value that we increment each time we have to condense the filename.

Finally, I've included three comments to remind us of things we have yet to address. All of these situations we will cover in future articles.

                    // Open input file...
                    IFlags := 0 ;
                    OFlags := 0 ;
                    if( Read_Check ) then
                    begin
                        IFlags := FAB_V_RCK ;
                    end ;
                    if( SymLink ) then
                    begin
                        IFlags := IFlags or FO_Symlink ;
                    end ;
                    if( Write_Check ) then
                    begin
                        OFlags := FAB_V_WCK ;
                    end ;
                    F := Open( S, FAB_V_GET or FAB_V_SHRALL or IFlags ) ;
                    if( F = nil ) then
                    begin
                        S := Lookup( '', Search_Context ) ;
                        continue ;
                    end ;
                    Count := F.Get_Size ;
                    if( Truncate ) then
                    begin
                        Count := F.Get_EOF ;
                    end ;

Now we determine the open flags for the input and output files and then open the input file. If the open fails, we move on to the next file. Of special note here is the FO_SymLink flag which indicates how a symbolic link is to be opened. A link is simply an indirect reference to a file located elsewhere. When opened, normally, the referenced file is opened transparently to the code that is opening the file. This is done by reading the name of the file from the link file. In other words, a link file's data is the name of the file to actually open. So, when COPY opens a link, it is unknowingly opening the referenced file. But if we use the FO_Symlink flag, the link file itself is what is opened. Thus, we can copy the link itself. Finally, we get the amount of data to copy from the input file. If /TRUNCATE is specified, we limit the amount to that indicated by the logical end of file, rather than the physical end of file.

                    // Prepare output file...
                    if( Operation = Op_Concatenate ) then
                    begin
                        if( OutFile = nil ) then // First one
                        begin
                            if( not Open_Output( O ) ) then
                            begin
                                OS^.OutputLn( RH_SysError, LIB_Get_Exception_Text( 0, 
                                    LIB_Get_Exception_Code( 0, 0 ) ) ) ;
                                continue ;
                            end ;
                        end ;
                    end else
                    begin
                        if( not Open_Output( O ) ) then
                        begin
                            OS^.OutputLn( RH_SysError, LIB_Get_Exception_Text( 0, 
                                LIB_Get_Exception_Code( 0, 0 ) ) ) ;
                            continue ;
                        end ;
                    end ;

Now we prepare the output file. In the case of concatenations, we open it once on the first file (OutFile will be nil in this case). Otherwise, we open it for each copy operation. Any output open errors are displayed.

                    // Copy data...
                    while( Count > 0 ) do
                    begin
                        if( not Read_File( Count ) ) then
                        begin
                            Result := F.IO_Error.Get_Error ;
                            exit ;
                        end ;
                        if( not Write_File( Count ) ) then
                        begin
                            Result := F.IO_Error.Get_Error ;
                            exit ;
                        end ;
                    end ;

Now we loop through the data, reading the input and writing the output. If either the read or write operations fail, we exit.

                    // Copy ancillary streams...
                    I := 1 ;
                    S := F.Stream_Name( I ) ;
                    while( S <> '' ) do
                    begin
                        if( OutFile.Stream_Index( PChar( S ) ) < 1 ) then
                        begin
                            // Stream doesn't exist in output file already
                            L := Outfile.Create_Stream( PChar( S ) ) ;
                            Copy_Stream( I, L ) ;
                        end ;
                        inc( I ) ;
                        S := F.Stream_Name( I ) ;
                    end ;

Now that the data is copied, we need to copy any ancillary data streams. We start with stream 1 and keep going until we run out of streams to copy. First we get the name of the stream, then we see if a stream with that name already exists on the output file. If not, we copy the stream. In this way, the first occurance of a stream name in the input files is the one written to the output, regardless of how many input files have a stream with that name.

                    // Close files...
                    if( Operation = Op_Copy ) then
                    begin
                        if( Contiguous ) then
                        begin
                            OutFile.Contiguous := True ;
                        end ;
                        OutFile.Free ;
                    end ;
                    F.Free ;

                    // Prepare for next lookup
                    S := Lookup( '', Search_Context ) ;
                end ; // while( S <> '' )

When the data copy is finished, if this was a copy operation then we close the output file. But first we make sure it is marked contiguous if that was specified. Finally, we close the input file, look up the next one, and loop back to process it.

                SYS_Lookup_Close( Search_Context ) ;
            end ; // for I := 0 to Inputs.Count - 1
            if( Operation = Op_Concatenate ) then
            begin
                if( Contiguous ) then
                begin
                    OutFile.Contiguous := True ;
                end ;
                OutFile.Free ;
            end ;
            OS.Free ;
        finally
            Inputs.Free ;
            Exclusions.Free ;
        end ;
    end ; // if( UUI.Execute )
end ; // Run

When we run out of files during the lookup, we close the lookup and loop back to the next input file specification, repeating the whole process again. Once we are done with all the input specifications, we can finally close the output file, which is still open for concatenation operations. Then we free the OS instance and various lists.

In the next article, we will look at the supporting routines that we referenced in this, and the previous, article's code.