sort_target Subroutine

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 target 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

    ! Sort dependencies first: the target digest depends on theirs
    do i=1,size(target%dependencies)

        call sort_target(target%dependencies(i)%ptr, dry_run)

    end do

    ! Skip if target was last built from the same inputs: its source file, if any,
    ! and the digests of its dependencies. These catch a dependency rebuilt by an
    ! earlier run that did not rebuild this target (it stopped early, or did not
    ! include it, as `fpm build` does with tests)
    target%digest = target%compute_digest()
    target%skip = .false.
    if (allocated(target%digest_cached) .and. .not.dry_run) then
        target%skip = target%digest_cached == target%digest
    end if

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

        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