Eskil

    if {$Pref(parse) != 0} {
        set opts $Pref(ignore)
        if {$Pref(nocase)} {lappend opts -nocase}
        if {$Pref(lineparsewords)} {lappend opts -words}
        set res [eval DiffUtil::diffStrings $opts \$line1 \$line2]
        set dotag 0
        set n [expr {[llength $res] / 2}]
        $::widgets($top,wLine1) insert end [myFormL $doingLine1] "hl$::HighLightCount change"

        $::widgets($top,wLine2) insert end [myFormL $doingLine2] "hl$::HighLightCount change"

        set new1 "new1"
        set new2 "new2"
        set change "change"
        foreach {i1 i2} $res {
            incr n -1
            if {$dotag} {
                if {$n == 1 && $Pref(marklast)} {

    foreach item {wLine1 wDiff1 wLine2 wDiff2} {
        if {[info exists ::widgets($top,$item)]} {
            set w $::widgets($top,$item)
            $w config -cursor $oldcursor2
        }
    }
}





# Read a conflict file and extract the two versions.
proc prepareConflict {top} {
    global Pref

    set ::diff($top,leftFile) [tmpFile]
    set ::diff($top,rightFile) [tmpFile]

            set state left
            set end2 [expr {$rightLine - 1}]
            set start1 $leftLine
        } elseif {[string match >>>>>>* $line] && $state eq "left"} {
            set state both
            regexp {>*\s*(.*)} $line -> leftName
            set end1 [expr {$leftLine - 1}]
            lappend diff($top,conflictDiff) [list \
                    $start1 [expr {$end1 - $start1 + 1}] \
                    $start2 [expr {$end2 - $start2 + 1}]]
        } elseif {$state eq "both"} {
            puts $ch1 $line
            puts $ch2 $line
            incr leftLine
            incr rightLine

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

    close $ch
}





# Get a CVS revision
proc getCvsRev {filename outfile {rev {}}} {
    set old ""
    set dir [file dirname $filename]
    if {$dir != "."} {
        set old [pwd]
        set outfile [file join [pwd] $outfile]

    set filerev [file nativename $filename@@[file join $stream $rev]]
    if {[catch {exec cleartool get -to $outfile $filerev} msg]} {
        tk_messageBox -icon error -title "Cleartool error" -message $msg
        return
    }
}

# Prepare for RCS/CVS diff. Checkout copies of the versions needed.
proc prepareRCS {top} {
    global Pref

















    set revs {}

    # Search for revision options
    if {$::diff($top,doptrev1) != ""} {
        lappend revs $::diff($top,doptrev1)
    }
    if {$::diff($top,doptrev2) != ""} {
        lappend revs $::diff($top,doptrev2)
    }


    switch [llength $revs] {
        0 {
            # Compare local file with latest version.
            set ::diff($top,leftFile) [tmpFile]
            set ::diff($top,rightLabel) $::diff($top,RevFile)
            set ::diff($top,rightFile)  $::diff($top,RevFile)

            set type $::diff($top,modetype)
            set ::diff($top,leftLabel) "$::diff($top,RevFile) ($type)"
            if {$type eq "CVS"} {
                getCvsRev $::diff($top,RevFile) $::diff($top,leftFile)
            } else {
                getRcsRev $::diff($top,RevFile) $::diff($top,leftFile)
            }
        }
        1 {

            # Compare local file with specified version.







            set r [lindex $revs 0]


            set ::diff($top,leftFile) [tmpFile]

            set ::diff($top,rightLabel) $::diff($top,RevFile)
            set ::diff($top,rightFile) $::diff($top,RevFile)

            set type $::diff($top,modetype)
            set ::diff($top,leftLabel) "$::diff($top,RevFile) ($type $r)"
            if {$type eq "CVS"} {
                getCvsRev $::diff($top,RevFile) $::diff($top,leftFile) $r


            } else {
                getRcsRev $::diff($top,RevFile) $::diff($top,leftFile) $r

            }
        }
        default {
            # Compare the two specified versions.
            set r1 [lindex $revs 0]
            set r2 [lindex $revs 1]
            set ::diff($top,leftFile) [tmpFile]
            set ::diff($top,rightFile) [tmpFile]

            set type $::diff($top,modetype)
            set ::diff($top,leftLabel) "$::diff($top,RevFile) ($type $r1)"
            set ::diff($top,rightLabel) "$::diff($top,RevFile) ($type $r2)"
            if {$type eq "CVS"} {
                getCvsRev $::diff($top,RevFile) $::diff($top,leftFile) $r1
                getCvsRev $::diff($top,RevFile) $::diff($top,rightFile) $r2
            } else {
                getRcsRev $::diff($top,RevFile) $::diff($top,leftFile) $r1
                getRcsRev $::diff($top,RevFile) $::diff($top,rightFile) $r2
            }




        }
    }
    # Make sure labels are updated before processing starts
    update idletasks
}

# Clean up after a RCS/CVS/CT diff.
proc cleanupRev {top} {
    global Pref

    clearTmp $::diff($top,rightFile) $::diff($top,leftFile)
    set ::diff($top,rightFile) $::diff($top,RevFile)
    set ::diff($top,leftFile) $::diff($top,RevFile)
}

# Prepare for ClearCase diff. Checkout copies of the versions needed.
proc prepareClearCase {top} {
    global Pref

    # Figure out stream and current version
    if {[catch {exec cleartool ls $::diff($top,RevFile)} info]} {
        puts "Cleartool error: $info"
        return
    }
    set currV {}
    if {![regexp {@@(\S+)\s+from (\S+)\s+Rule} $info -> dummy currV]} {
        regexp {@@(\S+)} $info -> currV
    }
    set stream [file dirname $currV]
    set latest [file tail $currV]

    # Search for revision options
    set revs {}
    if {$::diff($top,doptrev1) != ""} {
        lappend revs $::diff($top,doptrev1)
    }
    if {$::diff($top,doptrev2) != ""} {
        lappend revs $::diff($top,doptrev2)
    }
    foreach rev $revs {
        if {![string is digit -strict $rev] || $rev < 0 || $rev > $latest} {
            puts "Bad revision '$rev'"
            return
        }
    }
    if {[llength $revs] == 0} {
        lappend revs $latest
    }

    switch [llength $revs] {
        1 {
            # Compare local file with specified version.
            set r [lindex $revs 0]
            set ::diff($top,leftFile) [tmpFile]
            set ::diff($top,rightLabel) $::diff($top,RevFile)
            set ::diff($top,rightFile) $::diff($top,RevFile)

            set ::diff($top,leftLabel) "$::diff($top,RevFile) (CT $r)"

            getCtRev $::diff($top,RevFile) $::diff($top,leftFile) $stream $r
        }
        default {
            # Compare the two specified versions.
            set r1 [lindex $revs 0]
            set r2 [lindex $revs 1]
            set ::diff($top,leftFile) [tmpFile]
            set ::diff($top,rightFile) [tmpFile]

            set ::diff($top,leftLabel) "$::diff($top,RevFile) (CT $r1)"
            set ::diff($top,rightLabel) "$::diff($top,RevFile) (CT $r2)"

            getCtRev $::diff($top,RevFile) $::diff($top,leftFile) $stream $r1
            getCtRev $::diff($top,RevFile) $::diff($top,rightFile) $stream $r2
        }
    }
}

# Prepare for a diff by creating needed temporary files
proc prepareFiles {top} {
    set ::diff($top,cleanup) ""
    if {$::diff($top,mode) eq "rev"} {
        if {$::diff($top,modetype) eq "RCS" || $::diff($top,modetype) eq "CVS"} {
            prepareRCS $top
            set ::diff($top,cleanup) "rev"
        } elseif {$::diff($top,modetype) eq "CT"} {
            prepareClearCase $top
            set ::diff($top,cleanup) "rev"
        }
    } elseif {"conflict" eq $::diff($top,mode)} {
        prepareConflict $top
        set ::diff($top,cleanup) "conflict"
    }
}

# Clean up after a diff
proc cleanupFiles {top} {

    normalCursor $top
    showDiff $top 0
    if {$::widgets($top,eqLabel) eq "!"} {
        set ::widgets($top,eqLabel) " "
    }

    cleanupFiles $top
    if {"conflict" eq $::diff($top,mode)} {
        if {$::widgets($top,eqLabel) != "="} {
            makeMergeWin $top
        }
    }
    if {$::diff($top,printFile) != ""} {
        after idle "doPrint $top 1 ; cleanupAndExit all"
    }

            }
        }
    }
    return [eval tk_getOpenFile $args]
}

proc doOpenLeft {top {forget 0}} {
    if {!$forget && [info exists diff($top,leftDir)]} {
        set initDir $::diff($top,leftDir)
    } elseif {[info exists diff($top,rightDir)]} {
        set initDir $::diff($top,rightDir)
    } else {
        set initDir [pwd]
    }

    set apa [myOpenFile -title "Select left file" -initialdir $initDir \
            -parent $top]
    if {$apa != ""} {
        set ::diff($top,leftDir) [file dirname $apa]
        set ::diff($top,leftFile) $apa
        set ::diff($top,leftLabel) $apa
        set ::diff($top,leftOK) 1
        return 1
    }
    return 0
}

proc doOpenRight {top {forget 0}} {
    if {!$forget && [info exists diff($top,rightDir)]} {
        set initDir $::diff($top,rightDir)
    } elseif {[info exists diff($top,leftDir)]} {
        set initDir $::diff($top,leftDir)
    } else {
        set initDir [pwd]
    }

    set apa [myOpenFile -title "Select right file" -initialdir $initDir \
            -parent $top]

    set leftMergeData {}
    set rightMergeData {}

    if {![info exists ::diff($top,changes)]} {
        set ::diff($top,changes) {}
    }

    if {$::diff($top,mode) eq "rev"} {
        if {$::diff($top,modetype) eq "RCS" || $::diff($top,modetype) eq "CVS"} {
            prepareRCS $top
        }
    } elseif {"conflict" eq $::diff($top,mode)} {
        prepareConflict $top
    }

    set ch1 [open $::diff($top,leftFile) r]
    set ch2 [open $::diff($top,rightFile) r]
    set doingLine1 1
    set doingLine2 1
    set changeNo 0
    foreach change $::diff($top,changes) {

    }
    lappend leftMergeData $data1
    lappend rightMergeData $data2

    close $ch1
    close $ch2

    if {$::diff($top,mode) eq "rev"} {
        if {$::diff($top,modetype) eq "RCS" || $::diff($top,modetype) eq "CVS"} {
            cleanupRev $top
        }
    } elseif {"conflict" eq $::diff($top,mode)} {
        cleanupConflict $top
    }
}

# Fill up the merge window with the initial version of merged files.
proc fillMergeWindow {top} {
    global mergeSelection leftMergeData rightMergeData curMergeSel curMerge

    set w $top.merge.t

# Save the merge result.
proc saveMerge {top} {
    set w $top.merge.t

    if {$::diff($top,mergeFile) eq ""} {
        set apa no
        if {"conflict" eq $::diff($top,mode)} {
            set apa [tk_messageBox -parent $top.merge -icon question \
                    -title "Save merge file" -type yesno -message \
                    "Do you want to overwrite the original conflict file?"]
        }
        if {$apa == "yes"} {
            set ::diff($top,mergeFile) $::diff($top,conflictFile)
        } else {
            # Browse
            if {[info exists diff($top,rightDir)]} {
                set initDir $::diff($top,rightDir)
            } elseif {[info exists diff($top,leftDir)]} {
                set initDir $::diff($top,leftDir)
            } else {
                set initDir [pwd]
            }

            set apa [tk_getSaveFile -title "Save merge file" -initialdir $initDir \
                    -parent $top.merge]

    wm protocol $w WM_DELETE_WINDOW "closeMerge $top"

    grid $w.f.rb1 $w.f.rb2 $w.f.rb3 $w.f.rb4 x $w.f.b1 $w.f.b2 x \
            $w.f.bl $w.f.br x x x $w.f.bs $w.f.bq
    grid columnconfigure $w.f {4 7 10 12} -minsize 10
    grid columnconfigure $w.f 10 -weight 1

    if {"conflict" eq $::diff($top,mode)} {
        checkbutton $w.f.bm -text "Pure" -variable diff($top,modetype) \
                -onvalue "Pure" -offvalue "" -command {doDiff}
        grid $w.f.bm -row 0 -column 11
    }

    text $w.t -width 80 -height 20 -xscrollcommand "$w.sbx set" \
            -yscrollcommand "$w.sby set" -font myfont

    if {[winfo exists $top] && [winfo toplevel $top] eq $top} {
        raise $top
        focus -force $top
        return
    }
    destroy $top
    toplevel $top
    lappend diff(diffWindows) $top

    wm title $top "Clip Diff"
    wm protocol $top WM_DELETE_WINDOW "cleanupAndExit $top"
    set t1 [Scroll both \
            text $top.t1 -width 60 -height 35 -font myfont]
    set t2 [Scroll both \
            text $top.t2 -width 60 -height 35 -font myfont]