Eskil

    set leftLine 1
    set rightLine 1
    set leftLines {}
    set rightLines {}
    set state none
    set fname ""
    foreach line [split $data \n] {
        # Detect a new file or file name
        # "diff *" handles at least GIT and HG output
        # "Index:" and "=====*" handles at least FOSSIL and SVN output
        set newFile 0
        set newName ""
        if {[string match ======* $line]} {
            set newFile 1
        } elseif {[string match "diff *" $line]} {
            set newFile 1
            # Extract the last non-space. Works reasonably well.
            regexp {\S+\s*$} $line newName
        } elseif {[string match "Index: *" $line]} {
            set newName [string range $line 7 end]
        }

        if {$newFile} {
            if {$state != "none"} {
                displayOnePatch $top $leftLines $rightLines $leftLine $rightLine
            }
            set leftLines {}
            set rightLines {}
            set state none

        }
        if {$newName ne ""} {

            # If fname is set, a file that had no contents has passed.
            # It could be a binary file or some other that the diffing source
            # could not handle.
            # Display the name to see that it is involved. 
            if {$fname ne ""} {
                foreach side {1 2} {
                    emptyLine $top $side
                    insertLine $top $side "" $divider patch
                    insertLine $top $side "" $fname   patch
                    insertLine $top $side "" $divider patch
                }
                addChange $top 4 change 0 0 0 0
            }
            set fname $newName



        }
        if {$newFile || $newName ne ""} {
            continue
        }
        # Detect the first line in a -c style diff
        if {[regexp {^\*\*\* } $line]} {
            if {$state eq "right"} {
                displayOnePatch $top $leftLines $rightLines $leftLine $rightLine
                set leftLines {}
                set rightLines {}

            emptyLine $top $side
            insertLine $top $side "" $divider patch
            insertLine $top $side "" $fname   patch
            insertLine $top $side "" $divider patch
        }
        addChange $top 4 change 0 0 0 0
    }




}

#####################################
# Main diff
#####################################

# Prepare for a diff by creating needed temporary files

# eskil::rev::XXX::get {filename outfile rev}
#
# Get a revision of a file and place it in outfile.
# rev is in any format understood by this system, and
# should be retrieved from ParseRevs

# eskil::rev::XXX::getPatch {revs files {fileListName {}}}
#
# Get a patch of the file tree, between the revisions given.
# revs is in any format understood by this system, and
# should be retrieved from ParseRevs
# If files is non-empty it is a list of files that should be included.
# If fileListName is given, it is a variable name where to place the
# list of files affected by the patch. The list should be cleaned
# through lsort -dictionary -unique.
# NOTE that current directory must be correct before calling.

# eskil::rev::XXX::getChangedFiles {dir revs}
#
# Get a list of files changed between the revisions given.
# revs is in any format understood by this system, and
# should be retrieved from ParseRevs

    if {$old != ""} {
        cd $old
    }
}

# Get a CVS patch
proc eskil::rev::CVS::getPatch {revs files {fileListName {}}} {
    if {$::Pref(context) > 0} {
        set context $::Pref(context)
    } else {
        set context 5
    }
    # TODO: support files
    set cmd [list exec cvs diff -U $context]

        if {[regexp {^(\S+)\s+(\S+)$} $line -> pre file]} {
            lappend changes [file join $dir $file]
        }
    }
    return $changes
}

# Common helper for SVN revisions
proc eskil::rev::SVN::RevsToCmd {revs} {
    set cmd {}






















    set revs2 {}
    foreach rev $revs {
        # TODO: What happens in strange combinations ?
        if {[string match "*://*" $rev]} {
            # Full URL
            lappend cmd $rev
        } else {
            lappend revs2 $rev
        }
    }
    if {[llength $revs2] > 0} {
        lappend cmd -r [join $revs2 :]
    }
    return $cmd
}

# Get a SVN patch
proc eskil::rev::SVN::getPatch {revs files {fileListName {}}} {
    set cmd [list exec svn diff]
    lappend cmd {*}[RevsToCmd $revs]
    lappend cmd {*}$files

    if {[catch {eval $cmd} res]} {
        tk_messageBox -icon error -title "SVN error" -message $res
        return ""
    }
    if {$fileListName ne ""} {
        upvar 1 $fileListName fileList
        set fileList {}
        # SVN will have lines like this to show files:
        #Index: dir1/f11
        foreach line [lsearch -all -inline -regexp [split $res \n] {^Index: }] {
            if {[regexp {Index: (.*)} $line -> fn]} {
                lappend fileList $fn
            }
        }
        set fileList [lsort -dictionary -unique $fileList]
    }

    return $res
}

proc eskil::rev::SVN::getChangedFiles {dir revs} {
    # Must call SVN in top dir to get full changeset
    GetTopDir $dir top tail
    set cmd [list execDir $top svn diff --summarize]
    lappend cmd {*}[RevsToCmd $revs]

    if {[catch {eval $cmd} res]} {
        tk_messageBox -icon error -title "SVN error" -message $res
        return ""
    }
    # Result is one file per line, with an info word before
    set files {}

    if {$old != ""} {
        cd $old
    }
}

# Get a HG patch
proc eskil::rev::HG::getPatch {revs files {fileListName {}}} {

    set cmd [list exec hg diff]
    foreach rev $revs {
        lappend cmd -r $rev
    }
    lappend cmd "--" {*}$files

    if {[catch {eval $cmd} res]} {
        tk_messageBox -icon error -title "HG error" -message $res
        return ""
    }
    if {$fileListName ne ""} {
        upvar 1 $fileListName fileList
        set fileList {}
        # HG will have lines like this to show files:
        #diff -r 533b1d848a1c dir1/f12
        #diff -r 0dba7b280f8f -r 2e84355cc419 f1
        foreach line [lsearch -all -inline -regexp [split $res \n] {^diff -}] {
            if {[regexp {diff (?:-r \w+\s+)*(.*)$} $line -> fn]} {
                lappend fileList $fn
            }
        }
        set fileList [lsort -dictionary -unique $fileList]
    }

    return $res
}

proc eskil::rev::HG::getChangedFiles {dir revs} {
    set cmd [list execDir $dir hg diff --stat]
    foreach rev $revs {
        lappend cmd -r $rev

    if {$old != ""} {
        cd $old
    }
}

# Get a BZR patch
proc eskil::rev::BZR::getPatch {revs files {fileListName {}}} {
    # TODO: support files
    set cmd [list exec bzr diff]
    if {[llength $revs] == 2} {
        lappend cmd -r [lindex $revs 0]..[lindex $revs 1]
    } elseif {[llength $revs] == 1} {
        lappend cmd -r [lindex $revs 0]
    }

# Get an RCS revision
proc eskil::rev::RCS::get {filename outfile {rev {}}} {
    catch {exec co -p$rev [file nativename $filename] \
            > $outfile}
}

# Get a RCS patch
proc eskil::rev::RCS::getPatch {revs files {fileListName {}}} {
    # Not supported yet.
    return ""
}

proc eskil::rev::RCS::getChangedFiles {dir revs} {
    # Not supported yet.
    return ""

# Add file to GIT index
proc eskil::rev::GIT::add {filename} {
    GetTopDir $filename dir tail
    catch {execDir $dir git add $tail}
}

# Get a GIT patch
proc eskil::rev::GIT::getPatch {revs files {fileListName {}}} {
    set cmd [list exec git diff -p]
    if {[llength $revs] == 0} {
        # Always default to HEAD to see changes regardless of index
        lappend cmd HEAD
    } else {
        foreach rev $revs {
            lappend cmd $rev
        }
    }
    lappend cmd "--" {*}$files

    if {[catch {eval $cmd} res]} {
        tk_messageBox -icon error -title "GIT error" -message $res
        return ""
    }
    if {$fileListName ne ""} {
        upvar 1 $fileListName fileList
        set fileList {}
        # GIT will have lines like this to show files:
        #diff --git a/dir1/f12 b/dir1/f12
        foreach line [lsearch -all -inline -regexp [split $res \n] {^diff -}] {
            if {[regexp { a/(.*) b/} $line -> fn]} {
                lappend fileList $fn
            }
        }
        set fileList [lsort -dictionary -unique $fileList]
    }
    
    return $res
}

# Get a GIT change set
proc eskil::rev::GIT::getChangedFiles {dir revs} {
    set cmd [list execDir $dir git diff --name-only]
    if {[llength $revs] == 0} {

        catch {execDir $dir fossil finfo -p $tail > $outfile}
    } else {
        catch {execDir $dir fossil finfo -p $tail -r $rev > $outfile}
    }
}

# Get a FOSSIL patch
proc eskil::rev::FOSSIL::getPatch {revs files {fileListName {}}} {
    set cmd [list exec fossil diff]

    if {[llength $revs] >= 1} {
        lappend cmd --from [lindex $revs 0]
    }
    if {[llength $revs] >= 2} {
        lappend cmd --to [lindex $revs 1]
    }
    # Include added files contents
    lappend cmd -N

    lappend cmd {*}$files


    if {[catch {eval $cmd} res]} {
        tk_messageBox -icon error -title "FOSSIL error" -message $res
        return ""
    }
    if {$fileListName ne ""} {
        upvar 1 $fileListName fileList
        set fileList {}
        # FOSSIL will have lines like this to show files:
        #Index: dir1/f11
        foreach line [lsearch -all -inline -regexp [split $res \n] {^Index: }] {
            if {[regexp {Index: (.*)} $line -> fn]} {
                lappend fileList $fn
            }






        }
        set fileList [lsort -dictionary -unique $fileList]
    }
    return $res
}

proc eskil::rev::FOSSIL::getChangedFiles {dir revs} {
    set cmd [list execDir $dir fossil diff]

    if {[catch {exec cleartool get -to $outfile $filerev} msg]} {
        tk_messageBox -icon error -title "Cleartool error" -message $msg
        return
    }
}

# Get a CT patch
proc eskil::rev::CT::getPatch {revs files {fileListName {}}} {
    # Not supported yet
    return ""
}

proc eskil::rev::CT::getChangedFiles {dir revs} {
    # Not supported yet
    return ""

            $::widgets($top,commit) configure -state normal
        }
        if {[info commands eskil::rev::${type}::revertFile] ne ""} {
            $::widgets($top,revert) configure -state normal
        }
    }

    set fileList {}
    set patch [eskil::rev::${type}::getPatch $revs $files fileList]
    set ::eskil($top,patchFilelist) $fileList
    return $patch
}

##############################################################################
# Utilities
##############################################################################

# Execute a command within a specific dir as pwd

    }

    set res [string trim $::eskil(logdialog)]
    set ::eskil(logdialog) $res

    set todo $postcmd
    if {[llength $postcmd] > 1} {
        # Look through checkbuttons
        set todo {}
        set t 0
        foreach fileName $postcmd {
            if {$::eskil($top,commit,fileselect$t)} {
                lappend todo $fileName
            }
            incr t
        }
        # None left means ignore.
        if {[llength $todo] == 0} {
            return
        }
    }

    # Splash screen for visual feedback
    set now [clock clicks -milliseconds]

}
proc Fill3 {} {
    cd $::work
    exec echo Nisse > dir1/f11
    exec echo Hult  > dir2/f21
    exec echo Lingonben >> f1
}
proc Fill4 {} {
    cd $::work
    exec echo Musse > dir1/f11
    exec echo Pigg  > dir1/f12
    exec echo Mimmi >> dir2/f21
    exec echo Pluto >> f2
}

proc CreateRepo {type} {
    set repoDir [tmpFile]
    file mkdir $repoDir
    switch $type {
        FOSSIL {
            set repo $repoDir/apa.fossil

        HG     { exec hg  add {*}[glob *]}
    }
    exec {*}$cmt "First"
    Fill2
    exec {*}$cmt "Second"
    Fill3
    exec {*}$cmt "Third"
    # Local changes
    Fill4

    # Any cleanup?
    switch $type {
        SVN { exec svn update }
        FOSSIL {exec fossil status --sha1sum}
    }
}

foreach type {FOSSIL GIT SVN HG} {
    test rev-4.$type.1 {
        Setup fake repo
    } -body {
        CreateRepo $type
        # Dump info for debug of setup
        if 0 {
            puts "------------------- $type --------------------"
            puts "--- $::work"
            switch $type {
                FOSSIL { puts [exec fossil timeline -v] }
                GIT    { puts [exec git log --name-only] }
                SVN    { puts [exec svn log --verbose] }
                HG     { puts [exec hg log --verbose] }
            }
        }
        list
    }

    test rev-4.$type.2 {
        GetTopDir

    } -body {
        cd ~
        set f $::work/f1
        set revs [eskil::rev::${type}::ParseRevs $f "-1 0"]
        lsort -dictionary [eskil::rev::${type}::getChangedFiles $f $revs]
    } -match regexp -result {^/\S+/dir1/f11 /\S+/dir2/f21 /\S+/f1$}

    test rev-4.$type.16 {
        getPatch, list of files
    } -body {
        # getPatch needs to be in the checkout
        cd $::work
        set files [list $::work/dir1 $::work/f1 $::work/f2]
        if {$type in "SVN"} {
            # SVN gives full paths when given full paths
            set expect [list $::work/dir1/f11 $::work/dir1/f12 $::work/f2]
        } else {
            set expect [list dir1/f11 dir1/f12 f2]
        }
        set expect [lsort -dictionary $expect]
        set patch [eskil::rev::${type}::getPatch {} $files outFileList]
        if {$outFileList ne $expect} {
            return $outFileList ;#$patch
        } else {
            return 1
        }
    } -result 1

    test rev-4.$type.7 {
        getPatch, list of files
    } -body {
        # getPatch needs to be in the checkout
        cd $::work
        set files [list dir1 f1 f2]
        set expect [list dir1/f11 dir1/f12 f2]
        set expect [lsort -dictionary $expect]
        set patch [eskil::rev::${type}::getPatch {} $files outFileList]
        if {$outFileList ne $expect} {
            return $outFileList ;#$patch
        } else {
            return 1
        }
    } -result 1

    test rev-4.$type.8 {
        getPatch, list of files
    } -body {
        # getPatch needs to be in the checkout
        cd $::work
        set f f1
        set revs [eskil::rev::${type}::ParseRevs $f "-1 0"]
        set files [list dir1 f1 f2]
        set expect [list dir1/f11 f1]
        set expect [lsort -dictionary $expect]
        set patch [eskil::rev::${type}::getPatch $revs $files outFileList]
        if {$outFileList ne $expect} {
            return $outFileList ;#$patch
        } else {
            return 1
        }
    } -result 1
    
    clearTmp
}