sort_target Subroutine

public recursive subroutine sort_target(target, mock)

Topologically sort a target for scheduling by recursing over its dependencies.

Checks disk-cached source hashes to determine if objects are up-to-date. Up-to-date sources are tagged as skipped.

On completion, target should either be marked as sorted (target%sorted=.true.) or skipped (target%skip=.true.)

If target is marked as sorted, target%schedule should be an integer greater than zero indicating the region for scheduling

Arguments

Type IntentOptional Attributes Name
type(build_target_t), intent(inout), target :: target
logical, intent(in), optional :: mock

Optionally sort ALL targets if this is a dry run

Source Code

recursive subroutine sort_target(target, mock)
    type(build_target_t), intent(inout), target :: target
    !> Optionally sort ALL targets if this is a dry run
    logical, optional, intent(in) :: mock

    integer :: i, fh, stat
    logical :: dry_run
    
    dry_run = .false.
    if (present(mock)) dry_run = mock

    ! Check if target has already been processed (as a dependency)
    if (target%sorted .or. target%skip) return

    ! Check for a circular dependency
    ! (If target has been touched but not processed)
    if (target%touched) then
        call fpm_stop(1,'(!) Circular dependency found with: '//target%output_file)
    else
        target%touched = .true.  ! Set touched flag
    end if

    ! Load cached source file digest if present
    if (.not.allocated(target%digest_cached) .and. &
         exists(target%output_file) .and. &
         exists(target%output_file//'.digest') .and. &
         (.not.dry_run)) then 

        allocate(target%digest_cached)
        open(newunit=fh,file=target%output_file//'.digest',status='old')
        read(fh,*,iostat=stat) target%digest_cached
        close(fh)

        ! Cached digest is not recognized
        if (stat /= 0) deallocate(target%digest_cached)

    end if
    
    if (dry_run) then 
        
        target%skip = .false.
        
    elseif (allocated(target%source)) then

        ! Skip if target is source-based and source file is unmodified
        if (allocated(target%digest_cached)) then
            if (target%digest_cached == target%source%digest) target%skip = .true.
        end if

    elseif (exists(target%output_file)) then

        ! Skip if target is not source-based and already exists
        target%skip = .true.

    end if

    ! Loop over target dependencies
    target%schedule = 1
    do i=1,size(target%dependencies)

        ! Sort dependency
        call sort_target(target%dependencies(i)%ptr, dry_run)

        if (.not.target%dependencies(i)%ptr%skip) then

            ! Can't skip target if any dependency is not skipped
            target%skip = .false.

            ! Set target schedule after all of its dependencies
            target%schedule = max(target%schedule,target%dependencies(i)%ptr%schedule+1)

        end if

    end do

    ! Mark flag as processed: either sorted or skipped
    target%sorted = .not.target%skip

end subroutine sort_target