Eskil

            }
            set ::dirdiff(leftDir) $d1
            if {$rev2 ne ""} {
                .dirdiffX.l2 configure -text "and rev $rev2..."
                update
                set d2 [eskil::rev::${type}::mount $fullname $rev2]
                set ::dirdiff(rightDir) $d2
            }
            # VcsVfs mounts are thread local. Transfer them to any worker thread
            foreach tid $::eskil(threads) {
                .dirdiffX.l2 configure -text "and rev $rev2... (+thread)"
                update
                vcsvfs::transfer $tid
            }
            destroy .dirdiffX
        }
    }

    destroy .dirdiff
    DirDiff .dirdiff

    if {[file exists $::eskil(thisDir)/../version.txt]} {
        set ch [open $::eskil(thisDir)/../version.txt]
        set ::eskil(diffver) [string trim [read $ch 100]]
        close $ch
    }

    ##nagelfar syntax SubEval c
    set ::eskil(threads) {}
    if {[catch {package require Thread}]} {
        interp create _tinterp_
        interp alias {} SubEval _tinterp_ eval
    } else {
        set tid [thread::create -preserved]
        interp alias {} SubEval {} thread::send $tid
        lappend ::eskil(threads) $tid
    }
    SubEval [list set ::auto_path $::auto_path]
    SubEval [list set ::argv0 $::argv0]
    SubEval [list namespace eval ::starkit {}]
    SubEval [list set ::starkit::topdir $::starkit::topdir]
    SubEval {
        if {![file isdir $::starkit::topdir]} {
            vfs::mk4::Mount $::starkit::topdir $::starkit::topdir
        }
    }
    SubEval [list array set ::eskil [array get ::eskil]]

#----------------------------------------------------------------------
#  Virtual File System for Version Control Systems
#
#  Copyright (c) 2014-2016, Peter Spjuth
#
#  License for vcsvfs package: Same as for Tcl
#----------------------------------------------------------------------

package require vfs
package provide vcsvfs 0.3

namespace eval vcsvfs {
    variable DataRefChan
    variable mpoints {}
    namespace eval fossil {}
    namespace eval svn {}
    namespace eval git {}

            # Read-only, always error
        }
    }
    vfs::filesystem posixerror $::vfs::posix(EACCES)
    return -code error $::vfs::posix(EACCES)
}

# Transfer VcsVfs mount point(s) to another Thread.
# TclVfs (which VcsVfs is based on) mounts are thread local
#
# threadId:   Thread id as created by Thread package
# mountpoint: Mount point to transfer.
#             If no mount point is given, tranfer all current mount points
#
# Returns: None
proc vcsvfs::transfer {threadId {mountpoint {}}} {
    variable mpoints
    thread::send -async $threadId "package require vcsvfs"
    if {$mountpoint eq ""} {
        set data $mpoints
    } else {
        set data [dict create $mountpoint [dict get $mpoints $mountpoint]]
    }
    # Data might be large. Is that a problem? Is there a more efficient way?
    thread::send -async $threadId [list vcsvfs::Receive $data]
}

# Create mount(s) from received data
proc vcsvfs::Receive {data} {
    variable mpoints
    foreach mountpoint [dict keys $data] {
        # Avoid duplicates
        if {![dict exists $mpoints $mountpoint]} {
            dict set mpoints $mountpoint [dict get $data $mountpoint]
            vfs::filesystem mount $mountpoint [list vcsvfs::Vfs]
        }
    }
}

##################################################################
# Test structure
##################################################################
if 0 {