Cleanup of tabs and trailing spaces.

README

@@ -1,100 +1,100 b''
 MERCURIAL QUICK-START
 
 Setting up Mercurial:
 
  Note: some distributions fails to include bits of distutils by
  default, you'll need python-dev to install. You'll also need a C
  compiler and a 3-way merge tool like merge, tkdiff, or kdiff3.
 
  First, unpack the source:
 
  $ tar xvzf mercurial-<ver>.tar.gz
  $ cd mercurial-<ver>
 
  To install system-wide:
 
  $ python setup.py install   # change python to python2.3 if 2.2 is default
 
  To install in your home directory (~/bin and ~/lib, actually), run:
 
  $ python2.3 setup.py install --home=~
  $ export PYTHONPATH=${HOME}/lib/python  # (or lib64/ on some systems)
  $ export PATH=${HOME}/bin:$PATH         # add these to your .bashrc
 
  And finally:
 
  $ hg                                    # test installation, show help
 
  If you get complaints about missing modules, you probably haven't set
  PYTHONPATH correctly.
 
 Setting up a Mercurial project:
 
  $ cd project/
  $ hg init         # creates .hg
  $ hg addremove    # add all unknown files and remove all missing files
  $ hg commit       # commit all changes, edit changelog entry
 
  Mercurial will look for a file named .hgignore in the root of your
  repository which contains a set of regular expressions to ignore in
  file paths.
 
 Branching and merging:
 
  $ hg clone linux linux-work    # create a new branch
  $ cd linux-work
  $ <make changes>
  $ hg commit
  $ cd ../linux
  $ hg pull ../linux-work     # pull changesets from linux-work
  $ hg update -m              # merge the new tip from linux-work into
                              # our working directory
  $ hg commit                 # commit the result of the merge
 
 Importing patches:
 
  Fast:
  $ patch < ../p/foo.patch
  $ hg addremove
  $ hg commit
 
  Faster:
  $ patch < ../p/foo.patch
  $ hg commit `lsdiff -p1 ../p/foo.patch`
 
  Fastest:
- $ cat ../p/patchlist | xargs hg import -p1 -b ../p 
+ $ cat ../p/patchlist | xargs hg import -p1 -b ../p
 
 Exporting a patch:
 
  (make changes)
  $ hg commit
  $ hg tip
  28237:747a537bd090880c29eae861df4d81b245aa0190
  $ hg export 28237 > foo.patch    # export changeset 28237
 
 Network support:
 
  # pull from the primary Mercurial repo
- foo$ hg clone http://selenic.com/hg/ 
+ foo$ hg clone http://selenic.com/hg/
  foo$ cd hg
 
  # export your current repo via HTTP with browsable interface
  foo$ hg serve -n "My repo" -p 80
- 
+
  # pushing changes to a remote repo with SSH
  foo$ hg push ssh://[e-mail]/~/hg/
 
  # merge changes from a remote machine
  bar$ hg pull http://foo/
  bar$ hg update -m        # merge changes into your working directory
 
  # Set up a CGI server on your webserver
  foo$ cp hgweb.cgi ~/public_html/hg/index.cgi
  foo$ emacs ~/public_html/hg/index.cgi # adjust the defaults
 
 For more info:
 
  Documentation in doc/
  Mercurial website at http://selenic.com/mercurial
  Mercurial wiki at http://selenic.com/mercurial/wiki

comparison.txt

@@ -1,31 +1,31 b''
                     Mercurial      git                     BK (*)
 storage             revlog delta   compressed revisions    SCCS weave
 storage naming      by filename    by revision hash        by filename
 merge               file DAGs      changeset DAG           file DAGs?
 consistency         SHA1           SHA1                    CRC
-signable?           yes            yes                     no       
+signable?           yes            yes                     no
 
 retrieve file tip   O(1)           O(1)                    O(revs)
 add rev             O(1)           O(1)                    O(revs)
 find prev file rev  O(1)           O(changesets)           O(revs)
 annotate file       O(revs)        O(changesets)           O(revs)
 find file changeset O(1)           O(changesets)           ?
 
 checkout            O(files)       O(files)                O(revs)?
 commit              O(changes)     O(changes)              ?
                     6 patches/s    6 patches/s             slow
 diff working dir    O(changes)     O(changes)              ?
                     < 1s           < 1s                    ?
 tree diff revs      O(changes)     O(changes)              ?
                     < 1s           < 1s                    ?
 hardlink clone      O(files)       O(revisions)            O(files)
 
 find remote csets   O(log new)     rsync: O(revisions)     ?
                                    git-http: O(changesets)
 pull remote csets   O(patch)       O(modified files)       O(patch)
 
 repo growth         O(patch)       O(revisions)            O(patch)
  kernel history     300M           3.5G?                   250M?
 lines of code       2500           6500 (+ cogito)         ??
 
 * I've never used BK so this is just guesses

contrib/bash_completion

@@ -1,171 +1,171 b''
 #!/bin/bash
 
 _hg_commands()
 {
     local commands="$(hg -v help | sed -e '1,/^list of commands:/d' \
-                                       -e '/^global options:/,$d' \
+				       -e '/^global options:/,$d' \
 				       -e '/^ [^ ]/!d; s/[,:]//g;')"
-    
-    # hide debug commands from users, but complete them if 
+
+    # hide debug commands from users, but complete them if
     # specifically asked for
     if [[ "$cur" == de* ]]; then
 	commands="$commands debugcheckstate debugstate debugindex"
 	commands="$commands debugindexdot debugwalk debugdata"
 	commands="$commands debugancestor debugconfig debugrename"
     fi
     COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "$commands" -- "$cur") )
 }
 
 _hg_paths()
 {
     local paths="$(hg paths | sed -e 's/ = .*$//')"
     COMPREPLY=(${COMPREPLY[@]:-} $( compgen -W "$paths" -- "$cur" ))
 }
 
 _hg_status()
 {
     local files="$( hg status -$1 | cut -b 3- )"
     COMPREPLY=(${COMPREPLY[@]:-} $( compgen -W "$files" -- "$cur" ))
 }
 
 _hg_tags()
 {
     local tags="$(hg tags | sed -e 's/[0-9]*:[a-f0-9]\{40\}$//; s/ *$//')"
     COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "$tags" -- "$cur") )
 }
 
 # this is "kind of" ugly...
 _hg_count_non_option()
 {
     local i count=0
     local filters="$1"
 
     for (( i=1; $i<=$COMP_CWORD; i++ )); do
 	if [[ "${COMP_WORDS[i]}" != -* ]]; then
 	    if [[ ${COMP_WORDS[i-1]} == @($filters|$global_args) ]]; then
 		continue
 	    fi
 	    count=$(($count + 1))
 	fi
     done
 
     echo $(($count - 1))
 }
 
 _hg()
 {
     local cur prev cmd opts i
     # global options that receive an argument
     local global_args='--cwd|-R|--repository'
 
     COMPREPLY=()
     cur="$2"
     prev="$3"
 
-    # searching for the command 
+    # searching for the command
     # (first non-option argument that doesn't follow a global option that
     #  receives an argument)
     for (( i=1; $i<=$COMP_CWORD; i++ )); do
 	if [[ ${COMP_WORDS[i]} != -* ]]; then
 	    if [[ ${COMP_WORDS[i-1]} != @($global_args) ]]; then
 		cmd="${COMP_WORDS[i]}"
 		break
 	    fi
 	fi
     done
 
     if [[ "$cur" == -* ]]; then
 	# this assumes that there are no commands with spaces in the name
 	opts=$(hg -v help $cmd | sed -e '/^ *-/!d; s/ [^- ].*//')
 
 	COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "$opts" -- "$cur") )
 	return
     fi
 
     # global options
     case "$prev" in
 	-R|--repository)
 	    COMPREPLY=(${COMPREPLY[@]:-} $( compgen -d -- "$cur" ))
 	    return
 	;;
 	--cwd)
 	    COMPREPLY=(${COMPREPLY[@]:-} $( compgen -d -- "$cur" ))
 	    return
 	;;
     esac
 
     if [ -z "$cmd" ] || [ $COMP_CWORD -eq $i ]; then
 	_hg_commands
 	return
     fi
 
     # canonicalize command name
     cmd=$(hg -q help "$cmd" | sed -e 's/^hg //; s/ .*//; 1q')
 
     if [ "$cmd" != status ] && [ "$prev" = -r ] || [ "$prev" = --rev ]; then
 	_hg_tags
 	return
     fi
 
     case "$cmd" in
 	help)
 	    _hg_commands
 	;;
 	export|manifest|update)
 	    _hg_tags
 	;;
 	pull|push|outgoing|incoming)
 	    _hg_paths
 	    COMPREPLY=(${COMPREPLY[@]:-} $( compgen -d -- "$cur" ))
 	;;
 	paths)
 	    _hg_paths
 	;;
 	add)
 	    _hg_status "u"
 	;;
 	commit)
 	    _hg_status "mra"
 	;;
 	remove)
 	    _hg_status "r"
 	;;
 	forget)
 	    _hg_status "a"
 	;;
 	diff)
 	    _hg_status "mra"
 	;;
 	revert)
 	    _hg_status "mra"
 	;;
 	clone)
 	    local count=$(_hg_count_non_option)
 	    if [ $count = 1 ]; then
 		_hg_paths
 	    fi
 	    COMPREPLY=(${COMPREPLY[@]:-} $( compgen -d -- "$cur" ))
 	;;
 	debugindex|debugindexdot)
 	    COMPREPLY=(${COMPREPLY[@]:-} $( compgen -f -X "!*.i" -- "$cur" ))
 	;;
 	debugdata)
 	    COMPREPLY=(${COMPREPLY[@]:-} $( compgen -f -X "!*.d" -- "$cur" ))
 	;;
 	cat)
 	    local count=$(_hg_count_non_option '-o|--output')
 	    if [ $count = 2 ]; then
 		_hg_tags
 	    else
 		COMPREPLY=(${COMPREPLY[@]:-} $( compgen -f -- "$cur" ))
 	    fi
 	;;
-	*) 
+	*)
             COMPREPLY=(${COMPREPLY[@]:-} $( compgen -f -- "$cur" ))
 	;;
     esac
 
 }
 
 complete -o bashdefault -o default -F _hg hg 2> /dev/null \
     || complete -o default -F _hg hg

contrib/hgk

@@ -1,3651 +1,3651 b''
 #!/bin/sh
 # Tcl ignores the next line -*- tcl -*- \
 exec wish "$0" -- "${1+$@}"
 
 # Copyright (C) 2005 Paul Mackerras.  All rights reserved.
 # This program is free software; it may be used, copied, modified
 # and distributed under the terms of the GNU General Public Licence,
 # either version 2, or (at your option) any later version.
 
 proc gitdir {} {
     global env
     if {[info exists env(GIT_DIR)]} {
 	return $env(GIT_DIR)
     } else {
 	return ".hg"
     }
 }
 
 proc getcommits {rargs} {
     global commits commfd phase canv mainfont env
     global startmsecs nextupdate ncmupdate
     global ctext maincursor textcursor leftover
 
     # check that we can find a .git directory somewhere...
     set gitdir [gitdir]
     if {![file isdirectory $gitdir]} {
 	error_popup "Cannot find the git directory \"$gitdir\"."
 	exit 1
     }
     set commits {}
     set phase getcommits
     set startmsecs [clock clicks -milliseconds]
     set nextupdate [expr $startmsecs + 100]
     set ncmupdate 1
     if [catch {
 	set parse_args [concat --default HEAD $rargs]
 	set parsed_args [split [eval exec hg debug-rev-parse $parse_args] "\n"]
     }] {
 	# if git-rev-parse failed for some reason...
 	if {$rargs == {}} {
 	    set rargs HEAD
 	}
 	set parsed_args $rargs
     }
     if [catch {
 	set commfd [open "|hg debug-rev-list --header --topo-order --parents $parsed_args" r]
     } err] {
 	puts stderr "Error executing hg debug-rev-list: $err"
 	exit 1
     }
     set leftover {}
     fconfigure $commfd -blocking 0 -translation lf
     fileevent $commfd readable [list getcommitlines $commfd]
     $canv delete all
     $canv create text 3 3 -anchor nw -text "Reading commits..." \
 	-font $mainfont -tags textitems
     . config -cursor watch
     settextcursor watch
 }
 
 proc getcommitlines {commfd}  {
     global commits parents cdate children
     global commitlisted phase commitinfo nextupdate
     global stopped redisplaying leftover
 
     set stuff [read $commfd]
     if {$stuff == {}} {
 	if {![eof $commfd]} return
 	# set it blocking so we wait for the process to terminate
 	fconfigure $commfd -blocking 1
 	if {![catch {close $commfd} err]} {
 	    after idle finishcommits
 	    return
 	}
 	if {[string range $err 0 4] == "usage"} {
 	    set err \
 {Gitk: error reading commits: bad arguments to git-rev-list.
 (Note: arguments to gitk are passed to git-rev-list
 to allow selection of commits to be displayed.)}
 	} else {
 	    set err "Error reading commits: $err"
 	}
 	error_popup $err
 	exit 1
     }
     set start 0
     while 1 {
 	set i [string first "\0" $stuff $start]
 	if {$i < 0} {
 	    append leftover [string range $stuff $start end]
 	    return
 	}
 	set cmit [string range $stuff $start [expr {$i - 1}]]
 	if {$start == 0} {
 	    set cmit "$leftover$cmit"
 	    set leftover {}
 	}
 	set start [expr {$i + 1}]
 	set j [string first "\n" $cmit]
 	set ok 0
 	if {$j >= 0} {
 	    set ids [string range $cmit 0 [expr {$j - 1}]]
 	    set ok 1
 	    foreach id $ids {
 		if {![regexp {^[0-9a-f]{40}$} $id]} {
 		    set ok 0
 		    break
 		}
 	    }
 	}
 	if {!$ok} {
 	    set shortcmit $cmit
 	    if {[string length $shortcmit] > 80} {
 		set shortcmit "[string range $shortcmit 0 80]..."
 	    }
 	    error_popup "Can't parse hg debug-rev-list output: {$shortcmit}"
 	    exit 1
 	}
 	set id [lindex $ids 0]
 	set olds [lrange $ids 1 end]
 	set cmit [string range $cmit [expr {$j + 1}] end]
 	lappend commits $id
 	set commitlisted($id) 1
 	parsecommit $id $cmit 1 [lrange $ids 1 end]
 	drawcommit $id
 	if {[clock clicks -milliseconds] >= $nextupdate} {
 	    doupdate 1
 	}
 	while {$redisplaying} {
 	    set redisplaying 0
 	    if {$stopped == 1} {
 		set stopped 0
 		set phase "getcommits"
 		foreach id $commits {
 		    drawcommit $id
 		    if {$stopped} break
 		    if {[clock clicks -milliseconds] >= $nextupdate} {
 			doupdate 1
 		    }
 		}
 	    }
 	}
     }
 }
 
 proc doupdate {reading} {
     global commfd nextupdate numcommits ncmupdate
 
     if {$reading} {
 	fileevent $commfd readable {}
     }
     update
     set nextupdate [expr {[clock clicks -milliseconds] + 100}]
     if {$numcommits < 100} {
 	set ncmupdate [expr {$numcommits + 1}]
     } elseif {$numcommits < 10000} {
 	set ncmupdate [expr {$numcommits + 10}]
     } else {
 	set ncmupdate [expr {$numcommits + 100}]
     }
     if {$reading} {
 	fileevent $commfd readable [list getcommitlines $commfd]
     }
 }
 
 proc readcommit {id} {
     if [catch {set contents [exec hg debug-cat-file commit $id]}] return
     parsecommit $id $contents 0 {}
 }
 
 proc parsecommit {id contents listed olds} {
     global commitinfo children nchildren parents nparents cdate ncleft
 
     set inhdr 1
     set comment {}
     set headline {}
     set auname {}
     set audate {}
     set comname {}
     set comdate {}
     if {![info exists nchildren($id)]} {
 	set children($id) {}
 	set nchildren($id) 0
 	set ncleft($id) 0
     }
     set parents($id) $olds
     set nparents($id) [llength $olds]
     foreach p $olds {
 	if {![info exists nchildren($p)]} {
 	    set children($p) [list $id]
 	    set nchildren($p) 1
 	    set ncleft($p) 1
 	} elseif {[lsearch -exact $children($p) $id] < 0} {
 	    lappend children($p) $id
 	    incr nchildren($p)
 	    incr ncleft($p)
 	}
     }
     foreach line [split $contents "\n"] {
 	if {$inhdr} {
 	    if {$line == {}} {
 		set inhdr 0
 	    } else {
 		set tag [lindex $line 0]
 		if {$tag == "author"} {
 		    set x [expr {[llength $line] - 2}]
 		    set audate [lindex $line $x]
 		    set auname [lrange $line 1 [expr {$x - 1}]]
 		} elseif {$tag == "committer"} {
 		    set x [expr {[llength $line] - 2}]
 		    set comdate [lindex $line $x]
 		    set comname [lrange $line 1 [expr {$x - 1}]]
 		}
 	    }
 	} else {
 	    if {$comment == {}} {
 		set headline [string trim $line]
 	    } else {
 		append comment "\n"
 	    }
 	    if {!$listed} {
 		# git-rev-list indents the comment by 4 spaces;
 		# if we got this via git-cat-file, add the indentation
 		append comment "    "
 	    }
 	    append comment $line
 	}
     }
     if {$audate != {}} {
 	set audate [clock format $audate -format "%Y-%m-%d %H:%M:%S"]
     }
     if {$comdate != {}} {
 	set cdate($id) $comdate
 	set comdate [clock format $comdate -format "%Y-%m-%d %H:%M:%S"]
     }
     set commitinfo($id) [list $headline $auname $audate \
 			     $comname $comdate $comment]
 }
 
 proc readrefs {} {
     global tagids idtags headids idheads tagcontents
 
     set tags [exec hg tags]
     set lines [split $tags '\n']
     foreach f $lines {
 	set f [regexp -all -inline {\S+} $f]
 	set direct [lindex $f 0]
 	set full [lindex $f 1]
 	set sha [split $full ':']
 	set tag [lindex $sha 1]
 	lappend tagids($direct) $tag
 	lappend idtags($tag) $direct
     }
 }
 
 proc readotherrefs {base dname excl} {
     global otherrefids idotherrefs
 
     set git [gitdir]
     set files [glob -nocomplain -types f [file join $git $base *]]
     foreach f $files {
 	catch {
 	    set fd [open $f r]
 	    set line [read $fd 40]
 	    if {[regexp {^[0-9a-f]{40}} $line id]} {
 		set name "$dname[file tail $f]"
 		set otherrefids($name) $id
 		lappend idotherrefs($id) $name
 	    }
 	    close $fd
 	}
     }
     set dirs [glob -nocomplain -types d [file join $git $base *]]
     foreach d $dirs {
 	set dir [file tail $d]
 	if {[lsearch -exact $excl $dir] >= 0} continue
 	readotherrefs [file join $base $dir] "$dname$dir/" {}
     }
 }
 
 proc error_popup msg {
     set w .error
     toplevel $w
     wm transient $w .
     message $w.m -text $msg -justify center -aspect 400
     pack $w.m -side top -fill x -padx 20 -pady 20
     button $w.ok -text OK -command "destroy $w"
     pack $w.ok -side bottom -fill x
     bind $w <Visibility> "grab $w; focus $w"
     tkwait window $w
 }
 
 proc makewindow {} {
     global canv canv2 canv3 linespc charspc ctext cflist textfont
     global findtype findtypemenu findloc findstring fstring geometry
     global entries sha1entry sha1string sha1but
     global maincursor textcursor curtextcursor
     global rowctxmenu gaudydiff mergemax
 
     menu .bar
     .bar add cascade -label "File" -menu .bar.file
     menu .bar.file
     .bar.file add command -label "Reread references" -command rereadrefs
     .bar.file add command -label "Quit" -command doquit
     menu .bar.help
     .bar add cascade -label "Help" -menu .bar.help
     .bar.help add command -label "About gitk" -command about
     . configure -menu .bar
 
     if {![info exists geometry(canv1)]} {
 	set geometry(canv1) [expr 45 * $charspc]
 	set geometry(canv2) [expr 30 * $charspc]
 	set geometry(canv3) [expr 15 * $charspc]
 	set geometry(canvh) [expr 25 * $linespc + 4]
 	set geometry(ctextw) 80
 	set geometry(ctexth) 30
 	set geometry(cflistw) 30
     }
     panedwindow .ctop -orient vertical
     if {[info exists geometry(width)]} {
 	.ctop conf -width $geometry(width) -height $geometry(height)
 	set texth [expr {$geometry(height) - $geometry(canvh) - 56}]
 	set geometry(ctexth) [expr {($texth - 8) /
 				    [font metrics $textfont -linespace]}]
     }
     frame .ctop.top
     frame .ctop.top.bar
     pack .ctop.top.bar -side bottom -fill x
     set cscroll .ctop.top.csb
     scrollbar $cscroll -command {allcanvs yview} -highlightthickness 0
     pack $cscroll -side right -fill y
     panedwindow .ctop.top.clist -orient horizontal -sashpad 0 -handlesize 4
     pack .ctop.top.clist -side top -fill both -expand 1
     .ctop add .ctop.top
     set canv .ctop.top.clist.canv
     canvas $canv -height $geometry(canvh) -width $geometry(canv1) \
 	-bg white -bd 0 \
 	-yscrollincr $linespc -yscrollcommand "$cscroll set"
     .ctop.top.clist add $canv
     set canv2 .ctop.top.clist.canv2
     canvas $canv2 -height $geometry(canvh) -width $geometry(canv2) \
 	-bg white -bd 0 -yscrollincr $linespc
     .ctop.top.clist add $canv2
     set canv3 .ctop.top.clist.canv3
     canvas $canv3 -height $geometry(canvh) -width $geometry(canv3) \
 	-bg white -bd 0 -yscrollincr $linespc
     .ctop.top.clist add $canv3
     bind .ctop.top.clist <Configure> {resizeclistpanes %W %w}
 
     set sha1entry .ctop.top.bar.sha1
     set entries $sha1entry
     set sha1but .ctop.top.bar.sha1label
     button $sha1but -text "SHA1 ID: " -state disabled -relief flat \
 	-command gotocommit -width 8
     $sha1but conf -disabledforeground [$sha1but cget -foreground]
     pack .ctop.top.bar.sha1label -side left
     entry $sha1entry -width 40 -font $textfont -textvariable sha1string
     trace add variable sha1string write sha1change
     pack $sha1entry -side left -pady 2
 
     image create bitmap bm-left -data {
 	#define left_width 16
 	#define left_height 16
 	static unsigned char left_bits[] = {
 	0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
 	0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
 	0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
     }
     image create bitmap bm-right -data {
 	#define right_width 16
 	#define right_height 16
 	static unsigned char right_bits[] = {
 	0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
 	0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
 	0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
     }
     button .ctop.top.bar.leftbut -image bm-left -command goback \
 	-state disabled -width 26
     pack .ctop.top.bar.leftbut -side left -fill y
     button .ctop.top.bar.rightbut -image bm-right -command goforw \
 	-state disabled -width 26
     pack .ctop.top.bar.rightbut -side left -fill y
 
     button .ctop.top.bar.findbut -text "Find" -command dofind
     pack .ctop.top.bar.findbut -side left
     set findstring {}
     set fstring .ctop.top.bar.findstring
     lappend entries $fstring
     entry $fstring -width 30 -font $textfont -textvariable findstring
     pack $fstring -side left -expand 1 -fill x
     set findtype Exact
     set findtypemenu [tk_optionMenu .ctop.top.bar.findtype \
 			  findtype Exact IgnCase Regexp]
     set findloc "All fields"
     tk_optionMenu .ctop.top.bar.findloc findloc "All fields" Headline \
 	Comments Author Committer Files Pickaxe
     pack .ctop.top.bar.findloc -side right
     pack .ctop.top.bar.findtype -side right
     # for making sure type==Exact whenever loc==Pickaxe
     trace add variable findloc write findlocchange
 
     panedwindow .ctop.cdet -orient horizontal
     .ctop add .ctop.cdet
     frame .ctop.cdet.left
     set ctext .ctop.cdet.left.ctext
     text $ctext -bg white -state disabled -font $textfont \
 	-width $geometry(ctextw) -height $geometry(ctexth) \
 	-yscrollcommand ".ctop.cdet.left.sb set" -wrap none
     scrollbar .ctop.cdet.left.sb -command "$ctext yview"
     pack .ctop.cdet.left.sb -side right -fill y
     pack $ctext -side left -fill both -expand 1
     .ctop.cdet add .ctop.cdet.left
 
     $ctext tag conf filesep -font [concat $textfont bold] -back "#aaaaaa"
     if {$gaudydiff} {
 	$ctext tag conf hunksep -back blue -fore white
 	$ctext tag conf d0 -back "#ff8080"
 	$ctext tag conf d1 -back green
     } else {
 	$ctext tag conf hunksep -fore blue
 	$ctext tag conf d0 -fore red
 	$ctext tag conf d1 -fore "#00a000"
 	$ctext tag conf m0 -fore red
 	$ctext tag conf m1 -fore blue
 	$ctext tag conf m2 -fore green
 	$ctext tag conf m3 -fore purple
 	$ctext tag conf m4 -fore brown
 	$ctext tag conf mmax -fore darkgrey
 	set mergemax 5
 	$ctext tag conf mresult -font [concat $textfont bold]
 	$ctext tag conf msep -font [concat $textfont bold]
 	$ctext tag conf found -back yellow
     }
 
     frame .ctop.cdet.right
     set cflist .ctop.cdet.right.cfiles
     listbox $cflist -bg white -selectmode extended -width $geometry(cflistw) \
 	-yscrollcommand ".ctop.cdet.right.sb set"
     scrollbar .ctop.cdet.right.sb -command "$cflist yview"
     pack .ctop.cdet.right.sb -side right -fill y
     pack $cflist -side left -fill both -expand 1
     .ctop.cdet add .ctop.cdet.right
     bind .ctop.cdet <Configure> {resizecdetpanes %W %w}
 
     pack .ctop -side top -fill both -expand 1
 
     bindall <1> {selcanvline %W %x %y}
     #bindall <B1-Motion> {selcanvline %W %x %y}
     bindall <ButtonRelease-4> "allcanvs yview scroll -5 units"
     bindall <ButtonRelease-5> "allcanvs yview scroll 5 units"
     bindall <2> "allcanvs scan mark 0 %y"
     bindall <B2-Motion> "allcanvs scan dragto 0 %y"
     bind . <Key-Up> "selnextline -1"
     bind . <Key-Down> "selnextline 1"
     bind . <Key-Prior> "allcanvs yview scroll -1 pages"
     bind . <Key-Next> "allcanvs yview scroll 1 pages"
     bindkey <Key-Delete> "$ctext yview scroll -1 pages"
     bindkey <Key-BackSpace> "$ctext yview scroll -1 pages"
     bindkey <Key-space> "$ctext yview scroll 1 pages"
     bindkey p "selnextline -1"
     bindkey n "selnextline 1"
     bindkey b "$ctext yview scroll -1 pages"
     bindkey d "$ctext yview scroll 18 units"
     bindkey u "$ctext yview scroll -18 units"
     bindkey / {findnext 1}
     bindkey <Key-Return> {findnext 0}
     bindkey ? findprev
     bindkey f nextfile
     bind . <Control-q> doquit
     bind . <Control-f> dofind
     bind . <Control-g> {findnext 0}
     bind . <Control-r> findprev
     bind . <Control-equal> {incrfont 1}
     bind . <Control-KP_Add> {incrfont 1}
     bind . <Control-minus> {incrfont -1}
     bind . <Control-KP_Subtract> {incrfont -1}
     bind $cflist <<ListboxSelect>> listboxsel
     bind . <Destroy> {savestuff %W}
     bind . <Button-1> "click %W"
     bind $fstring <Key-Return> dofind
     bind $sha1entry <Key-Return> gotocommit
     bind $sha1entry <<PasteSelection>> clearsha1
 
     set maincursor [. cget -cursor]
     set textcursor [$ctext cget -cursor]
     set curtextcursor $textcursor
 
     set rowctxmenu .rowctxmenu
     menu $rowctxmenu -tearoff 0
     $rowctxmenu add command -label "Diff this -> selected" \
 	-command {diffvssel 0}
     $rowctxmenu add command -label "Diff selected -> this" \
 	-command {diffvssel 1}
     $rowctxmenu add command -label "Make patch" -command mkpatch
     $rowctxmenu add command -label "Create tag" -command mktag
     $rowctxmenu add command -label "Write commit to file" -command writecommit
 }
 
 # when we make a key binding for the toplevel, make sure
 # it doesn't get triggered when that key is pressed in the
 # find string entry widget.
 proc bindkey {ev script} {
     global entries
     bind . $ev $script
     set escript [bind Entry $ev]
     if {$escript == {}} {
 	set escript [bind Entry <Key>]
     }
     foreach e $entries {
 	bind $e $ev "$escript; break"
     }
 }
 
 # set the focus back to the toplevel for any click outside
 # the entry widgets
 proc click {w} {
     global entries
     foreach e $entries {
 	if {$w == $e} return
     }
     focus .
 }
 
 proc savestuff {w} {
     global canv canv2 canv3 ctext cflist mainfont textfont
     global stuffsaved findmergefiles gaudydiff maxgraphpct
     global maxwidth
 
     if {$stuffsaved} return
     if {![winfo viewable .]} return
     catch {
 	set f [open "~/.gitk-new" w]
 	puts $f [list set mainfont $mainfont]
 	puts $f [list set textfont $textfont]
 	puts $f [list set findmergefiles $findmergefiles]
 	puts $f [list set gaudydiff $gaudydiff]
 	puts $f [list set maxgraphpct $maxgraphpct]
 	puts $f [list set maxwidth $maxwidth]
 	puts $f "set geometry(width) [winfo width .ctop]"
 	puts $f "set geometry(height) [winfo height .ctop]"
 	puts $f "set geometry(canv1) [expr [winfo width $canv]-2]"
 	puts $f "set geometry(canv2) [expr [winfo width $canv2]-2]"
 	puts $f "set geometry(canv3) [expr [winfo width $canv3]-2]"
 	puts $f "set geometry(canvh) [expr [winfo height $canv]-2]"
 	set wid [expr {([winfo width $ctext] - 8) \
 			   / [font measure $textfont "0"]}]
 	puts $f "set geometry(ctextw) $wid"
 	set wid [expr {([winfo width $cflist] - 11) \
 			   / [font measure [$cflist cget -font] "0"]}]
 	puts $f "set geometry(cflistw) $wid"
 	close $f
 	file rename -force "~/.gitk-new" "~/.gitk"
     }
     set stuffsaved 1
 }
 
 proc resizeclistpanes {win w} {
     global oldwidth
     if [info exists oldwidth($win)] {
 	set s0 [$win sash coord 0]
 	set s1 [$win sash coord 1]
 	if {$w < 60} {
 	    set sash0 [expr {int($w/2 - 2)}]
 	    set sash1 [expr {int($w*5/6 - 2)}]
 	} else {
 	    set factor [expr {1.0 * $w / $oldwidth($win)}]
 	    set sash0 [expr {int($factor * [lindex $s0 0])}]
 	    set sash1 [expr {int($factor * [lindex $s1 0])}]
 	    if {$sash0 < 30} {
 		set sash0 30
 	    }
 	    if {$sash1 < $sash0 + 20} {
 		set sash1 [expr $sash0 + 20]
 	    }
 	    if {$sash1 > $w - 10} {
 		set sash1 [expr $w - 10]
 		if {$sash0 > $sash1 - 20} {
 		    set sash0 [expr $sash1 - 20]
 		}
 	    }
 	}
 	$win sash place 0 $sash0 [lindex $s0 1]
 	$win sash place 1 $sash1 [lindex $s1 1]
     }
     set oldwidth($win) $w
 }
 
 proc resizecdetpanes {win w} {
     global oldwidth
     if [info exists oldwidth($win)] {
 	set s0 [$win sash coord 0]
 	if {$w < 60} {
 	    set sash0 [expr {int($w*3/4 - 2)}]
 	} else {
 	    set factor [expr {1.0 * $w / $oldwidth($win)}]
 	    set sash0 [expr {int($factor * [lindex $s0 0])}]
 	    if {$sash0 < 45} {
 		set sash0 45
 	    }
 	    if {$sash0 > $w - 15} {
 		set sash0 [expr $w - 15]
 	    }
 	}
 	$win sash place 0 $sash0 [lindex $s0 1]
     }
     set oldwidth($win) $w
 }
 
 proc allcanvs args {
     global canv canv2 canv3
     eval $canv $args
     eval $canv2 $args
     eval $canv3 $args
 }
 
 proc bindall {event action} {
     global canv canv2 canv3
     bind $canv $event $action
     bind $canv2 $event $action
     bind $canv3 $event $action
 }
 
 proc about {} {
     set w .about
     if {[winfo exists $w]} {
 	raise $w
 	return
     }
     toplevel $w
     wm title $w "About gitk"
     message $w.m -text {
 Gitk version 1.2
 
 Copyright � 2005 Paul Mackerras
 
 Use and redistribute under the terms of the GNU General Public License} \
 	    -justify center -aspect 400
     pack $w.m -side top -fill x -padx 20 -pady 20
     button $w.ok -text Close -command "destroy $w"
     pack $w.ok -side bottom
 }
 
 proc assigncolor {id} {
     global commitinfo colormap commcolors colors nextcolor
     global parents nparents children nchildren
     global cornercrossings crossings
 
     if [info exists colormap($id)] return
     set ncolors [llength $colors]
     if {$nparents($id) <= 1 && $nchildren($id) == 1} {
 	set child [lindex $children($id) 0]
 	if {[info exists colormap($child)]
 	    && $nparents($child) == 1} {
 	    set colormap($id) $colormap($child)
 	    return
 	}
     }
     set badcolors {}
     if {[info exists cornercrossings($id)]} {
 	foreach x $cornercrossings($id) {
 	    if {[info exists colormap($x)]
 		&& [lsearch -exact $badcolors $colormap($x)] < 0} {
 		lappend badcolors $colormap($x)
 	    }
 	}
 	if {[llength $badcolors] >= $ncolors} {
 	    set badcolors {}
 	}
     }
     set origbad $badcolors
     if {[llength $badcolors] < $ncolors - 1} {
 	if {[info exists crossings($id)]} {
 	    foreach x $crossings($id) {
 		if {[info exists colormap($x)]
 		    && [lsearch -exact $badcolors $colormap($x)] < 0} {
 		    lappend badcolors $colormap($x)
 		}
 	    }
 	    if {[llength $badcolors] >= $ncolors} {
 		set badcolors $origbad
 	    }
 	}
 	set origbad $badcolors
     }
     if {[llength $badcolors] < $ncolors - 1} {
 	foreach child $children($id) {
 	    if {[info exists colormap($child)]
 		&& [lsearch -exact $badcolors $colormap($child)] < 0} {
 		lappend badcolors $colormap($child)
 	    }
 	    if {[info exists parents($child)]} {
 		foreach p $parents($child) {
 		    if {[info exists colormap($p)]
 			&& [lsearch -exact $badcolors $colormap($p)] < 0} {
 			lappend badcolors $colormap($p)
 		    }
 		}
 	    }
 	}
 	if {[llength $badcolors] >= $ncolors} {
 	    set badcolors $origbad
 	}
     }
     for {set i 0} {$i <= $ncolors} {incr i} {
 	set c [lindex $colors $nextcolor]
 	if {[incr nextcolor] >= $ncolors} {
 	    set nextcolor 0
 	}
 	if {[lsearch -exact $badcolors $c]} break
     }
     set colormap($id) $c
 }
 
 proc initgraph {} {
     global canvy canvy0 lineno numcommits nextcolor linespc
     global mainline mainlinearrow sidelines
     global nchildren ncleft
     global displist nhyperspace
 
     allcanvs delete all
     set nextcolor 0
     set canvy $canvy0
     set lineno -1
     set numcommits 0
     catch {unset mainline}
     catch {unset mainlinearrow}
     catch {unset sidelines}
     foreach id [array names nchildren] {
 	set ncleft($id) $nchildren($id)
     }
     set displist {}
     set nhyperspace 0
 }
 
 proc bindline {t id} {
     global canv
 
     $canv bind $t <Enter> "lineenter %x %y $id"
     $canv bind $t <Motion> "linemotion %x %y $id"
     $canv bind $t <Leave> "lineleave $id"
     $canv bind $t <Button-1> "lineclick %x %y $id 1"
 }
 
 proc drawlines {id xtra} {
     global mainline mainlinearrow sidelines lthickness colormap canv
 
     $canv delete lines.$id
     if {[info exists mainline($id)]} {
 	set t [$canv create line $mainline($id) \
 		   -width [expr {($xtra + 1) * $lthickness}] \
 		   -fill $colormap($id) -tags lines.$id \
 		   -arrow $mainlinearrow($id)]
 	$canv lower $t
 	bindline $t $id
     }
     if {[info exists sidelines($id)]} {
 	foreach ls $sidelines($id) {
 	    set coords [lindex $ls 0]
 	    set thick [lindex $ls 1]
 	    set arrow [lindex $ls 2]
 	    set t [$canv create line $coords -fill $colormap($id) \
 		       -width [expr {($thick + $xtra) * $lthickness}] \
 		       -arrow $arrow -tags lines.$id]
 	    $canv lower $t
 	    bindline $t $id
 	}
     }
 }
 
 # level here is an index in displist
 proc drawcommitline {level} {
     global parents children nparents displist
     global canv canv2 canv3 mainfont namefont canvy linespc
     global lineid linehtag linentag linedtag commitinfo
     global colormap numcommits currentparents dupparents
     global idtags idline idheads idotherrefs
     global lineno lthickness mainline mainlinearrow sidelines
     global commitlisted rowtextx idpos lastuse displist
     global oldnlines olddlevel olddisplist
 
     incr numcommits
     incr lineno
     set id [lindex $displist $level]
     set lastuse($id) $lineno
     set lineid($lineno) $id
     set idline($id) $lineno
     set ofill [expr {[info exists commitlisted($id)]? "blue": "white"}]
     if {![info exists commitinfo($id)]} {
 	readcommit $id
 	if {![info exists commitinfo($id)]} {
 	    set commitinfo($id) {"No commit information available"}
 	    set nparents($id) 0
 	}
     }
     assigncolor $id
     set currentparents {}
     set dupparents {}
     if {[info exists commitlisted($id)] && [info exists parents($id)]} {
 	foreach p $parents($id) {
 	    if {[lsearch -exact $currentparents $p] < 0} {
 		lappend currentparents $p
 	    } else {
 		# remember that this parent was listed twice
 		lappend dupparents $p
 	    }
 	}
     }
     set x [xcoord $level $level $lineno]
     set y1 $canvy
     set canvy [expr $canvy + $linespc]
     allcanvs conf -scrollregion \
 	[list 0 0 0 [expr $y1 + 0.5 * $linespc + 2]]
     if {[info exists mainline($id)]} {
 	lappend mainline($id) $x $y1
 	if {$mainlinearrow($id) ne "none"} {
 	    set mainline($id) [trimdiagstart $mainline($id)]
 	}
     }
     drawlines $id 0
     set orad [expr {$linespc / 3}]
     set t [$canv create oval [expr $x - $orad] [expr $y1 - $orad] \
 	       [expr $x + $orad - 1] [expr $y1 + $orad - 1] \
 	       -fill $ofill -outline black -width 1]
     $canv raise $t
     $canv bind $t <1> {selcanvline {} %x %y}
     set xt [xcoord [llength $displist] $level $lineno]
     if {[llength $currentparents] > 2} {
 	set xt [expr {$xt + ([llength $currentparents] - 2) * $linespc}]
     }
     set rowtextx($lineno) $xt
     set idpos($id) [list $x $xt $y1]
     if {[info exists idtags($id)] || [info exists idheads($id)]
 	|| [info exists idotherrefs($id)]} {
 	set xt [drawtags $id $x $xt $y1]
     }
     set headline [lindex $commitinfo($id) 0]
     set name [lindex $commitinfo($id) 1]
     set date [lindex $commitinfo($id) 2]
     set linehtag($lineno) [$canv create text $xt $y1 -anchor w \
 			       -text $headline -font $mainfont ]
     $canv bind $linehtag($lineno) <Button-3> "rowmenu %X %Y $id"
     set linentag($lineno) [$canv2 create text 3 $y1 -anchor w \
 			       -text $name -font $namefont]
     set linedtag($lineno) [$canv3 create text 3 $y1 -anchor w \
 			       -text $date -font $mainfont]
 
     set olddlevel $level
     set olddisplist $displist
     set oldnlines [llength $displist]
 }
 
 proc drawtags {id x xt y1} {
     global idtags idheads idotherrefs
     global linespc lthickness
     global canv mainfont idline rowtextx
 
     set marks {}
     set ntags 0
     set nheads 0
     if {[info exists idtags($id)]} {
 	set marks $idtags($id)
 	set ntags [llength $marks]
     }
     if {[info exists idheads($id)]} {
 	set marks [concat $marks $idheads($id)]
 	set nheads [llength $idheads($id)]
     }
     if {[info exists idotherrefs($id)]} {
 	set marks [concat $marks $idotherrefs($id)]
     }
     if {$marks eq {}} {
 	return $xt
     }
 
     set delta [expr {int(0.5 * ($linespc - $lthickness))}]
     set yt [expr $y1 - 0.5 * $linespc]
     set yb [expr $yt + $linespc - 1]
     set xvals {}
     set wvals {}
     foreach tag $marks {
 	set wid [font measure $mainfont $tag]
 	lappend xvals $xt
 	lappend wvals $wid
 	set xt [expr {$xt + $delta + $wid + $lthickness + $linespc}]
     }
     set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
 	       -width $lthickness -fill black -tags tag.$id]
     $canv lower $t
     foreach tag $marks x $xvals wid $wvals {
 	set xl [expr $x + $delta]
 	set xr [expr $x + $delta + $wid + $lthickness]
 	if {[incr ntags -1] >= 0} {
 	    # draw a tag
 	    set t [$canv create polygon $x [expr $yt + $delta] $xl $yt \
 		       $xr $yt $xr $yb $xl $yb $x [expr $yb - $delta] \
 		       -width 1 -outline black -fill yellow -tags tag.$id]
 	    $canv bind $t <1> [list showtag $tag 1]
 	    set rowtextx($idline($id)) [expr {$xr + $linespc}]
 	} else {
 	    # draw a head or other ref
 	    if {[incr nheads -1] >= 0} {
 		set col green
 	    } else {
 		set col "#ddddff"
 	    }
 	    set xl [expr $xl - $delta/2]
 	    $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
 		-width 1 -outline black -fill $col -tags tag.$id
 	}
 	set t [$canv create text $xl $y1 -anchor w -text $tag \
 		   -font $mainfont -tags tag.$id]
 	if {$ntags >= 0} {
 	    $canv bind $t <1> [list showtag $tag 1]
 	}
     }
     return $xt
 }
 
 proc notecrossings {id lo hi corner} {
     global olddisplist crossings cornercrossings
 
     for {set i $lo} {[incr i] < $hi} {} {
 	set p [lindex $olddisplist $i]
 	if {$p == {}} continue
 	if {$i == $corner} {
 	    if {![info exists cornercrossings($id)]
 		|| [lsearch -exact $cornercrossings($id) $p] < 0} {
 		lappend cornercrossings($id) $p
 	    }
 	    if {![info exists cornercrossings($p)]
 		|| [lsearch -exact $cornercrossings($p) $id] < 0} {
 		lappend cornercrossings($p) $id
 	    }
 	} else {
 	    if {![info exists crossings($id)]
 		|| [lsearch -exact $crossings($id) $p] < 0} {
 		lappend crossings($id) $p
 	    }
 	    if {![info exists crossings($p)]
 		|| [lsearch -exact $crossings($p) $id] < 0} {
 		lappend crossings($p) $id
 	    }
 	}
     }
 }
 
 proc xcoord {i level ln} {
     global canvx0 xspc1 xspc2
 
     set x [expr {$canvx0 + $i * $xspc1($ln)}]
     if {$i > 0 && $i == $level} {
 	set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
     } elseif {$i > $level} {
 	set x [expr {$x + $xspc2 - $xspc1($ln)}]
     }
     return $x
 }
 
 # it seems Tk can't draw arrows on the end of diagonal line segments...
 proc trimdiagend {line} {
     while {[llength $line] > 4} {
 	set x1 [lindex $line end-3]
 	set y1 [lindex $line end-2]
 	set x2 [lindex $line end-1]
 	set y2 [lindex $line end]
 	if {($x1 == $x2) != ($y1 == $y2)} break
 	set line [lreplace $line end-1 end]
     }
     return $line
 }
 
 proc trimdiagstart {line} {
     while {[llength $line] > 4} {
 	set x1 [lindex $line 0]
 	set y1 [lindex $line 1]
 	set x2 [lindex $line 2]
 	set y2 [lindex $line 3]
 	if {($x1 == $x2) != ($y1 == $y2)} break
 	set line [lreplace $line 0 1]
     }
     return $line
 }
 
 proc drawslants {id needonscreen nohs} {
     global canv mainline mainlinearrow sidelines
     global canvx0 canvy xspc1 xspc2 lthickness
     global currentparents dupparents
     global lthickness linespc canvy colormap lineno geometry
     global maxgraphpct maxwidth
     global displist onscreen lastuse
     global parents commitlisted
     global oldnlines olddlevel olddisplist
     global nhyperspace numcommits nnewparents
 
     if {$lineno < 0} {
 	lappend displist $id
 	set onscreen($id) 1
 	return 0
     }
 
     set y1 [expr {$canvy - $linespc}]
     set y2 $canvy
 
     # work out what we need to get back on screen
     set reins {}
     if {$onscreen($id) < 0} {
 	# next to do isn't displayed, better get it on screen...
 	lappend reins [list $id 0]
     }
     # make sure all the previous commits's parents are on the screen
     foreach p $currentparents {
 	if {$onscreen($p) < 0} {
 	    lappend reins [list $p 0]
 	}
     }
     # bring back anything requested by caller
     if {$needonscreen ne {}} {
 	lappend reins $needonscreen
     }
 
     # try the shortcut
     if {$currentparents == $id && $onscreen($id) == 0 && $reins eq {}} {
 	set dlevel $olddlevel
 	set x [xcoord $dlevel $dlevel $lineno]
 	set mainline($id) [list $x $y1]
 	set mainlinearrow($id) none
 	set lastuse($id) $lineno
 	set displist [lreplace $displist $dlevel $dlevel $id]
 	set onscreen($id) 1
 	set xspc1([expr {$lineno + 1}]) $xspc1($lineno)
 	return $dlevel
     }
 
     # update displist
     set displist [lreplace $displist $olddlevel $olddlevel]
     set j $olddlevel
     foreach p $currentparents {
 	set lastuse($p) $lineno
 	if {$onscreen($p) == 0} {
 	    set displist [linsert $displist $j $p]
 	    set onscreen($p) 1
 	    incr j
 	}
     }
     if {$onscreen($id) == 0} {
 	lappend displist $id
 	set onscreen($id) 1
     }
 
     # remove the null entry if present
     set nullentry [lsearch -exact $displist {}]
     if {$nullentry >= 0} {
 	set displist [lreplace $displist $nullentry $nullentry]
     }
 
     # bring back the ones we need now (if we did it earlier
     # it would change displist and invalidate olddlevel)
     foreach pi $reins {
 	# test again in case of duplicates in reins
 	set p [lindex $pi 0]
 	if {$onscreen($p) < 0} {
 	    set onscreen($p) 1
 	    set lastuse($p) $lineno
 	    set displist [linsert $displist [lindex $pi 1] $p]
 	    incr nhyperspace -1
 	}
     }
 
     set lastuse($id) $lineno
 
     # see if we need to make any lines jump off into hyperspace
     set displ [llength $displist]
     if {$displ > $maxwidth} {
 	set ages {}
 	foreach x $displist {
 	    lappend ages [list $lastuse($x) $x]
 	}
 	set ages [lsort -integer -index 0 $ages]
 	set k 0
 	while {$displ > $maxwidth} {
 	    set use [lindex $ages $k 0]
 	    set victim [lindex $ages $k 1]
 	    if {$use >= $lineno - 5} break
 	    incr k
 	    if {[lsearch -exact $nohs $victim] >= 0} continue
 	    set i [lsearch -exact $displist $victim]
 	    set displist [lreplace $displist $i $i]
 	    set onscreen($victim) -1
 	    incr nhyperspace
 	    incr displ -1
 	    if {$i < $nullentry} {
 		incr nullentry -1
 	    }
 	    set x [lindex $mainline($victim) end-1]
 	    lappend mainline($victim) $x $y1
 	    set line [trimdiagend $mainline($victim)]
 	    set arrow "last"
 	    if {$mainlinearrow($victim) ne "none"} {
 		set line [trimdiagstart $line]
 		set arrow "both"
 	    }
 	    lappend sidelines($victim) [list $line 1 $arrow]
 	    unset mainline($victim)
 	}
     }
 
     set dlevel [lsearch -exact $displist $id]
 
     # If we are reducing, put in a null entry
     if {$displ < $oldnlines} {
 	# does the next line look like a merge?
 	# i.e. does it have > 1 new parent?
 	if {$nnewparents($id) > 1} {
 	    set i [expr {$dlevel + 1}]
 	} elseif {$nnewparents([lindex $olddisplist $olddlevel]) == 0} {
 	    set i $olddlevel
 	    if {$nullentry >= 0 && $nullentry < $i} {
 		incr i -1
 	    }
 	} elseif {$nullentry >= 0} {
 	    set i $nullentry
 	    while {$i < $displ
 		   && [lindex $olddisplist $i] == [lindex $displist $i]} {
 		incr i
 	    }
 	} else {
 	    set i $olddlevel
 	    if {$dlevel >= $i} {
 		incr i
 	    }
 	}
 	if {$i < $displ} {
 	    set displist [linsert $displist $i {}]
 	    incr displ
 	    if {$dlevel >= $i} {
 		incr dlevel
 	    }
 	}
     }
 
     # decide on the line spacing for the next line
     set lj [expr {$lineno + 1}]
     set maxw [expr {$maxgraphpct * $geometry(canv1) / 100}]
     if {$displ <= 1 || $canvx0 + $displ * $xspc2 <= $maxw} {
 	set xspc1($lj) $xspc2
     } else {
 	set xspc1($lj) [expr {($maxw - $canvx0 - $xspc2) / ($displ - 1)}]
 	if {$xspc1($lj) < $lthickness} {
 	    set xspc1($lj) $lthickness
 	}
     }
 
     foreach idi $reins {
 	set id [lindex $idi 0]
 	set j [lsearch -exact $displist $id]
 	set xj [xcoord $j $dlevel $lj]
 	set mainline($id) [list $xj $y2]
 	set mainlinearrow($id) first
     }
 
     set i -1
     foreach id $olddisplist {
 	incr i
 	if {$id == {}} continue
 	if {$onscreen($id) <= 0} continue
 	set xi [xcoord $i $olddlevel $lineno]
 	if {$i == $olddlevel} {
 	    foreach p $currentparents {
 		set j [lsearch -exact $displist $p]
 		set coords [list $xi $y1]
 		set xj [xcoord $j $dlevel $lj]
 		if {$xj < $xi - $linespc} {
 		    lappend coords [expr {$xj + $linespc}] $y1
 		    notecrossings $p $j $i [expr {$j + 1}]
 		} elseif {$xj > $xi + $linespc} {
 		    lappend coords [expr {$xj - $linespc}] $y1
 		    notecrossings $p $i $j [expr {$j - 1}]
 		}
 		if {[lsearch -exact $dupparents $p] >= 0} {
 		    # draw a double-width line to indicate the doubled parent
 		    lappend coords $xj $y2
 		    lappend sidelines($p) [list $coords 2 none]
 		    if {![info exists mainline($p)]} {
 			set mainline($p) [list $xj $y2]
 			set mainlinearrow($p) none
 		    }
 		} else {
 		    # normal case, no parent duplicated
 		    set yb $y2
 		    set dx [expr {abs($xi - $xj)}]
 		    if {0 && $dx < $linespc} {
 			set yb [expr {$y1 + $dx}]
 		    }
 		    if {![info exists mainline($p)]} {
 			if {$xi != $xj} {
 			    lappend coords $xj $yb
 			}
 			set mainline($p) $coords
 			set mainlinearrow($p) none
 		    } else {
 			lappend coords $xj $yb
 			if {$yb < $y2} {
 			    lappend coords $xj $y2
 			}
 			lappend sidelines($p) [list $coords 1 none]
 		    }
 		}
 	    }
 	} else {
 	    set j $i
 	    if {[lindex $displist $i] != $id} {
 		set j [lsearch -exact $displist $id]
 	    }
 	    if {$j != $i || $xspc1($lineno) != $xspc1($lj)
 		|| ($olddlevel < $i && $i < $dlevel)
 		|| ($dlevel < $i && $i < $olddlevel)} {
 		set xj [xcoord $j $dlevel $lj]
 		lappend mainline($id) $xi $y1 $xj $y2
 	    }
 	}
     }
     return $dlevel
 }
 
 # search for x in a list of lists
 proc llsearch {llist x} {
     set i 0
     foreach l $llist {
 	if {$l == $x || [lsearch -exact $l $x] >= 0} {
 	    return $i
 	}
 	incr i
     }
     return -1
 }
 
 proc drawmore {reading} {
     global displayorder numcommits ncmupdate nextupdate
     global stopped nhyperspace parents commitlisted
     global maxwidth onscreen displist currentparents olddlevel
 
     set n [llength $displayorder]
     while {$numcommits < $n} {
 	set id [lindex $displayorder $numcommits]
 	set ctxend [expr {$numcommits + 10}]
 	if {!$reading && $ctxend > $n} {
 	    set ctxend $n
 	}
 	set dlist {}
 	if {$numcommits > 0} {
 	    set dlist [lreplace $displist $olddlevel $olddlevel]
 	    set i $olddlevel
 	    foreach p $currentparents {
 		if {$onscreen($p) == 0} {
 		    set dlist [linsert $dlist $i $p]
 		    incr i
 		}
 	    }
 	}
 	set nohs {}
 	set reins {}
 	set isfat [expr {[llength $dlist] > $maxwidth}]
 	if {$nhyperspace > 0 || $isfat} {
 	    if {$ctxend > $n} break
 	    # work out what to bring back and
 	    # what we want to don't want to send into hyperspace
 	    set room 1
 	    for {set k $numcommits} {$k < $ctxend} {incr k} {
 		set x [lindex $displayorder $k]
 		set i [llsearch $dlist $x]
 		if {$i < 0} {
 		    set i [llength $dlist]
 		    lappend dlist $x
 		}
 		if {[lsearch -exact $nohs $x] < 0} {
 		    lappend nohs $x
 		}
 		if {$reins eq {} && $onscreen($x) < 0 && $room} {
 		    set reins [list $x $i]
 		}
 		set newp {}
 		if {[info exists commitlisted($x)]} {
 		    set right 0
 		    foreach p $parents($x) {
 			if {[llsearch $dlist $p] < 0} {
 			    lappend newp $p
 			    if {[lsearch -exact $nohs $p] < 0} {
 				lappend nohs $p
 			    }
 			    if {$reins eq {} && $onscreen($p) < 0 && $room} {
 				set reins [list $p [expr {$i + $right}]]
 			    }
 			}
 			set right 1
 		    }
 		}
 		set l [lindex $dlist $i]
 		if {[llength $l] == 1} {
 		    set l $newp
 		} else {
 		    set j [lsearch -exact $l $x]
 		    set l [concat [lreplace $l $j $j] $newp]
 		}
 		set dlist [lreplace $dlist $i $i $l]
 		if {$room && $isfat && [llength $newp] <= 1} {
 		    set room 0
 		}
 	    }
 	}
 
 	set dlevel [drawslants $id $reins $nohs]
 	drawcommitline $dlevel
 	if {[clock clicks -milliseconds] >= $nextupdate
 	    && $numcommits >= $ncmupdate} {
 	    doupdate $reading
 	    if {$stopped} break
 	}
     }
 }
 
 # level here is an index in todo
 proc updatetodo {level noshortcut} {
     global ncleft todo nnewparents
     global commitlisted parents onscreen
 
     set id [lindex $todo $level]
     set olds {}
     if {[info exists commitlisted($id)]} {
 	foreach p $parents($id) {
 	    if {[lsearch -exact $olds $p] < 0} {
 		lappend olds $p
 	    }
 	}
     }
     if {!$noshortcut && [llength $olds] == 1} {
 	set p [lindex $olds 0]
 	if {$ncleft($p) == 1 && [lsearch -exact $todo $p] < 0} {
 	    set ncleft($p) 0
 	    set todo [lreplace $todo $level $level $p]
 	    set onscreen($p) 0
 	    set nnewparents($id) 1
 	    return 0
 	}
     }
 
     set todo [lreplace $todo $level $level]
     set i $level
     set n 0
     foreach p $olds {
 	incr ncleft($p) -1
 	set k [lsearch -exact $todo $p]
 	if {$k < 0} {
 	    set todo [linsert $todo $i $p]
 	    set onscreen($p) 0
 	    incr i
 	    incr n
 	}
     }
     set nnewparents($id) $n
 
     return 1
 }
 
 proc decidenext {{noread 0}} {
     global ncleft todo
     global datemode cdate
     global commitinfo
 
     # choose which one to do next time around
     set todol [llength $todo]
     set level -1
     set latest {}
     for {set k $todol} {[incr k -1] >= 0} {} {
 	set p [lindex $todo $k]
 	if {$ncleft($p) == 0} {
 	    if {$datemode} {
 		if {![info exists commitinfo($p)]} {
 		    if {$noread} {
 			return {}
 		    }
 		    readcommit $p
 		}
 		if {$latest == {} || $cdate($p) > $latest} {
 		    set level $k
 		    set latest $cdate($p)
 		}
 	    } else {
 		set level $k
 		break
 	    }
 	}
     }
     if {$level < 0} {
 	if {$todo != {}} {
 	    puts "ERROR: none of the pending commits can be done yet:"
 	    foreach p $todo {
 		puts "  $p ($ncleft($p))"
 	    }
 	}
 	return -1
     }
 
     return $level
 }
 
 proc drawcommit {id} {
     global phase todo nchildren datemode nextupdate
     global numcommits ncmupdate displayorder todo onscreen
 
     if {$phase != "incrdraw"} {
 	set phase incrdraw
 	set displayorder {}
 	set todo {}
 	initgraph
     }
     if {$nchildren($id) == 0} {
 	lappend todo $id
 	set onscreen($id) 0
     }
     set level [decidenext 1]
     if {$level == {} || $id != [lindex $todo $level]} {
 	return
     }
     while 1 {
 	lappend displayorder [lindex $todo $level]
 	if {[updatetodo $level $datemode]} {
 	    set level [decidenext 1]
 	    if {$level == {}} break
 	}
 	set id [lindex $todo $level]
 	if {![info exists commitlisted($id)]} {
 	    break
 	}
     }
     drawmore 1
 }
 
 proc finishcommits {} {
     global phase
     global canv mainfont ctext maincursor textcursor
 
     if {$phase != "incrdraw"} {
 	$canv delete all
 	$canv create text 3 3 -anchor nw -text "No commits selected" \
 	    -font $mainfont -tags textitems
 	set phase {}
     } else {
 	drawrest
     }
     . config -cursor $maincursor
     settextcursor $textcursor
 }
 
 # Don't change the text pane cursor if it is currently the hand cursor,
 # showing that we are over a sha1 ID link.
 proc settextcursor {c} {
     global ctext curtextcursor
 
     if {[$ctext cget -cursor] == $curtextcursor} {
 	$ctext config -cursor $c
     }
     set curtextcursor $c
 }
 
 proc drawgraph {} {
     global nextupdate startmsecs ncmupdate
     global displayorder onscreen
 
     if {$displayorder == {}} return
     set startmsecs [clock clicks -milliseconds]
     set nextupdate [expr $startmsecs + 100]
     set ncmupdate 1
     initgraph
     foreach id $displayorder {
 	set onscreen($id) 0
     }
     drawmore 0
 }
 
 proc drawrest {} {
     global phase stopped redisplaying selectedline
     global datemode todo displayorder
     global numcommits ncmupdate
     global nextupdate startmsecs
 
     set level [decidenext]
     if {$level >= 0} {
 	set phase drawgraph
 	while 1 {
 	    lappend displayorder [lindex $todo $level]
 	    set hard [updatetodo $level $datemode]
 	    if {$hard} {
 		set level [decidenext]
 		if {$level < 0} break
 	    }
 	}
 	drawmore 0
     }
     set phase {}
     set drawmsecs [expr [clock clicks -milliseconds] - $startmsecs]
     #puts "overall $drawmsecs ms for $numcommits commits"
     if {$redisplaying} {
 	if {$stopped == 0 && [info exists selectedline]} {
 	    selectline $selectedline 0
 	}
 	if {$stopped == 1} {
 	    set stopped 0
 	    after idle drawgraph
 	} else {
 	    set redisplaying 0
 	}
     }
 }
 
 proc findmatches {f} {
     global findtype foundstring foundstrlen
     if {$findtype == "Regexp"} {
 	set matches [regexp -indices -all -inline $foundstring $f]
     } else {
 	if {$findtype == "IgnCase"} {
 	    set str [string tolower $f]
 	} else {
 	    set str $f
 	}
 	set matches {}
 	set i 0
 	while {[set j [string first $foundstring $str $i]] >= 0} {
 	    lappend matches [list $j [expr $j+$foundstrlen-1]]
 	    set i [expr $j + $foundstrlen]
 	}
     }
     return $matches
 }
 
 proc dofind {} {
     global findtype findloc findstring markedmatches commitinfo
     global numcommits lineid linehtag linentag linedtag
     global mainfont namefont canv canv2 canv3 selectedline
     global matchinglines foundstring foundstrlen
 
     stopfindproc
     unmarkmatches
     focus .
     set matchinglines {}
     if {$findloc == "Pickaxe"} {
 	findpatches
 	return
     }
     if {$findtype == "IgnCase"} {
 	set foundstring [string tolower $findstring]
     } else {
 	set foundstring $findstring
     }
     set foundstrlen [string length $findstring]
     if {$foundstrlen == 0} return
     if {$findloc == "Files"} {
 	findfiles
 	return
     }
     if {![info exists selectedline]} {
 	set oldsel -1
     } else {
 	set oldsel $selectedline
     }
     set didsel 0
     set fldtypes {Headline Author Date Committer CDate Comment}
     for {set l 0} {$l < $numcommits} {incr l} {
 	set id $lineid($l)
 	set info $commitinfo($id)
 	set doesmatch 0
 	foreach f $info ty $fldtypes {
 	    if {$findloc != "All fields" && $findloc != $ty} {
 		continue
 	    }
 	    set matches [findmatches $f]
 	    if {$matches == {}} continue
 	    set doesmatch 1
 	    if {$ty == "Headline"} {
 		markmatches $canv $l $f $linehtag($l) $matches $mainfont
 	    } elseif {$ty == "Author"} {
 		markmatches $canv2 $l $f $linentag($l) $matches $namefont
 	    } elseif {$ty == "Date"} {
 		markmatches $canv3 $l $f $linedtag($l) $matches $mainfont
 	    }
 	}
 	if {$doesmatch} {
 	    lappend matchinglines $l
 	    if {!$didsel && $l > $oldsel} {
 		findselectline $l
 		set didsel 1
 	    }
 	}
     }
     if {$matchinglines == {}} {
 	bell
     } elseif {!$didsel} {
 	findselectline [lindex $matchinglines 0]
     }
 }
 
 proc findselectline {l} {
     global findloc commentend ctext
     selectline $l 1
     if {$findloc == "All fields" || $findloc == "Comments"} {
 	# highlight the matches in the comments
 	set f [$ctext get 1.0 $commentend]
 	set matches [findmatches $f]
 	foreach match $matches {
 	    set start [lindex $match 0]
 	    set end [expr [lindex $match 1] + 1]
 	    $ctext tag add found "1.0 + $start c" "1.0 + $end c"
 	}
     }
 }
 
 proc findnext {restart} {
     global matchinglines selectedline
     if {![info exists matchinglines]} {
 	if {$restart} {
 	    dofind
 	}
 	return
     }
     if {![info exists selectedline]} return
     foreach l $matchinglines {
 	if {$l > $selectedline} {
 	    findselectline $l
 	    return
 	}
     }
     bell
 }
 
 proc findprev {} {
     global matchinglines selectedline
     if {![info exists matchinglines]} {
 	dofind
 	return
     }
     if {![info exists selectedline]} return
     set prev {}
     foreach l $matchinglines {
 	if {$l >= $selectedline} break
 	set prev $l
     }
     if {$prev != {}} {
 	findselectline $prev
     } else {
 	bell
     }
 }
 
 proc findlocchange {name ix op} {
     global findloc findtype findtypemenu
     if {$findloc == "Pickaxe"} {
 	set findtype Exact
 	set state disabled
     } else {
 	set state normal
     }
     $findtypemenu entryconf 1 -state $state
     $findtypemenu entryconf 2 -state $state
 }
 
 proc stopfindproc {{done 0}} {
     global findprocpid findprocfile findids
     global ctext findoldcursor phase maincursor textcursor
     global findinprogress
 
     catch {unset findids}
     if {[info exists findprocpid]} {
 	if {!$done} {
 	    catch {exec kill $findprocpid}
 	}
 	catch {close $findprocfile}
 	unset findprocpid
     }
     if {[info exists findinprogress]} {
 	unset findinprogress
 	if {$phase != "incrdraw"} {
 	    . config -cursor $maincursor
 	    settextcursor $textcursor
 	}
     }
 }
 
 proc findpatches {} {
     global findstring selectedline numcommits
     global findprocpid findprocfile
     global finddidsel ctext lineid findinprogress
     global findinsertpos
 
     if {$numcommits == 0} return
 
     # make a list of all the ids to search, starting at the one
     # after the selected line (if any)
     if {[info exists selectedline]} {
 	set l $selectedline
     } else {
 	set l -1
     }
     set inputids {}
     for {set i 0} {$i < $numcommits} {incr i} {
 	if {[incr l] >= $numcommits} {
 	    set l 0
 	}
 	append inputids $lineid($l) "\n"
     }
 
     if {[catch {
 	set f [open [list | hg debug-diff-tree --stdin -s -r -S$findstring \
 			 << $inputids] r]
     } err]} {
 	error_popup "Error starting search process: $err"
 	return
     }
 
     set findinsertpos end
     set findprocfile $f
     set findprocpid [pid $f]
     fconfigure $f -blocking 0
     fileevent $f readable readfindproc
     set finddidsel 0
     . config -cursor watch
     settextcursor watch
     set findinprogress 1
 }
 
 proc readfindproc {} {
     global findprocfile finddidsel
     global idline matchinglines findinsertpos
 
     set n [gets $findprocfile line]
     if {$n < 0} {
 	if {[eof $findprocfile]} {
 	    stopfindproc 1
 	    if {!$finddidsel} {
 		bell
 	    }
 	}
 	return
     }
     if {![regexp {^[0-9a-f]{40}} $line id]} {
 	error_popup "Can't parse git-diff-tree output: $line"
 	stopfindproc
 	return
     }
     if {![info exists idline($id)]} {
 	puts stderr "spurious id: $id"
 	return
     }
     set l $idline($id)
     insertmatch $l $id
 }
 
 proc insertmatch {l id} {
     global matchinglines findinsertpos finddidsel
 
     if {$findinsertpos == "end"} {
 	if {$matchinglines != {} && $l < [lindex $matchinglines 0]} {
 	    set matchinglines [linsert $matchinglines 0 $l]
 	    set findinsertpos 1
 	} else {
 	    lappend matchinglines $l
 	}
     } else {
 	set matchinglines [linsert $matchinglines $findinsertpos $l]
 	incr findinsertpos
     }
     markheadline $l $id
     if {!$finddidsel} {
 	findselectline $l
 	set finddidsel 1
     }
 }
 
 proc findfiles {} {
     global selectedline numcommits lineid ctext
     global ffileline finddidsel parents nparents
     global findinprogress findstartline findinsertpos
     global treediffs fdiffids fdiffsneeded fdiffpos
     global findmergefiles
 
     if {$numcommits == 0} return
 
     if {[info exists selectedline]} {
 	set l [expr {$selectedline + 1}]
     } else {
 	set l 0
     }
     set ffileline $l
     set findstartline $l
     set diffsneeded {}
     set fdiffsneeded {}
     while 1 {
 	set id $lineid($l)
 	if {$findmergefiles || $nparents($id) == 1} {
 	    foreach p $parents($id) {
 		if {![info exists treediffs([list $id $p])]} {
 		    append diffsneeded "$id $p\n"
 		    lappend fdiffsneeded [list $id $p]
 		}
 	    }
 	}
 	if {[incr l] >= $numcommits} {
 	    set l 0
 	}
 	if {$l == $findstartline} break
     }
 
     # start off a git-diff-tree process if needed
     if {$diffsneeded ne {}} {
 	if {[catch {
 	    set df [open [list | hg debug-diff-tree -r --stdin << $diffsneeded] r]
 	} err ]} {
 	    error_popup "Error starting search process: $err"
 	    return
 	}
 	catch {unset fdiffids}
 	set fdiffpos 0
 	fconfigure $df -blocking 0
 	fileevent $df readable [list readfilediffs $df]
     }
 
     set finddidsel 0
     set findinsertpos end
     set id $lineid($l)
     set p [lindex $parents($id) 0]
     . config -cursor watch
     settextcursor watch
     set findinprogress 1
     findcont [list $id $p]
     update
 }
 
 proc readfilediffs {df} {
     global findids fdiffids fdiffs
 
     set n [gets $df line]
     if {$n < 0} {
 	if {[eof $df]} {
 	    donefilediff
 	    if {[catch {close $df} err]} {
 		stopfindproc
 		bell
 		error_popup "Error in hg debug-diff-tree: $err"
 	    } elseif {[info exists findids]} {
 		set ids $findids
 		stopfindproc
 		bell
 		error_popup "Couldn't find diffs for {$ids}"
 	    }
 	}
 	return
     }
     if {[regexp {^([0-9a-f]{40}) \(from ([0-9a-f]{40})\)} $line match id p]} {
 	# start of a new string of diffs
 	donefilediff
 	set fdiffids [list $id $p]
 	set fdiffs {}
     } elseif {[string match ":*" $line]} {
 	lappend fdiffs [lindex $line 5]
     }
 }
 
 proc donefilediff {} {
     global fdiffids fdiffs treediffs findids
     global fdiffsneeded fdiffpos
 
     if {[info exists fdiffids]} {
 	while {[lindex $fdiffsneeded $fdiffpos] ne $fdiffids
 	       && $fdiffpos < [llength $fdiffsneeded]} {
 	    # git-diff-tree doesn't output anything for a commit
 	    # which doesn't change anything
 	    set nullids [lindex $fdiffsneeded $fdiffpos]
 	    set treediffs($nullids) {}
 	    if {[info exists findids] && $nullids eq $findids} {
 		unset findids
 		findcont $nullids
 	    }
 	    incr fdiffpos
 	}
 	incr fdiffpos
 
 	if {![info exists treediffs($fdiffids)]} {
 	    set treediffs($fdiffids) $fdiffs
 	}
 	if {[info exists findids] && $fdiffids eq $findids} {
 	    unset findids
 	    findcont $fdiffids
 	}
     }
 }
 
 proc findcont {ids} {
     global findids treediffs parents nparents
     global ffileline findstartline finddidsel
     global lineid numcommits matchinglines findinprogress
     global findmergefiles
 
     set id [lindex $ids 0]
     set p [lindex $ids 1]
     set pi [lsearch -exact $parents($id) $p]
     set l $ffileline
     while 1 {
 	if {$findmergefiles || $nparents($id) == 1} {
 	    if {![info exists treediffs($ids)]} {
 		set findids $ids
 		set ffileline $l
 		return
 	    }
 	    set doesmatch 0
 	    foreach f $treediffs($ids) {
 		set x [findmatches $f]
 		if {$x != {}} {
 		    set doesmatch 1
 		    break
 		}
 	    }
 	    if {$doesmatch} {
 		insertmatch $l $id
 		set pi $nparents($id)
 	    }
 	} else {
 	    set pi $nparents($id)
 	}
 	if {[incr pi] >= $nparents($id)} {
 	    set pi 0
 	    if {[incr l] >= $numcommits} {
 		set l 0
 	    }
 	    if {$l == $findstartline} break
 	    set id $lineid($l)
 	}
 	set p [lindex $parents($id) $pi]
 	set ids [list $id $p]
     }
     stopfindproc
     if {!$finddidsel} {
 	bell
     }
 }
 
 # mark a commit as matching by putting a yellow background
 # behind the headline
 proc markheadline {l id} {
     global canv mainfont linehtag commitinfo
 
     set bbox [$canv bbox $linehtag($l)]
     set t [$canv create rect $bbox -outline {} -tags matches -fill yellow]
     $canv lower $t
 }
 
 # mark the bits of a headline, author or date that match a find string
 proc markmatches {canv l str tag matches font} {
     set bbox [$canv bbox $tag]
     set x0 [lindex $bbox 0]
     set y0 [lindex $bbox 1]
     set y1 [lindex $bbox 3]
     foreach match $matches {
 	set start [lindex $match 0]
 	set end [lindex $match 1]
 	if {$start > $end} continue
 	set xoff [font measure $font [string range $str 0 [expr $start-1]]]
 	set xlen [font measure $font [string range $str 0 [expr $end]]]
 	set t [$canv create rect [expr $x0+$xoff] $y0 [expr $x0+$xlen+2] $y1 \
 		   -outline {} -tags matches -fill yellow]
 	$canv lower $t
     }
 }
 
 proc unmarkmatches {} {
     global matchinglines findids
     allcanvs delete matches
     catch {unset matchinglines}
     catch {unset findids}
 }
 
 proc selcanvline {w x y} {
     global canv canvy0 ctext linespc
     global lineid linehtag linentag linedtag rowtextx
     set ymax [lindex [$canv cget -scrollregion] 3]
     if {$ymax == {}} return
     set yfrac [lindex [$canv yview] 0]
     set y [expr {$y + $yfrac * $ymax}]
     set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
     if {$l < 0} {
 	set l 0
     }
     if {$w eq $canv} {
 	if {![info exists rowtextx($l)] || $x < $rowtextx($l)} return
     }
     unmarkmatches
     selectline $l 1
 }
 
 proc commit_descriptor {p} {
     global commitinfo
     set l "..."
     if {[info exists commitinfo($p)]} {
 	set l [lindex $commitinfo($p) 0]
     }
     return "$p ($l)"
 }
 
 # append some text to the ctext widget, and make any SHA1 ID
 # that we know about be a clickable link.
 proc appendwithlinks {text} {
     global ctext idline linknum
 
     set start [$ctext index "end - 1c"]
     $ctext insert end $text
     $ctext insert end "\n"
     set links [regexp -indices -all -inline {[0-9a-f]{40}} $text]
     foreach l $links {
 	set s [lindex $l 0]
 	set e [lindex $l 1]
 	set linkid [string range $text $s $e]
 	if {![info exists idline($linkid)]} continue
 	incr e
 	$ctext tag add link "$start + $s c" "$start + $e c"
 	$ctext tag add link$linknum "$start + $s c" "$start + $e c"
 	$ctext tag bind link$linknum <1> [list selectline $idline($linkid) 1]
 	incr linknum
     }
     $ctext tag conf link -foreground blue -underline 1
     $ctext tag bind link <Enter> { %W configure -cursor hand2 }
     $ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
 }
 
 proc selectline {l isnew} {
     global canv canv2 canv3 ctext commitinfo selectedline
     global lineid linehtag linentag linedtag
     global canvy0 linespc parents nparents children
     global cflist currentid sha1entry
     global commentend idtags idline linknum
 
     $canv delete hover
     normalline
     if {![info exists lineid($l)] || ![info exists linehtag($l)]} return
     $canv delete secsel
     set t [eval $canv create rect [$canv bbox $linehtag($l)] -outline {{}} \
 	       -tags secsel -fill [$canv cget -selectbackground]]
     $canv lower $t
     $canv2 delete secsel
     set t [eval $canv2 create rect [$canv2 bbox $linentag($l)] -outline {{}} \
 	       -tags secsel -fill [$canv2 cget -selectbackground]]
     $canv2 lower $t
     $canv3 delete secsel
     set t [eval $canv3 create rect [$canv3 bbox $linedtag($l)] -outline {{}} \
 	       -tags secsel -fill [$canv3 cget -selectbackground]]
     $canv3 lower $t
     set y [expr {$canvy0 + $l * $linespc}]
     set ymax [lindex [$canv cget -scrollregion] 3]
     set ytop [expr {$y - $linespc - 1}]
     set ybot [expr {$y + $linespc + 1}]
     set wnow [$canv yview]
     set wtop [expr [lindex $wnow 0] * $ymax]
     set wbot [expr [lindex $wnow 1] * $ymax]
     set wh [expr {$wbot - $wtop}]
     set newtop $wtop
     if {$ytop < $wtop} {
 	if {$ybot < $wtop} {
 	    set newtop [expr {$y - $wh / 2.0}]
 	} else {
 	    set newtop $ytop
 	    if {$newtop > $wtop - $linespc} {
 		set newtop [expr {$wtop - $linespc}]
 	    }
 	}
     } elseif {$ybot > $wbot} {
 	if {$ytop > $wbot} {
 	    set newtop [expr {$y - $wh / 2.0}]
 	} else {
 	    set newtop [expr {$ybot - $wh}]
 	    if {$newtop < $wtop + $linespc} {
 		set newtop [expr {$wtop + $linespc}]
 	    }
 	}
     }
     if {$newtop != $wtop} {
 	if {$newtop < 0} {
 	    set newtop 0
 	}
 	allcanvs yview moveto [expr $newtop * 1.0 / $ymax]
     }
 
     if {$isnew} {
 	addtohistory [list selectline $l 0]
     }
 
     set selectedline $l
 
     set id $lineid($l)
     set currentid $id
     $sha1entry delete 0 end
     $sha1entry insert 0 $id
     $sha1entry selection from 0
     $sha1entry selection to end
 
     $ctext conf -state normal
     $ctext delete 0.0 end
     set linknum 0
     $ctext mark set fmark.0 0.0
     $ctext mark gravity fmark.0 left
     set info $commitinfo($id)
     $ctext insert end "Author: [lindex $info 1]  [lindex $info 2]\n"
     $ctext insert end "Committer: [lindex $info 3]  [lindex $info 4]\n"
     if {[info exists idtags($id)]} {
 	$ctext insert end "Tags:"
 	foreach tag $idtags($id) {
 	    $ctext insert end " $tag"
 	}
 	$ctext insert end "\n"
     }
- 
+
     set comment {}
     if {[info exists parents($id)]} {
 	foreach p $parents($id) {
 	    append comment "Parent: [commit_descriptor $p]\n"
 	}
     }
     if {[info exists children($id)]} {
 	foreach c $children($id) {
 	    append comment "Child:  [commit_descriptor $c]\n"
 	}
     }
     append comment "\n"
     append comment [lindex $info 5]
 
     # make anything that looks like a SHA1 ID be a clickable link
     appendwithlinks $comment
 
     $ctext tag delete Comments
     $ctext tag remove found 1.0 end
     $ctext conf -state disabled
     set commentend [$ctext index "end - 1c"]
 
     $cflist delete 0 end
     $cflist insert end "Comments"
     if {$nparents($id) == 1} {
 	startdiff [concat $id $parents($id)]
     } elseif {$nparents($id) > 1} {
 	mergediff $id
     }
 }
 
 proc selnextline {dir} {
     global selectedline
     if {![info exists selectedline]} return
     set l [expr $selectedline + $dir]
     unmarkmatches
     selectline $l 1
 }
 
 proc unselectline {} {
     global selectedline
 
     catch {unset selectedline}
     allcanvs delete secsel
 }
 
 proc addtohistory {cmd} {
     global history historyindex
 
     if {$historyindex > 0
 	&& [lindex $history [expr {$historyindex - 1}]] == $cmd} {
 	return
     }
 
     if {$historyindex < [llength $history]} {
 	set history [lreplace $history $historyindex end $cmd]
     } else {
 	lappend history $cmd
     }
     incr historyindex
     if {$historyindex > 1} {
 	.ctop.top.bar.leftbut conf -state normal
     } else {
 	.ctop.top.bar.leftbut conf -state disabled
     }
     .ctop.top.bar.rightbut conf -state disabled
 }
 
 proc goback {} {
     global history historyindex
 
     if {$historyindex > 1} {
 	incr historyindex -1
 	set cmd [lindex $history [expr {$historyindex - 1}]]
 	eval $cmd
 	.ctop.top.bar.rightbut conf -state normal
     }
     if {$historyindex <= 1} {
 	.ctop.top.bar.leftbut conf -state disabled
     }
 }
 
 proc goforw {} {
     global history historyindex
 
     if {$historyindex < [llength $history]} {
 	set cmd [lindex $history $historyindex]
 	incr historyindex
 	eval $cmd
 	.ctop.top.bar.leftbut conf -state normal
     }
     if {$historyindex >= [llength $history]} {
 	.ctop.top.bar.rightbut conf -state disabled
     }
 }
 
 proc mergediff {id} {
     global parents diffmergeid diffmergegca mergefilelist diffpindex
 
     set diffmergeid $id
     set diffpindex -1
     set diffmergegca [findgca $parents($id)]
     if {[info exists mergefilelist($id)]} {
 	if {$mergefilelist($id) ne {}} {
 	    showmergediff
 	}
     } else {
 	contmergediff {}
     }
 }
 
 proc findgca {ids} {
     set gca {}
     foreach id $ids {
 	if {$gca eq {}} {
 	    set gca $id
 	} else {
 	    if {[catch {
 		set gca [exec hg debug-merge-base $gca $id]
 	    } err]} {
 		return {}
 	    }
 	}
     }
     return $gca
 }
 
 proc contmergediff {ids} {
     global diffmergeid diffpindex parents nparents diffmergegca
     global treediffs mergefilelist diffids treepending
 
     # diff the child against each of the parents, and diff
     # each of the parents against the GCA.
     while 1 {
 	if {[lindex $ids 0] == $diffmergeid && $diffmergegca ne {}} {
 	    set ids [list [lindex $ids 1] $diffmergegca]
 	} else {
 	    if {[incr diffpindex] >= $nparents($diffmergeid)} break
 	    set p [lindex $parents($diffmergeid) $diffpindex]
 	    set ids [list $diffmergeid $p]
 	}
 	if {![info exists treediffs($ids)]} {
 	    set diffids $ids
 	    if {![info exists treepending]} {
 		gettreediffs $ids
 	    }
 	    return
 	}
     }
 
     # If a file in some parent is different from the child and also
     # different from the GCA, then it's interesting.
     # If we don't have a GCA, then a file is interesting if it is
     # different from the child in all the parents.
     if {$diffmergegca ne {}} {
 	set files {}
 	foreach p $parents($diffmergeid) {
 	    set gcadiffs $treediffs([list $p $diffmergegca])
 	    foreach f $treediffs([list $diffmergeid $p]) {
 		if {[lsearch -exact $files $f] < 0
 		    && [lsearch -exact $gcadiffs $f] >= 0} {
 		    lappend files $f
 		}
 	    }
 	}
 	set files [lsort $files]
     } else {
 	set p [lindex $parents($diffmergeid) 0]
 	set files $treediffs([list $diffmergeid $p])
 	for {set i 1} {$i < $nparents($diffmergeid) && $files ne {}} {incr i} {
 	    set p [lindex $parents($diffmergeid) $i]
 	    set df $treediffs([list $diffmergeid $p])
 	    set nf {}
 	    foreach f $files {
 		if {[lsearch -exact $df $f] >= 0} {
 		    lappend nf $f
 		}
 	    }
 	    set files $nf
 	}
     }
 
     set mergefilelist($diffmergeid) $files
     if {$files ne {}} {
 	showmergediff
     }
 }
 
 proc showmergediff {} {
     global cflist diffmergeid mergefilelist parents
     global diffopts diffinhunk currentfile currenthunk filelines
     global diffblocked groupfilelast mergefds groupfilenum grouphunks
 
     set files $mergefilelist($diffmergeid)
     foreach f $files {
 	$cflist insert end $f
     }
     set env(GIT_DIFF_OPTS) $diffopts
     set flist {}
     catch {unset currentfile}
     catch {unset currenthunk}
     catch {unset filelines}
     catch {unset groupfilenum}
     catch {unset grouphunks}
     set groupfilelast -1
     foreach p $parents($diffmergeid) {
 	set cmd [list | hg debug-diff-tree -p $p $diffmergeid]
 	set cmd [concat $cmd $mergefilelist($diffmergeid)]
 	if {[catch {set f [open $cmd r]} err]} {
 	    error_popup "Error getting diffs: $err"
 	    foreach f $flist {
 		catch {close $f}
 	    }
 	    return
 	}
 	lappend flist $f
 	set ids [list $diffmergeid $p]
 	set mergefds($ids) $f
 	set diffinhunk($ids) 0
 	set diffblocked($ids) 0
 	fconfigure $f -blocking 0
 	fileevent $f readable [list getmergediffline $f $ids $diffmergeid]
     }
 }
 
 proc getmergediffline {f ids id} {
     global diffmergeid diffinhunk diffoldlines diffnewlines
     global currentfile currenthunk
     global diffoldstart diffnewstart diffoldlno diffnewlno
     global diffblocked mergefilelist
     global noldlines nnewlines difflcounts filelines
 
     set n [gets $f line]
     if {$n < 0} {
 	if {![eof $f]} return
     }
 
     if {!([info exists diffmergeid] && $diffmergeid == $id)} {
 	if {$n < 0} {
 	    close $f
 	}
 	return
     }
 
     if {$diffinhunk($ids) != 0} {
 	set fi $currentfile($ids)
 	if {$n > 0 && [regexp {^[-+ \\]} $line match]} {
 	    # continuing an existing hunk
 	    set line [string range $line 1 end]
 	    set p [lindex $ids 1]
 	    if {$match eq "-" || $match eq " "} {
 		set filelines($p,$fi,$diffoldlno($ids)) $line
 		incr diffoldlno($ids)
 	    }
 	    if {$match eq "+" || $match eq " "} {
 		set filelines($id,$fi,$diffnewlno($ids)) $line
 		incr diffnewlno($ids)
 	    }
 	    if {$match eq " "} {
 		if {$diffinhunk($ids) == 2} {
 		    lappend difflcounts($ids) \
 			[list $noldlines($ids) $nnewlines($ids)]
 		    set noldlines($ids) 0
 		    set diffinhunk($ids) 1
 		}
 		incr noldlines($ids)
 	    } elseif {$match eq "-" || $match eq "+"} {
 		if {$diffinhunk($ids) == 1} {
 		    lappend difflcounts($ids) [list $noldlines($ids)]
 		    set noldlines($ids) 0
 		    set nnewlines($ids) 0
 		    set diffinhunk($ids) 2
 		}
 		if {$match eq "-"} {
 		    incr noldlines($ids)
 		} else {
 		    incr nnewlines($ids)
 		}
 	    }
 	    # and if it's \ No newline at end of line, then what?
 	    return
 	}
 	# end of a hunk
 	if {$diffinhunk($ids) == 1 && $noldlines($ids) != 0} {
 	    lappend difflcounts($ids) [list $noldlines($ids)]
 	} elseif {$diffinhunk($ids) == 2
 		  && ($noldlines($ids) != 0 || $nnewlines($ids) != 0)} {
 	    lappend difflcounts($ids) [list $noldlines($ids) $nnewlines($ids)]
 	}
 	set currenthunk($ids) [list $currentfile($ids) \
 				   $diffoldstart($ids) $diffnewstart($ids) \
 				   $diffoldlno($ids) $diffnewlno($ids) \
 				   $difflcounts($ids)]
 	set diffinhunk($ids) 0
 	# -1 = need to block, 0 = unblocked, 1 = is blocked
 	set diffblocked($ids) -1
 	processhunks
 	if {$diffblocked($ids) == -1} {
 	    fileevent $f readable {}
 	    set diffblocked($ids) 1
 	}
     }
 
     if {$n < 0} {
 	# eof
 	if {!$diffblocked($ids)} {
 	    close $f
 	    set currentfile($ids) [llength $mergefilelist($diffmergeid)]
 	    set currenthunk($ids) [list $currentfile($ids) 0 0 0 0 {}]
 	    processhunks
 	}
     } elseif {[regexp {^diff --git a/(.*) b/} $line match fname]} {
 	# start of a new file
 	set currentfile($ids) \
 	    [lsearch -exact $mergefilelist($diffmergeid) $fname]
     } elseif {[regexp {^@@ -([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@(.*)} \
 		   $line match f1l f1c f2l f2c rest]} {
 	if {[info exists currentfile($ids)] && $currentfile($ids) >= 0} {
 	    # start of a new hunk
 	    if {$f1l == 0 && $f1c == 0} {
 		set f1l 1
 	    }
 	    if {$f2l == 0 && $f2c == 0} {
 		set f2l 1
 	    }
 	    set diffinhunk($ids) 1
 	    set diffoldstart($ids) $f1l
 	    set diffnewstart($ids) $f2l
 	    set diffoldlno($ids) $f1l
 	    set diffnewlno($ids) $f2l
 	    set difflcounts($ids) {}
 	    set noldlines($ids) 0
 	    set nnewlines($ids) 0
 	}
     }
 }
 
 proc processhunks {} {
     global diffmergeid parents nparents currenthunk
     global mergefilelist diffblocked mergefds
     global grouphunks grouplinestart grouplineend groupfilenum
 
     set nfiles [llength $mergefilelist($diffmergeid)]
     while 1 {
 	set fi $nfiles
 	set lno 0
 	# look for the earliest hunk
 	foreach p $parents($diffmergeid) {
 	    set ids [list $diffmergeid $p]
 	    if {![info exists currenthunk($ids)]} return
 	    set i [lindex $currenthunk($ids) 0]
 	    set l [lindex $currenthunk($ids) 2]
 	    if {$i < $fi || ($i == $fi && $l < $lno)} {
 		set fi $i
 		set lno $l
 		set pi $p
 	    }
 	}
 
 	if {$fi < $nfiles} {
 	    set ids [list $diffmergeid $pi]
 	    set hunk $currenthunk($ids)
 	    unset currenthunk($ids)
 	    if {$diffblocked($ids) > 0} {
 		fileevent $mergefds($ids) readable \
 		    [list getmergediffline $mergefds($ids) $ids $diffmergeid]
 	    }
 	    set diffblocked($ids) 0
 
 	    if {[info exists groupfilenum] && $groupfilenum == $fi
 		&& $lno <= $grouplineend} {
 		# add this hunk to the pending group
 		lappend grouphunks($pi) $hunk
 		set endln [lindex $hunk 4]
 		if {$endln > $grouplineend} {
 		    set grouplineend $endln
 		}
 		continue
 	    }
 	}
 
 	# succeeding stuff doesn't belong in this group, so
 	# process the group now
 	if {[info exists groupfilenum]} {
 	    processgroup
 	    unset groupfilenum
 	    unset grouphunks
 	}
 
 	if {$fi >= $nfiles} break
 
 	# start a new group
 	set groupfilenum $fi
 	set grouphunks($pi) [list $hunk]
 	set grouplinestart $lno
 	set grouplineend [lindex $hunk 4]
     }
 }
 
 proc processgroup {} {
     global groupfilelast groupfilenum difffilestart
     global mergefilelist diffmergeid ctext filelines
     global parents diffmergeid diffoffset
     global grouphunks grouplinestart grouplineend nparents
     global mergemax
 
     $ctext conf -state normal
     set id $diffmergeid
     set f $groupfilenum
     if {$groupfilelast != $f} {
 	$ctext insert end "\n"
 	set here [$ctext index "end - 1c"]
 	set difffilestart($f) $here
 	set mark fmark.[expr {$f + 1}]
 	$ctext mark set $mark $here
 	$ctext mark gravity $mark left
 	set header [lindex $mergefilelist($id) $f]
 	set l [expr {(78 - [string length $header]) / 2}]
 	set pad [string range "----------------------------------------" 1 $l]
 	$ctext insert end "$pad $header $pad\n" filesep
 	set groupfilelast $f
 	foreach p $parents($id) {
 	    set diffoffset($p) 0
 	}
     }
 
     $ctext insert end "@@" msep
     set nlines [expr {$grouplineend - $grouplinestart}]
     set events {}
     set pnum 0
     foreach p $parents($id) {
 	set startline [expr {$grouplinestart + $diffoffset($p)}]
 	set ol $startline
 	set nl $grouplinestart
 	if {[info exists grouphunks($p)]} {
 	    foreach h $grouphunks($p) {
 		set l [lindex $h 2]
 		if {$nl < $l} {
 		    for {} {$nl < $l} {incr nl} {
 			set filelines($p,$f,$ol) $filelines($id,$f,$nl)
 			incr ol
 		    }
 		}
 		foreach chunk [lindex $h 5] {
 		    if {[llength $chunk] == 2} {
 			set olc [lindex $chunk 0]
 			set nlc [lindex $chunk 1]
 			set nnl [expr {$nl + $nlc}]
 			lappend events [list $nl $nnl $pnum $olc $nlc]
 			incr ol $olc
 			set nl $nnl
 		    } else {
 			incr ol [lindex $chunk 0]
 			incr nl [lindex $chunk 0]
 		    }
 		}
 	    }
 	}
 	if {$nl < $grouplineend} {
 	    for {} {$nl < $grouplineend} {incr nl} {
 		set filelines($p,$f,$ol) $filelines($id,$f,$nl)
 		incr ol
 	    }
 	}
 	set nlines [expr {$ol - $startline}]
 	$ctext insert end " -$startline,$nlines" msep
 	incr pnum
     }
 
     set nlines [expr {$grouplineend - $grouplinestart}]
     $ctext insert end " +$grouplinestart,$nlines @@\n" msep
 
     set events [lsort -integer -index 0 $events]
     set nevents [llength $events]
     set nmerge $nparents($diffmergeid)
     set l $grouplinestart
     for {set i 0} {$i < $nevents} {set i $j} {
 	set nl [lindex $events $i 0]
 	while {$l < $nl} {
 	    $ctext insert end " $filelines($id,$f,$l)\n"
 	    incr l
 	}
 	set e [lindex $events $i]
 	set enl [lindex $e 1]
 	set j $i
 	set active {}
 	while 1 {
 	    set pnum [lindex $e 2]
 	    set olc [lindex $e 3]
 	    set nlc [lindex $e 4]
 	    if {![info exists delta($pnum)]} {
 		set delta($pnum) [expr {$olc - $nlc}]
 		lappend active $pnum
 	    } else {
 		incr delta($pnum) [expr {$olc - $nlc}]
 	    }
 	    if {[incr j] >= $nevents} break
 	    set e [lindex $events $j]
 	    if {[lindex $e 0] >= $enl} break
 	    if {[lindex $e 1] > $enl} {
 		set enl [lindex $e 1]
 	    }
 	}
 	set nlc [expr {$enl - $l}]
 	set ncol mresult
 	set bestpn -1
 	if {[llength $active] == $nmerge - 1} {
 	    # no diff for one of the parents, i.e. it's identical
 	    for {set pnum 0} {$pnum < $nmerge} {incr pnum} {
 		if {![info exists delta($pnum)]} {
 		    if {$pnum < $mergemax} {
 			lappend ncol m$pnum
 		    } else {
 			lappend ncol mmax
 		    }
 		    break
 		}
 	    }
 	} elseif {[llength $active] == $nmerge} {
 	    # all parents are different, see if one is very similar
 	    set bestsim 30
 	    for {set pnum 0} {$pnum < $nmerge} {incr pnum} {
 		set sim [similarity $pnum $l $nlc $f \
 			     [lrange $events $i [expr {$j-1}]]]
 		if {$sim > $bestsim} {
 		    set bestsim $sim
 		    set bestpn $pnum
 		}
 	    }
 	    if {$bestpn >= 0} {
 		lappend ncol m$bestpn
 	    }
 	}
 	set pnum -1
 	foreach p $parents($id) {
 	    incr pnum
 	    if {![info exists delta($pnum)] || $pnum == $bestpn} continue
 	    set olc [expr {$nlc + $delta($pnum)}]
 	    set ol [expr {$l + $diffoffset($p)}]
 	    incr diffoffset($p) $delta($pnum)
 	    unset delta($pnum)
 	    for {} {$olc > 0} {incr olc -1} {
 		$ctext insert end "-$filelines($p,$f,$ol)\n" m$pnum
 		incr ol
 	    }
 	}
 	set endl [expr {$l + $nlc}]
 	if {$bestpn >= 0} {
 	    # show this pretty much as a normal diff
 	    set p [lindex $parents($id) $bestpn]
 	    set ol [expr {$l + $diffoffset($p)}]
 	    incr diffoffset($p) $delta($bestpn)
 	    unset delta($bestpn)
 	    for {set k $i} {$k < $j} {incr k} {
 		set e [lindex $events $k]
 		if {[lindex $e 2] != $bestpn} continue
 		set nl [lindex $e 0]
 		set ol [expr {$ol + $nl - $l}]
 		for {} {$l < $nl} {incr l} {
 		    $ctext insert end "+$filelines($id,$f,$l)\n" $ncol
 		}
 		set c [lindex $e 3]
 		for {} {$c > 0} {incr c -1} {
 		    $ctext insert end "-$filelines($p,$f,$ol)\n" m$bestpn
 		    incr ol
 		}
 		set nl [lindex $e 1]
 		for {} {$l < $nl} {incr l} {
 		    $ctext insert end "+$filelines($id,$f,$l)\n" mresult
 		}
 	    }
 	}
 	for {} {$l < $endl} {incr l} {
 	    $ctext insert end "+$filelines($id,$f,$l)\n" $ncol
 	}
     }
     while {$l < $grouplineend} {
 	$ctext insert end " $filelines($id,$f,$l)\n"
 	incr l
     }
     $ctext conf -state disabled
 }
 
 proc similarity {pnum l nlc f events} {
     global diffmergeid parents diffoffset filelines
 
     set id $diffmergeid
     set p [lindex $parents($id) $pnum]
     set ol [expr {$l + $diffoffset($p)}]
     set endl [expr {$l + $nlc}]
     set same 0
     set diff 0
     foreach e $events {
 	if {[lindex $e 2] != $pnum} continue
 	set nl [lindex $e 0]
 	set ol [expr {$ol + $nl - $l}]
 	for {} {$l < $nl} {incr l} {
 	    incr same [string length $filelines($id,$f,$l)]
 	    incr same
 	}
 	set oc [lindex $e 3]
 	for {} {$oc > 0} {incr oc -1} {
 	    incr diff [string length $filelines($p,$f,$ol)]
 	    incr diff
 	    incr ol
 	}
 	set nl [lindex $e 1]
 	for {} {$l < $nl} {incr l} {
 	    incr diff [string length $filelines($id,$f,$l)]
 	    incr diff
 	}
     }
     for {} {$l < $endl} {incr l} {
 	incr same [string length $filelines($id,$f,$l)]
 	incr same
     }
     if {$same == 0} {
 	return 0
     }
     return [expr {200 * $same / (2 * $same + $diff)}]
 }
 
 proc startdiff {ids} {
     global treediffs diffids treepending diffmergeid
 
     set diffids $ids
     catch {unset diffmergeid}
     if {![info exists treediffs($ids)]} {
 	if {![info exists treepending]} {
 	    gettreediffs $ids
 	}
     } else {
 	addtocflist $ids
     }
 }
 
 proc addtocflist {ids} {
     global treediffs cflist
     foreach f $treediffs($ids) {
 	$cflist insert end $f
     }
     getblobdiffs $ids
 }
 
 proc gettreediffs {ids} {
     global treediff parents treepending
     set treepending $ids
     set treediff {}
     set id [lindex $ids 0]
     set p [lindex $ids 1]
     if [catch {set gdtf [open "|hg debug-diff-tree -r $p $id" r]}] return
     fconfigure $gdtf -blocking 0
     fileevent $gdtf readable [list gettreediffline $gdtf $ids]
 }
 
 proc gettreediffline {gdtf ids} {
     global treediff treediffs treepending diffids diffmergeid
 
     set n [gets $gdtf line]
     if {$n < 0} {
 	if {![eof $gdtf]} return
 	close $gdtf
 	set treediffs($ids) $treediff
 	unset treepending
 	if {$ids != $diffids} {
 	    gettreediffs $diffids
 	} else {
 	    if {[info exists diffmergeid]} {
 		contmergediff $ids
 	    } else {
 		addtocflist $ids
 	    }
 	}
 	return
     }
     set file [lindex $line 5]
     lappend treediff $file
 }
 
 proc getblobdiffs {ids} {
     global diffopts blobdifffd diffids env curdifftag curtagstart
     global difffilestart nextupdate diffinhdr treediffs
 
     set id [lindex $ids 0]
     set p [lindex $ids 1]
     set env(GIT_DIFF_OPTS) $diffopts
     set cmd [list | hg debug-diff-tree -r -p -C $p $id]
     if {[catch {set bdf [open $cmd r]} err]} {
 	puts "error getting diffs: $err"
 	return
     }
     set diffinhdr 0
     fconfigure $bdf -blocking 0
     set blobdifffd($ids) $bdf
     set curdifftag Comments
     set curtagstart 0.0
     catch {unset difffilestart}
     fileevent $bdf readable [list getblobdiffline $bdf $diffids]
     set nextupdate [expr {[clock clicks -milliseconds] + 100}]
 }
 
 proc getblobdiffline {bdf ids} {
     global diffids blobdifffd ctext curdifftag curtagstart
     global diffnexthead diffnextnote difffilestart
     global nextupdate diffinhdr treediffs
     global gaudydiff
 
     set n [gets $bdf line]
     if {$n < 0} {
 	if {[eof $bdf]} {
 	    close $bdf
 	    if {$ids == $diffids && $bdf == $blobdifffd($ids)} {
 		$ctext tag add $curdifftag $curtagstart end
 	    }
 	}
 	return
     }
     if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
 	return
     }
     $ctext conf -state normal
     if {[regexp {^diff --git a/(.*) b/(.*)} $line match fname newname]} {
 	# start of a new file
 	$ctext insert end "\n"
 	$ctext tag add $curdifftag $curtagstart end
 	set curtagstart [$ctext index "end - 1c"]
 	set header $newname
 	set here [$ctext index "end - 1c"]
 	set i [lsearch -exact $treediffs($diffids) $fname]
 	if {$i >= 0} {
 	    set difffilestart($i) $here
 	    incr i
 	    $ctext mark set fmark.$i $here
 	    $ctext mark gravity fmark.$i left
 	}
 	if {$newname != $fname} {
 	    set i [lsearch -exact $treediffs($diffids) $newname]
 	    if {$i >= 0} {
 		set difffilestart($i) $here
 		incr i
 		$ctext mark set fmark.$i $here
 		$ctext mark gravity fmark.$i left
 	    }
 	}
 	set curdifftag "f:$fname"
 	$ctext tag delete $curdifftag
 	set l [expr {(78 - [string length $header]) / 2}]
 	set pad [string range "----------------------------------------" 1 $l]
 	$ctext insert end "$pad $header $pad\n" filesep
 	set diffinhdr 1
     } elseif {[regexp {^(---|\+\+\+)} $line]} {
 	set diffinhdr 0
     } elseif {[regexp {^@@ -([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@(.*)} \
 		   $line match f1l f1c f2l f2c rest]} {
 	if {$gaudydiff} {
 	    $ctext insert end "\t" hunksep
 	    $ctext insert end "    $f1l    " d0 "    $f2l    " d1
 	    $ctext insert end "    $rest \n" hunksep
 	} else {
 	    $ctext insert end "$line\n" hunksep
 	}
 	set diffinhdr 0
     } else {
 	set x [string range $line 0 0]
 	if {$x == "-" || $x == "+"} {
 	    set tag [expr {$x == "+"}]
 	    if {$gaudydiff} {
 		set line [string range $line 1 end]
 	    }
 	    $ctext insert end "$line\n" d$tag
 	} elseif {$x == " "} {
 	    if {$gaudydiff} {
 		set line [string range $line 1 end]
 	    }
 	    $ctext insert end "$line\n"
 	} elseif {$diffinhdr || $x == "\\"} {
 	    # e.g. "\ No newline at end of file"
 	    $ctext insert end "$line\n" filesep
 	} else {
 	    # Something else we don't recognize
 	    if {$curdifftag != "Comments"} {
 		$ctext insert end "\n"
 		$ctext tag add $curdifftag $curtagstart end
 		set curtagstart [$ctext index "end - 1c"]
 		set curdifftag Comments
 	    }
 	    $ctext insert end "$line\n" filesep
 	}
     }
     $ctext conf -state disabled
     if {[clock clicks -milliseconds] >= $nextupdate} {
 	incr nextupdate 100
 	fileevent $bdf readable {}
 	update
 	fileevent $bdf readable "getblobdiffline $bdf {$ids}"
     }
 }
 
 proc nextfile {} {
     global difffilestart ctext
     set here [$ctext index @0,0]
     for {set i 0} {[info exists difffilestart($i)]} {incr i} {
 	if {[$ctext compare $difffilestart($i) > $here]} {
 	    if {![info exists pos]
 		|| [$ctext compare $difffilestart($i) < $pos]} {
 		set pos $difffilestart($i)
 	    }
 	}
     }
     if {[info exists pos]} {
 	$ctext yview $pos
     }
 }
 
 proc listboxsel {} {
     global ctext cflist currentid
     if {![info exists currentid]} return
     set sel [lsort [$cflist curselection]]
     if {$sel eq {}} return
     set first [lindex $sel 0]
     catch {$ctext yview fmark.$first}
 }
 
 proc setcoords {} {
     global linespc charspc canvx0 canvy0 mainfont
     global xspc1 xspc2 lthickness
 
     set linespc [font metrics $mainfont -linespace]
     set charspc [font measure $mainfont "m"]
     set canvy0 [expr 3 + 0.5 * $linespc]
     set canvx0 [expr 3 + 0.5 * $linespc]
     set lthickness [expr {int($linespc / 9) + 1}]
     set xspc1(0) $linespc
     set xspc2 $linespc
 }
 
 proc redisplay {} {
     global stopped redisplaying phase
     if {$stopped > 1} return
     if {$phase == "getcommits"} return
     set redisplaying 1
     if {$phase == "drawgraph" || $phase == "incrdraw"} {
 	set stopped 1
     } else {
 	drawgraph
     }
 }
 
 proc incrfont {inc} {
     global mainfont namefont textfont ctext canv phase
     global stopped entries
     unmarkmatches
     set mainfont [lreplace $mainfont 1 1 [expr {[lindex $mainfont 1] + $inc}]]
     set namefont [lreplace $namefont 1 1 [expr {[lindex $namefont 1] + $inc}]]
     set textfont [lreplace $textfont 1 1 [expr {[lindex $textfont 1] + $inc}]]
     setcoords
     $ctext conf -font $textfont
     $ctext tag conf filesep -font [concat $textfont bold]
     foreach e $entries {
 	$e conf -font $mainfont
     }
     if {$phase == "getcommits"} {
 	$canv itemconf textitems -font $mainfont
     }
     redisplay
 }
 
 proc clearsha1 {} {
     global sha1entry sha1string
     if {[string length $sha1string] == 40} {
 	$sha1entry delete 0 end
     }
 }
 
 proc sha1change {n1 n2 op} {
     global sha1string currentid sha1but
     if {$sha1string == {}
 	|| ([info exists currentid] && $sha1string == $currentid)} {
 	set state disabled
     } else {
 	set state normal
     }
     if {[$sha1but cget -state] == $state} return
     if {$state == "normal"} {
 	$sha1but conf -state normal -relief raised -text "Goto: "
     } else {
 	$sha1but conf -state disabled -relief flat -text "SHA1 ID: "
     }
 }
 
 proc gotocommit {} {
     global sha1string currentid idline tagids
     global lineid numcommits
 
     if {$sha1string == {}
 	|| ([info exists currentid] && $sha1string == $currentid)} return
     if {[info exists tagids($sha1string)]} {
 	set id $tagids($sha1string)
     } else {
 	set id [string tolower $sha1string]
 	if {[regexp {^[0-9a-f]{4,39}$} $id]} {
 	    set matches {}
 	    for {set l 0} {$l < $numcommits} {incr l} {
 		if {[string match $id* $lineid($l)]} {
 		    lappend matches $lineid($l)
 		}
 	    }
 	    if {$matches ne {}} {
 		if {[llength $matches] > 1} {
 		    error_popup "Short SHA1 id $id is ambiguous"
 		    return
 		}
 		set id [lindex $matches 0]
 	    }
 	}
     }
     if {[info exists idline($id)]} {
 	selectline $idline($id) 1
 	return
     }
     if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
 	set type "SHA1 id"
     } else {
 	set type "Tag"
     }
     error_popup "$type $sha1string is not known"
 }
 
 proc lineenter {x y id} {
     global hoverx hovery hoverid hovertimer
     global commitinfo canv
 
     if {![info exists commitinfo($id)]} return
     set hoverx $x
     set hovery $y
     set hoverid $id
     if {[info exists hovertimer]} {
 	after cancel $hovertimer
     }
     set hovertimer [after 500 linehover]
     $canv delete hover
 }
 
 proc linemotion {x y id} {
     global hoverx hovery hoverid hovertimer
 
     if {[info exists hoverid] && $id == $hoverid} {
 	set hoverx $x
 	set hovery $y
 	if {[info exists hovertimer]} {
 	    after cancel $hovertimer
 	}
 	set hovertimer [after 500 linehover]
     }
 }
 
 proc lineleave {id} {
     global hoverid hovertimer canv
 
     if {[info exists hoverid] && $id == $hoverid} {
 	$canv delete hover
 	if {[info exists hovertimer]} {
 	    after cancel $hovertimer
 	    unset hovertimer
 	}
 	unset hoverid
     }
 }
 
 proc linehover {} {
     global hoverx hovery hoverid hovertimer
     global canv linespc lthickness
     global commitinfo mainfont
 
     set text [lindex $commitinfo($hoverid) 0]
     set ymax [lindex [$canv cget -scrollregion] 3]
     if {$ymax == {}} return
     set yfrac [lindex [$canv yview] 0]
     set x [expr {$hoverx + 2 * $linespc}]
     set y [expr {$hovery + $yfrac * $ymax - $linespc / 2}]
     set x0 [expr {$x - 2 * $lthickness}]
     set y0 [expr {$y - 2 * $lthickness}]
     set x1 [expr {$x + [font measure $mainfont $text] + 2 * $lthickness}]
     set y1 [expr {$y + $linespc + 2 * $lthickness}]
     set t [$canv create rectangle $x0 $y0 $x1 $y1 \
 	       -fill \#ffff80 -outline black -width 1 -tags hover]
     $canv raise $t
     set t [$canv create text $x $y -anchor nw -text $text -tags hover]
     $canv raise $t
 }
 
 proc clickisonarrow {id y} {
     global mainline mainlinearrow sidelines lthickness
 
     set thresh [expr {2 * $lthickness + 6}]
     if {[info exists mainline($id)]} {
 	if {$mainlinearrow($id) ne "none"} {
 	    if {abs([lindex $mainline($id) 1] - $y) < $thresh} {
 		return "up"
 	    }
 	}
     }
     if {[info exists sidelines($id)]} {
 	foreach ls $sidelines($id) {
 	    set coords [lindex $ls 0]
 	    set arrow [lindex $ls 2]
 	    if {$arrow eq "first" || $arrow eq "both"} {
 		if {abs([lindex $coords 1] - $y) < $thresh} {
 		    return "up"
 		}
 	    }
 	    if {$arrow eq "last" || $arrow eq "both"} {
 		if {abs([lindex $coords end] - $y) < $thresh} {
 		    return "down"
 		}
 	    }
 	}
     }
     return {}
 }
 
 proc arrowjump {id dirn y} {
     global mainline sidelines canv
 
     set yt {}
     if {$dirn eq "down"} {
 	if {[info exists mainline($id)]} {
 	    set y1 [lindex $mainline($id) 1]
 	    if {$y1 > $y} {
 		set yt $y1
 	    }
 	}
 	if {[info exists sidelines($id)]} {
 	    foreach ls $sidelines($id) {
 		set y1 [lindex $ls 0 1]
 		if {$y1 > $y && ($yt eq {} || $y1 < $yt)} {
 		    set yt $y1
 		}
 	    }
 	}
     } else {
 	if {[info exists sidelines($id)]} {
 	    foreach ls $sidelines($id) {
 		set y1 [lindex $ls 0 end]
 		if {$y1 < $y && ($yt eq {} || $y1 > $yt)} {
 		    set yt $y1
 		}
 	    }
 	}
     }
     if {$yt eq {}} return
     set ymax [lindex [$canv cget -scrollregion] 3]
     if {$ymax eq {} || $ymax <= 0} return
     set view [$canv yview]
     set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
     set yfrac [expr {$yt / $ymax - $yspan / 2}]
     if {$yfrac < 0} {
 	set yfrac 0
     }
     $canv yview moveto $yfrac
 }
 
 proc lineclick {x y id isnew} {
     global ctext commitinfo children cflist canv thickerline
 
     unmarkmatches
     unselectline
     normalline
     $canv delete hover
     # draw this line thicker than normal
     drawlines $id 1
     set thickerline $id
     if {$isnew} {
 	set ymax [lindex [$canv cget -scrollregion] 3]
 	if {$ymax eq {}} return
 	set yfrac [lindex [$canv yview] 0]
 	set y [expr {$y + $yfrac * $ymax}]
     }
     set dirn [clickisonarrow $id $y]
     if {$dirn ne {}} {
 	arrowjump $id $dirn $y
 	return
     }
 
     if {$isnew} {
 	addtohistory [list lineclick $x $y $id 0]
     }
     # fill the details pane with info about this line
     $ctext conf -state normal
     $ctext delete 0.0 end
     $ctext tag conf link -foreground blue -underline 1
     $ctext tag bind link <Enter> { %W configure -cursor hand2 }
     $ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
     $ctext insert end "Parent:\t"
     $ctext insert end $id [list link link0]
     $ctext tag bind link0 <1> [list selbyid $id]
     set info $commitinfo($id)
     $ctext insert end "\n\t[lindex $info 0]\n"
     $ctext insert end "\tAuthor:\t[lindex $info 1]\n"
     $ctext insert end "\tDate:\t[lindex $info 2]\n"
     if {[info exists children($id)]} {
 	$ctext insert end "\nChildren:"
 	set i 0
 	foreach child $children($id) {
 	    incr i
 	    set info $commitinfo($child)
 	    $ctext insert end "\n\t"
 	    $ctext insert end $child [list link link$i]
 	    $ctext tag bind link$i <1> [list selbyid $child]
 	    $ctext insert end "\n\t[lindex $info 0]"
 	    $ctext insert end "\n\tAuthor:\t[lindex $info 1]"
 	    $ctext insert end "\n\tDate:\t[lindex $info 2]\n"
 	}
     }
     $ctext conf -state disabled
 
     $cflist delete 0 end
 }
 
 proc normalline {} {
     global thickerline
     if {[info exists thickerline]} {
 	drawlines $thickerline 0
 	unset thickerline
     }
 }
 
 proc selbyid {id} {
     global idline
     if {[info exists idline($id)]} {
 	selectline $idline($id) 1
     }
 }
 
 proc mstime {} {
     global startmstime
     if {![info exists startmstime]} {
 	set startmstime [clock clicks -milliseconds]
     }
     return [format "%.3f" [expr {([clock click -milliseconds] - $startmstime) / 1000.0}]]
 }
 
 proc rowmenu {x y id} {
     global rowctxmenu idline selectedline rowmenuid
 
     if {![info exists selectedline] || $idline($id) eq $selectedline} {
 	set state disabled
     } else {
 	set state normal
     }
     $rowctxmenu entryconfigure 0 -state $state
     $rowctxmenu entryconfigure 1 -state $state
     $rowctxmenu entryconfigure 2 -state $state
     set rowmenuid $id
     tk_popup $rowctxmenu $x $y
 }
 
 proc diffvssel {dirn} {
     global rowmenuid selectedline lineid
 
     if {![info exists selectedline]} return
     if {$dirn} {
 	set oldid $lineid($selectedline)
 	set newid $rowmenuid
     } else {
 	set oldid $rowmenuid
 	set newid $lineid($selectedline)
     }
     addtohistory [list doseldiff $oldid $newid]
     doseldiff $oldid $newid
 }
 
 proc doseldiff {oldid newid} {
     global ctext cflist
     global commitinfo
 
     $ctext conf -state normal
     $ctext delete 0.0 end
     $ctext mark set fmark.0 0.0
     $ctext mark gravity fmark.0 left
     $cflist delete 0 end
     $cflist insert end "Top"
     $ctext insert end "From "
     $ctext tag conf link -foreground blue -underline 1
     $ctext tag bind link <Enter> { %W configure -cursor hand2 }
     $ctext tag bind link <Leave> { %W configure -cursor $curtextcursor }
     $ctext tag bind link0 <1> [list selbyid $oldid]
     $ctext insert end $oldid [list link link0]
     $ctext insert end "\n     "
     $ctext insert end [lindex $commitinfo($oldid) 0]
     $ctext insert end "\n\nTo   "
     $ctext tag bind link1 <1> [list selbyid $newid]
     $ctext insert end $newid [list link link1]
     $ctext insert end "\n     "
     $ctext insert end [lindex $commitinfo($newid) 0]
     $ctext insert end "\n"
     $ctext conf -state disabled
     $ctext tag delete Comments
     $ctext tag remove found 1.0 end
     startdiff [list $newid $oldid]
 }
 
 proc mkpatch {} {
     global rowmenuid currentid commitinfo patchtop patchnum
 
     if {![info exists currentid]} return
     set oldid $currentid
     set oldhead [lindex $commitinfo($oldid) 0]
     set newid $rowmenuid
     set newhead [lindex $commitinfo($newid) 0]
     set top .patch
     set patchtop $top
     catch {destroy $top}
     toplevel $top
     label $top.title -text "Generate patch"
     grid $top.title - -pady 10
     label $top.from -text "From:"
     entry $top.fromsha1 -width 40 -relief flat
     $top.fromsha1 insert 0 $oldid
     $top.fromsha1 conf -state readonly
     grid $top.from $top.fromsha1 -sticky w
     entry $top.fromhead -width 60 -relief flat
     $top.fromhead insert 0 $oldhead
     $top.fromhead conf -state readonly
     grid x $top.fromhead -sticky w
     label $top.to -text "To:"
     entry $top.tosha1 -width 40 -relief flat
     $top.tosha1 insert 0 $newid
     $top.tosha1 conf -state readonly
     grid $top.to $top.tosha1 -sticky w
     entry $top.tohead -width 60 -relief flat
     $top.tohead insert 0 $newhead
     $top.tohead conf -state readonly
     grid x $top.tohead -sticky w
     button $top.rev -text "Reverse" -command mkpatchrev -padx 5
     grid $top.rev x -pady 10
     label $top.flab -text "Output file:"
     entry $top.fname -width 60
     $top.fname insert 0 [file normalize "patch$patchnum.patch"]
     incr patchnum
     grid $top.flab $top.fname -sticky w
     frame $top.buts
     button $top.buts.gen -text "Generate" -command mkpatchgo
     button $top.buts.can -text "Cancel" -command mkpatchcan
     grid $top.buts.gen $top.buts.can
     grid columnconfigure $top.buts 0 -weight 1 -uniform a
     grid columnconfigure $top.buts 1 -weight 1 -uniform a
     grid $top.buts - -pady 10 -sticky ew
     focus $top.fname
 }
 
 proc mkpatchrev {} {
     global patchtop
 
     set oldid [$patchtop.fromsha1 get]
     set oldhead [$patchtop.fromhead get]
     set newid [$patchtop.tosha1 get]
     set newhead [$patchtop.tohead get]
     foreach e [list fromsha1 fromhead tosha1 tohead] \
 	    v [list $newid $newhead $oldid $oldhead] {
 	$patchtop.$e conf -state normal
 	$patchtop.$e delete 0 end
 	$patchtop.$e insert 0 $v
 	$patchtop.$e conf -state readonly
     }
 }
 
 proc mkpatchgo {} {
     global patchtop
 
     set oldid [$patchtop.fromsha1 get]
     set newid [$patchtop.tosha1 get]
     set fname [$patchtop.fname get]
     if {[catch {exec hg debug-diff-tree -p $oldid $newid >$fname &} err]} {
 	error_popup "Error creating patch: $err"
     }
     catch {destroy $patchtop}
     unset patchtop
 }
 
 proc mkpatchcan {} {
     global patchtop
 
     catch {destroy $patchtop}
     unset patchtop
 }
 
 proc mktag {} {
     global rowmenuid mktagtop commitinfo
 
     set top .maketag
     set mktagtop $top
     catch {destroy $top}
     toplevel $top
     label $top.title -text "Create tag"
     grid $top.title - -pady 10
     label $top.id -text "ID:"
     entry $top.sha1 -width 40 -relief flat
     $top.sha1 insert 0 $rowmenuid
     $top.sha1 conf -state readonly
     grid $top.id $top.sha1 -sticky w
     entry $top.head -width 60 -relief flat
     $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
     $top.head conf -state readonly
     grid x $top.head -sticky w
     label $top.tlab -text "Tag name:"
     entry $top.tag -width 60
     grid $top.tlab $top.tag -sticky w
     frame $top.buts
     button $top.buts.gen -text "Create" -command mktaggo
     button $top.buts.can -text "Cancel" -command mktagcan
     grid $top.buts.gen $top.buts.can
     grid columnconfigure $top.buts 0 -weight 1 -uniform a
     grid columnconfigure $top.buts 1 -weight 1 -uniform a
     grid $top.buts - -pady 10 -sticky ew
     focus $top.tag
 }
 
 proc domktag {} {
     global mktagtop env tagids idtags
 
     set id [$mktagtop.sha1 get]
     set tag [$mktagtop.tag get]
     if {$tag == {}} {
 	error_popup "No tag name specified"
 	return
     }
     if {[info exists tagids($tag)]} {
 	error_popup "Tag \"$tag\" already exists"
 	return
     }
     if {[catch {
 	set out [exec hg tag $tag $id]
     } err]} {
 	error_popup "Error creating tag: $err"
 	return
     }
 
     set tagids($tag) $id
     lappend idtags($id) $tag
     redrawtags $id
 }
 
 proc redrawtags {id} {
     global canv linehtag idline idpos selectedline
 
     if {![info exists idline($id)]} return
     $canv delete tag.$id
     set xt [eval drawtags $id $idpos($id)]
     $canv coords $linehtag($idline($id)) $xt [lindex $idpos($id) 2]
     if {[info exists selectedline] && $selectedline == $idline($id)} {
 	selectline $selectedline 0
     }
 }
 
 proc mktagcan {} {
     global mktagtop
 
     catch {destroy $mktagtop}
     unset mktagtop
 }
 
 proc mktaggo {} {
     domktag
     mktagcan
 }
 
 proc writecommit {} {
     global rowmenuid wrcomtop commitinfo wrcomcmd
 
     set top .writecommit
     set wrcomtop $top
     catch {destroy $top}
     toplevel $top
     label $top.title -text "Write commit to file"
     grid $top.title - -pady 10
     label $top.id -text "ID:"
     entry $top.sha1 -width 40 -relief flat
     $top.sha1 insert 0 $rowmenuid
     $top.sha1 conf -state readonly
     grid $top.id $top.sha1 -sticky w
     entry $top.head -width 60 -relief flat
     $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
     $top.head conf -state readonly
     grid x $top.head -sticky w
     label $top.clab -text "Command:"
     entry $top.cmd -width 60 -textvariable wrcomcmd
     grid $top.clab $top.cmd -sticky w -pady 10
     label $top.flab -text "Output file:"
     entry $top.fname -width 60
     $top.fname insert 0 [file normalize "commit-[string range $rowmenuid 0 6]"]
     grid $top.flab $top.fname -sticky w
     frame $top.buts
     button $top.buts.gen -text "Write" -command wrcomgo
     button $top.buts.can -text "Cancel" -command wrcomcan
     grid $top.buts.gen $top.buts.can
     grid columnconfigure $top.buts 0 -weight 1 -uniform a
     grid columnconfigure $top.buts 1 -weight 1 -uniform a
     grid $top.buts - -pady 10 -sticky ew
     focus $top.fname
 }
 
 proc wrcomgo {} {
     global wrcomtop
 
     set id [$wrcomtop.sha1 get]
     set cmd "echo $id | [$wrcomtop.cmd get]"
     set fname [$wrcomtop.fname get]
     if {[catch {exec sh -c $cmd >$fname &} err]} {
 	error_popup "Error writing commit: $err"
     }
     catch {destroy $wrcomtop}
     unset wrcomtop
 }
 
 proc wrcomcan {} {
     global wrcomtop
 
     catch {destroy $wrcomtop}
     unset wrcomtop
 }
 
 proc listrefs {id} {
     global idtags idheads idotherrefs
 
     set x {}
     if {[info exists idtags($id)]} {
 	set x $idtags($id)
     }
     set y {}
     if {[info exists idheads($id)]} {
 	set y $idheads($id)
     }
     set z {}
     if {[info exists idotherrefs($id)]} {
 	set z $idotherrefs($id)
     }
     return [list $x $y $z]
 }
 
 proc rereadrefs {} {
     global idtags idheads idotherrefs
     global tagids headids otherrefids
 
     set refids [concat [array names idtags] \
 		    [array names idheads] [array names idotherrefs]]
     foreach id $refids {
 	if {![info exists ref($id)]} {
 	    set ref($id) [listrefs $id]
 	}
     }
     foreach v {tagids idtags headids idheads otherrefids idotherrefs} {
 	catch {unset $v}
     }
     readrefs
     set refids [lsort -unique [concat $refids [array names idtags] \
 			[array names idheads] [array names idotherrefs]]]
     foreach id $refids {
 	set v [listrefs $id]
 	if {![info exists ref($id)] || $ref($id) != $v} {
 	    redrawtags $id
 	}
     }
 }
 
 proc showtag {tag isnew} {
     global ctext cflist tagcontents tagids linknum
 
     if {$isnew} {
 	addtohistory [list showtag $tag 0]
     }
     $ctext conf -state normal
     $ctext delete 0.0 end
     set linknum 0
     if {[info exists tagcontents($tag)]} {
 	set text $tagcontents($tag)
     } else {
 	set text "Tag: $tag\nId:  $tagids($tag)"
     }
     appendwithlinks $text
     $ctext conf -state disabled
     $cflist delete 0 end
 }
 
 proc doquit {} {
     global stopped
     set stopped 100
     destroy .
 }
 
 # defaults...
 set datemode 0
 set boldnames 0
 set diffopts "-U 5 -p"
 set wrcomcmd "hg debug-diff-tree --stdin -p --pretty"
 
 set mainfont {Helvetica 9}
 set textfont {Courier 9}
 set findmergefiles 0
 set gaudydiff 0
 set maxgraphpct 50
 set maxwidth 16
 
 set colors {green red blue magenta darkgrey brown orange}
 
 catch {source ~/.gitk}
 
 set namefont $mainfont
 if {$boldnames} {
     lappend namefont bold
 }
 
 set revtreeargs {}
 foreach arg $argv {
     switch -regexp -- $arg {
 	"^$" { }
 	"^-b" { set boldnames 1 }
 	"^-d" { set datemode 1 }
 	default {
 	    lappend revtreeargs $arg
 	}
     }
 }
 
 set history {}
 set historyindex 0
 
 set stopped 0
 set redisplaying 0
 set stuffsaved 0
 set patchnum 0
 setcoords
 makewindow
 readrefs
 getcommits $revtreeargs

contrib/hgk.py

@@ -1,341 +1,341 b''
 #!/usr/bin/env python
 #
 # Minimal support for git commands on an hg repository
 #
 # Copyright 2005 Chris Mason <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import time, sys, signal, os
 from mercurial import hg, mdiff, fancyopts, commands, ui, util
 
 def dodiff(fp, ui, repo, node1, node2, files=None, match=util.always,
            changes=None, text=False):
     def date(c):
         return time.asctime(time.gmtime(float(c[2].split(' ')[0])))
 
     if not changes:
         (c, a, d, u) = repo.changes(node1, node2, files, match=match)
     else:
         (c, a, d, u) = changes
     if files:
         c, a, d = map(lambda x: filterfiles(files, x), (c, a, d))
 
     if not c and not a and not d:
         return
 
     if node2:
         change = repo.changelog.read(node2)
         mmap2 = repo.manifest.read(change[0])
         date2 = date(change)
         def read(f):
             return repo.file(f).read(mmap2[f])
     else:
         date2 = time.asctime()
         if not node1:
             node1 = repo.dirstate.parents()[0]
         def read(f):
             return repo.wfile(f).read()
 
     change = repo.changelog.read(node1)
     mmap = repo.manifest.read(change[0])
     date1 = date(change)
 
     for f in c:
         to = None
         if f in mmap:
             to = repo.file(f).read(mmap[f])
         tn = read(f)
         fp.write("diff --git a/%s b/%s\n" % (f, f))
         fp.write(mdiff.unidiff(to, date1, tn, date2, f, None, text=text))
     for f in a:
         to = None
         tn = read(f)
         fp.write("diff --git /dev/null b/%s\n" % (f))
         fp.write(mdiff.unidiff(to, date1, tn, date2, f, None, text=text))
     for f in d:
         to = repo.file(f).read(mmap[f])
         tn = None
         fp.write("diff --git a/%s /dev/null\n" % (f))
         fp.write(mdiff.unidiff(to, date1, tn, date2, f, None, text=text))
 
 def difftree(ui, repo, node1=None, node2=None, **opts):
     """diff trees from two commits"""
     def __difftree(repo, node1, node2):
         def date(c):
             return time.asctime(time.gmtime(float(c[2].split(' ')[0])))
 
         if node2:
             change = repo.changelog.read(node2)
             mmap2 = repo.manifest.read(change[0])
             (c, a, d, u) = repo.changes(node1, node2)
             def read(f): return repo.file(f).read(mmap2[f])
             date2 = date(change)
         else:
             date2 = time.asctime()
             (c, a, d, u) = repo.changes(node1, None)
             if not node1:
                 node1 = repo.dirstate.parents()[0]
             def read(f): return file(os.path.join(repo.root, f)).read()
 
         change = repo.changelog.read(node1)
         mmap = repo.manifest.read(change[0])
         date1 = date(change)
         empty = "0" * 40;
 
         for f in c:
             # TODO get file permissions
-            print ":100664 100664 %s %s M\t%s\t%s" % (hg.hex(mmap[f]), 
+            print ":100664 100664 %s %s M\t%s\t%s" % (hg.hex(mmap[f]),
                                                       hg.hex(mmap2[f]), f, f)
         for f in a:
             print ":000000 100664 %s %s N\t%s\t%s" % (empty, hg.hex(mmap2[f]), f, f)
         for f in d:
             print ":100664 000000 %s %s D\t%s\t%s" % (hg.hex(mmap[f]), empty, f, f)
     ##
 
     while True:
         if opts['stdin']:
             try:
                 line = raw_input().split(' ')
                 node1 = line[0]
                 if len(line) > 1:
                     node2 = line[1]
                 else:
                     node2 = None
             except EOFError:
                 break
         node1 = repo.lookup(node1)
         if node2:
             node2 = repo.lookup(node2)
         else:
             node2 = node1
             node1 = repo.changelog.parents(node1)[0]
         if opts['patch']:
             if opts['pretty']:
                 catcommit(repo, node2, "")
             dodiff(sys.stdout, ui, repo, node1, node2)
         else:
             __difftree(repo, node1, node2)
         if not opts['stdin']:
             break
 
 def catcommit(repo, n, prefix, changes=None):
     nlprefix = '\n' + prefix;
     (p1, p2) = repo.changelog.parents(n)
     (h, h1, h2) = map(hg.hex, (n, p1, p2))
     (i1, i2) = map(repo.changelog.rev, (p1, p2))
     if not changes:
         changes = repo.changelog.read(n)
     print "tree %s" % (hg.hex(changes[0]))
     if i1 != -1: print "parent %s" % (h1)
     if i2 != -1: print "parent %s" % (h2)
     date_ar = changes[2].split(' ')
     date = int(float(date_ar[0]))
     lines = changes[4].splitlines()
     if lines[-1].startswith('committer:'):
         committer = lines[-1].split(': ')[1].rstrip()
     else:
         committer = "%s %s %s" % (changes[1], date, date_ar[1])
-        
+
     print "author %s %s %s" % (changes[1], date, date_ar[1])
     print "committer %s" % (committer)
     print ""
     if prefix != "":
         print "%s%s" % (prefix, changes[4].replace('\n', nlprefix).strip())
     else:
         print changes[4]
     if prefix:
         sys.stdout.write('\0')
 
 def base(ui, repo, node1, node2):
     """Output common ancestor information"""
     node1 = repo.lookup(node1)
     node2 = repo.lookup(node2)
     n = repo.changelog.ancestor(node1, node2)
     print hg.hex(n)
 
 def catfile(ui, repo, type=None, r=None, **opts):
     """cat a specific revision"""
     # in stdin mode, every line except the commit is prefixed with two
     # spaces.  This way the our caller can find the commit without magic
     # strings
     #
     prefix = ""
     if opts['stdin']:
         try:
             (type, r) = raw_input().split(' ');
             prefix = "    "
         except EOFError:
             return
 
     else:
         if not type or not r:
             ui.warn("cat-file: type or revision not supplied\n")
             commands.help_(ui, 'cat-file')
 
     while r:
         if type != "commit":
             sys.stderr.write("aborting hg cat-file only understands commits\n")
             sys.exit(1);
         n = repo.lookup(r)
         catcommit(repo, n, prefix)
         if opts['stdin']:
             try:
                 (type, r) = raw_input().split(' ');
             except EOFError:
                 break
         else:
             break
 
 # git rev-tree is a confusing thing.  You can supply a number of
 # commit sha1s on the command line, and it walks the commit history
 # telling you which commits are reachable from the supplied ones via
 # a bitmask based on arg position.
 # you can specify a commit to stop at by starting the sha1 with ^
 def revtree(args, repo, full="tree", maxnr=0, parents=False):
     def chlogwalk():
         ch = repo.changelog
         count = ch.count()
         i = count
         l = [0] * 100
         chunk = 100
         while True:
             if chunk > i:
                 chunk = i
                 i = 0
             else:
                 i -= chunk
 
             for x in xrange(0, chunk):
                 if i + x >= count:
                     l[chunk - x:] = [0] * (chunk - x)
                     break
                 if full != None:
                     l[x] = ch.read(ch.node(i + x))
                 else:
                     l[x] = 1
             for x in xrange(chunk-1, -1, -1):
                 if l[x] != 0:
                     yield (i + x, full != None and l[x] or None)
             if i == 0:
                 break
-            
+
     # calculate and return the reachability bitmask for sha
     def is_reachable(ar, reachable, sha):
         if len(ar) == 0:
             return 1
         mask = 0
         for i in range(len(ar)):
             if sha in reachable[i]:
                 mask |= 1 << i
 
         return mask
 
     reachable = []
     stop_sha1 = []
     want_sha1 = []
     count = 0
 
     # figure out which commits they are asking for and which ones they
     # want us to stop on
     for i in range(len(args)):
         if args[i].startswith('^'):
             s = repo.lookup(args[i][1:])
             stop_sha1.append(s)
             want_sha1.append(s)
         elif args[i] != 'HEAD':
             want_sha1.append(repo.lookup(args[i]))
 
     # calculate the graph for the supplied commits
     for i in range(len(want_sha1)):
         reachable.append({});
         n = want_sha1[i];
         visit = [n];
         reachable[i][n] = 1
         while visit:
             n = visit.pop(0)
             if n in stop_sha1:
                 continue
             for p in repo.changelog.parents(n):
                 if p not in reachable[i]:
                     reachable[i][p] = 1
                     visit.append(p)
                 if p in stop_sha1:
                     continue
 
     # walk the repository looking for commits that are in our
     # reachability graph
     #for i in range(repo.changelog.count()-1, -1, -1):
     for i, changes in chlogwalk():
         n = repo.changelog.node(i)
         mask = is_reachable(want_sha1, reachable, n)
         if mask:
             parentstr = ""
             if parents:
                 pp = repo.changelog.parents(n)
                 if pp[0] != hg.nullid:
                     parentstr += " " + hg.hex(pp[0])
                 if pp[1] != hg.nullid:
                     parentstr += " " + hg.hex(pp[1])
             if not full:
                 print hg.hex(n) + parentstr
             elif full is "commit":
                 print hg.hex(n) + parentstr
                 catcommit(repo, n, '    ', changes)
             else:
                 (p1, p2) = repo.changelog.parents(n)
                 (h, h1, h2) = map(hg.hex, (n, p1, p2))
                 (i1, i2) = map(repo.changelog.rev, (p1, p2))
 
                 date = changes[2].split(' ')[0]
                 print "%s %s:%s" % (date, h, mask),
                 mask = is_reachable(want_sha1, reachable, p1)
                 if i1 != -1 and mask > 0:
                     print "%s:%s " % (h1, mask),
                 mask = is_reachable(want_sha1, reachable, p2)
                 if i2 != -1 and mask > 0:
                     print "%s:%s " % (h2, mask),
                 print ""
             if maxnr and count >= maxnr:
                 break
             count += 1
 
 # git rev-list tries to order things by date, and has the ability to stop
 # at a given commit without walking the whole repo.  TODO add the stop
 # parameter
 def revlist(ui, repo, *revs, **opts):
     """print revisions"""
     if opts['header']:
         full = "commit"
     else:
         full = None
     copy = [x for x in revs]
     revtree(copy, repo, full, opts['max_count'], opts['parents'])
 
 def view(ui, repo, *etc):
     "start interactive history viewer"
     os.chdir(repo.root)
     os.system("hgk " + " ".join(etc))
 
 cmdtable = {
     "view": (view, [], 'hg view'),
     "debug-diff-tree": (difftree, [('p', 'patch', None, 'generate patch'),
                             ('r', 'recursive', None, 'recursive'),
                             ('P', 'pretty', None, 'pretty'),
                             ('s', 'stdin', None, 'stdin'),
                             ('C', 'copy', None, 'detect copies'),
                             ('S', 'search', "", 'search')],
                             "hg git-diff-tree [options] node1 node2"),
     "debug-cat-file": (catfile, [('s', 'stdin', None, 'stdin')],
                  "hg debug-cat-file [options] type file"),
     "debug-merge-base": (base, [], "hg debug-merge-base node node"),
     "debug-rev-list": (revlist, [('H', 'header', None, 'header'),
                            ('t', 'topo-order', None, 'topo-order'),
                            ('p', 'parents', None, 'parents'),
                            ('n', 'max-count', 0, 'max-count')],
                  "hg debug-rev-list [options] revs"),
 }
 
 def reposetup(ui, repo):
     pass

contrib/mercurial.el

@@ -1,1103 +1,1103 b''
 ;;; mercurial.el --- Emacs support for the Mercurial distributed SCM
 
 ;; Copyright (C) 2005 Bryan O'Sullivan
 
 ;; Author: Bryan O'Sullivan <[e-mail]>
 
 ;; mercurial.el is free software; you can redistribute it and/or
 ;; modify it under the terms of version 2 of the GNU General Public
 ;; License as published by the Free Software Foundation.
 
 ;; mercurial.el is distributed in the hope that it will be useful, but
 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 ;; General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
 ;; along with mercurial.el, GNU Emacs, or XEmacs; see the file COPYING
 ;; (`C-h C-l').  If not, write to the Free Software Foundation, Inc.,
 ;; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 ;;; Commentary:
 
 ;; mercurial.el builds upon Emacs's VC mode to provide flexible
 ;; integration with the Mercurial distributed SCM tool.
 
 ;; To get going as quickly as possible, load mercurial.el into Emacs and
 ;; type `C-c h h'; this runs hg-help-overview, which prints a helpful
 ;; usage overview.
 
 ;; Much of the inspiration for mercurial.el comes from Rajesh
 ;; Vaidheeswarran's excellent p4.el, which does an admirably thorough
 ;; job for the commercial Perforce SCM product.  In fact, substantial
 ;; chunks of code are adapted from p4.el.
 
 ;; This code has been developed under XEmacs 21.5, and may not work as
 ;; well under GNU Emacs (albeit tested under 21.4).  Patches to
 ;; enhance the portability of this code, fix bugs, and add features
 ;; are most welcome.  You can clone a Mercurial repository for this
 ;; package from http://www.serpentine.com/hg/hg-emacs
 
 ;; Please send problem reports and suggestions to [e-mail].
 
 
 ;;; Code:
 
 (require 'advice)
 (require 'cl)
 (require 'diff-mode)
 (require 'easymenu)
 (require 'executable)
 (require 'vc)
 
 
 ;;; XEmacs has view-less, while GNU Emacs has view.  Joy.
 
 (condition-case nil
     (require 'view-less)
   (error nil))
 (condition-case nil
     (require 'view)
   (error nil))
 
 
 ;;; Variables accessible through the custom system.
 
 (defgroup mercurial nil
   "Mercurial distributed SCM."
   :group 'tools)
 
 (defcustom hg-binary
     (or (executable-find "hg")
 	(dolist (path '("~/bin/hg" "/usr/bin/hg" "/usr/local/bin/hg"))
 	  (when (file-executable-p path)
 	    (return path))))
   "The path to Mercurial's hg executable."
   :type '(file :must-match t)
   :group 'mercurial)
 
 (defcustom hg-mode-hook nil
   "Hook run when a buffer enters hg-mode."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-commit-mode-hook nil
   "Hook run when a buffer is created to prepare a commit."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-pre-commit-hook nil
   "Hook run before a commit is performed.
 If you want to prevent the commit from proceeding, raise an error."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-log-mode-hook nil
   "Hook run after a buffer is filled with log information."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-global-prefix "\C-ch"
   "The global prefix for Mercurial keymap bindings."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-commit-allow-empty-message nil
   "Whether to allow changes to be committed with empty descriptions."
   :type 'boolean
   :group 'mercurial)
 
 (defcustom hg-commit-allow-empty-file-list nil
   "Whether to allow changes to be committed without any modified files."
   :type 'boolean
   :group 'mercurial)
 
 (defcustom hg-rev-completion-limit 100
   "The maximum number of revisions that hg-read-rev will offer to complete.
 This affects memory usage and performance when prompting for revisions
 in a repository with a lot of history."
   :type 'integer
   :group 'mercurial)
 
 (defcustom hg-log-limit 50
   "The maximum number of revisions that hg-log will display."
   :type 'integer
   :group 'mercurial)
 
 (defcustom hg-update-modeline t
   "Whether to update the modeline with the status of a file after every save.
 Set this to nil on platforms with poor process management, such as Windows."
   :type 'boolean
   :group 'mercurial)
 
 (defcustom hg-incoming-repository "default"
   "The repository from which changes are pulled from by default.
 This should be a symbolic repository name, since it is used for all
 repository-related commands."
   :type 'string
   :group 'mercurial)
 
 (defcustom hg-outgoing-repository "default-push"
   "The repository to which changes are pushed to by default.
 This should be a symbolic repository name, since it is used for all
 repository-related commands."
   :type 'string
   :group 'mercurial)
 
 
 ;;; Other variables.
 
 (defconst hg-running-xemacs (string-match "XEmacs" emacs-version)
   "Is mercurial.el running under XEmacs?")
 
 (defvar hg-mode nil
   "Is this file managed by Mercurial?")
 (make-variable-buffer-local 'hg-mode)
 (put 'hg-mode 'permanent-local t)
 
 (defvar hg-status nil)
 (make-variable-buffer-local 'hg-status)
 (put 'hg-status 'permanent-local t)
 
 (defvar hg-prev-buffer nil)
 (make-variable-buffer-local 'hg-prev-buffer)
 (put 'hg-prev-buffer 'permanent-local t)
 
 (defvar hg-root nil)
 (make-variable-buffer-local 'hg-root)
 (put 'hg-root 'permanent-local t)
 
 (defvar hg-output-buffer-name "*Hg*"
   "The name to use for Mercurial output buffers.")
 
 (defvar hg-file-history nil)
 (defvar hg-repo-history nil)
 (defvar hg-rev-history nil)
 
 
 ;;; Random constants.
 
 (defconst hg-commit-message-start
   "--- Enter your commit message.  Type `C-c C-c' to commit. ---\n")
 
 (defconst hg-commit-message-end
   "--- Files in bold will be committed.  Click to toggle selection. ---\n")
 
 
 ;;; hg-mode keymap.
 
 (defvar hg-mode-map (make-sparse-keymap))
 (define-key hg-mode-map "\C-xv" 'hg-prefix-map)
 
 (defvar hg-prefix-map
   (let ((map (copy-keymap vc-prefix-map)))
     (if (functionp 'set-keymap-name)
       (set-keymap-name map 'hg-prefix-map)); XEmacs
     map)
   "This keymap overrides some default vc-mode bindings.")
 (fset 'hg-prefix-map hg-prefix-map)
 (define-key hg-prefix-map "=" 'hg-diff)
 (define-key hg-prefix-map "c" 'hg-undo)
 (define-key hg-prefix-map "g" 'hg-annotate)
 (define-key hg-prefix-map "l" 'hg-log)
 (define-key hg-prefix-map "n" 'hg-commit-start)
 ;; (define-key hg-prefix-map "r" 'hg-update)
 (define-key hg-prefix-map "u" 'hg-revert-buffer)
 (define-key hg-prefix-map "~" 'hg-version-other-window)
 
 (add-minor-mode 'hg-mode 'hg-mode hg-mode-map)
 
 
 ;;; Global keymap.
 
 (global-set-key "\C-xvi" 'hg-add)
 
 (defvar hg-global-map (make-sparse-keymap))
 (fset 'hg-global-map hg-global-map)
 (global-set-key hg-global-prefix 'hg-global-map)
 (define-key hg-global-map "," 'hg-incoming)
 (define-key hg-global-map "." 'hg-outgoing)
 (define-key hg-global-map "<" 'hg-pull)
 (define-key hg-global-map "=" 'hg-diff-repo)
 (define-key hg-global-map ">" 'hg-push)
 (define-key hg-global-map "?" 'hg-help-overview)
 (define-key hg-global-map "A" 'hg-addremove)
 (define-key hg-global-map "U" 'hg-revert)
 (define-key hg-global-map "a" 'hg-add)
 (define-key hg-global-map "c" 'hg-commit-start)
 (define-key hg-global-map "f" 'hg-forget)
 (define-key hg-global-map "h" 'hg-help-overview)
 (define-key hg-global-map "i" 'hg-init)
 (define-key hg-global-map "l" 'hg-log-repo)
 (define-key hg-global-map "r" 'hg-root)
 (define-key hg-global-map "s" 'hg-status)
 (define-key hg-global-map "u" 'hg-update)
 
 
 ;;; View mode keymap.
 
 (defvar hg-view-mode-map
   (let ((map (copy-keymap (if (boundp 'view-minor-mode-map)
 			      view-minor-mode-map
 			    view-mode-map))))
     (if (functionp 'set-keymap-name)
       (set-keymap-name map 'hg-view-mode-map)); XEmacs
     map))
 (fset 'hg-view-mode-map hg-view-mode-map)
 (define-key hg-view-mode-map
   (if hg-running-xemacs [button2] [mouse-2])
   'hg-buffer-mouse-clicked)
 
 
 ;;; Commit mode keymaps.
 
 (defvar hg-commit-mode-map (make-sparse-keymap))
 (define-key hg-commit-mode-map "\C-c\C-c" 'hg-commit-finish)
 (define-key hg-commit-mode-map "\C-c\C-k" 'hg-commit-kill)
 (define-key hg-commit-mode-map "\C-xv=" 'hg-diff-repo)
 
 (defvar hg-commit-mode-file-map (make-sparse-keymap))
 (define-key hg-commit-mode-file-map
   (if hg-running-xemacs [button2] [mouse-2])
   'hg-commit-mouse-clicked)
 (define-key hg-commit-mode-file-map " " 'hg-commit-toggle-file)
 (define-key hg-commit-mode-file-map "\r" 'hg-commit-toggle-file)
-  
+
 
 ;;; Convenience functions.
 
 (defsubst hg-binary ()
   (if hg-binary
       hg-binary
     (error "No `hg' executable found!")))
 
 (defsubst hg-replace-in-string (str regexp newtext &optional literal)
   "Replace all matches in STR for REGEXP with NEWTEXT string.
 Return the new string.  Optional LITERAL non-nil means do a literal
 replacement.
 
 This function bridges yet another pointless impedance gap between
 XEmacs and GNU Emacs."
   (if (fboundp 'replace-in-string)
       (replace-in-string str regexp newtext literal)
     (replace-regexp-in-string regexp newtext str nil literal)))
 
 (defsubst hg-strip (str)
   "Strip leading and trailing blank lines from a string."
   (hg-replace-in-string (hg-replace-in-string str "[\r\n][ \t\r\n]*\\'" "")
 			"\\`[ \t\r\n]*[\r\n]" ""))
 
 (defsubst hg-chomp (str)
   "Strip trailing newlines from a string."
   (hg-replace-in-string str "[\r\n]+\'" ""))
 
 (defun hg-run-command (command &rest args)
   "Run the shell command COMMAND, returning (EXIT-CODE . COMMAND-OUTPUT).
 The list ARGS contains a list of arguments to pass to the command."
   (let* (exit-code
 	 (output
 	  (with-output-to-string
 	    (with-current-buffer
 		standard-output
 	      (setq exit-code
 		    (apply 'call-process command nil t nil args))))))
     (cons exit-code output)))
 
 (defun hg-run (command &rest args)
   "Run the Mercurial command COMMAND, returning (EXIT-CODE . COMMAND-OUTPUT)."
   (apply 'hg-run-command (hg-binary) command args))
 
 (defun hg-run0 (command &rest args)
   "Run the Mercurial command COMMAND, returning its output.
 If the command does not exit with a zero status code, raise an error."
   (let ((res (apply 'hg-run-command (hg-binary) command args)))
     (if (not (eq (car res) 0))
 	(error "Mercurial command failed %s - exit code %s"
 	       (cons command args)
 	       (car res))
       (cdr res))))
 
 (defun hg-sync-buffers (path)
   "Sync buffers visiting PATH with their on-disk copies.
 If PATH is not being visited, but is under the repository root, sync
 all buffers visiting files in the repository."
   (let ((buf (find-buffer-visiting path)))
     (if buf
 	(with-current-buffer buf
 	  (vc-buffer-sync))
       (hg-do-across-repo path
 	(vc-buffer-sync)))))
-  
+
 (defun hg-buffer-commands (pnt)
   "Use the properties of a character to do something sensible."
   (interactive "d")
   (let ((rev (get-char-property pnt 'rev))
 	(file (get-char-property pnt 'file))
 	(date (get-char-property pnt 'date))
 	(user (get-char-property pnt 'user))
 	(host (get-char-property pnt 'host))
 	(prev-buf (current-buffer)))
     (cond
      (file
       (find-file-other-window file))
      (rev
       (hg-diff hg-view-file-name rev rev prev-buf))
      ((message "I don't know how to do that yet")))))
 
 (defsubst hg-event-point (event)
   "Return the character position of the mouse event EVENT."
   (if hg-running-xemacs
       (event-point event)
     (posn-point (event-start event))))
 
 (defsubst hg-event-window (event)
   "Return the window over which mouse event EVENT occurred."
   (if hg-running-xemacs
       (event-window event)
     (posn-window (event-start event))))
 
 (defun hg-buffer-mouse-clicked (event)
   "Translate the mouse clicks in a HG log buffer to character events.
 These are then handed off to `hg-buffer-commands'.
 
 Handle frickin' frackin' gratuitous event-related incompatibilities."
   (interactive "e")
   (select-window (hg-event-window event))
   (hg-buffer-commands (hg-event-point event)))
 
 (unless (fboundp 'view-minor-mode)
   (defun view-minor-mode (prev-buffer exit-func)
     (view-mode)))
 
 (defsubst hg-abbrev-file-name (file)
   "Portable wrapper around abbreviate-file-name."
   (if hg-running-xemacs
       (abbreviate-file-name file t)
     (abbreviate-file-name file)))
 
 (defun hg-read-file-name (&optional prompt default)
   "Read a file or directory name, or a pattern, to use with a command."
   (save-excursion
     (while hg-prev-buffer
       (set-buffer hg-prev-buffer))
     (let ((path (or default (buffer-file-name))))
       (if (or (not path) current-prefix-arg)
 	  (expand-file-name
 	   (read-file-name (format "File, directory or pattern%s: "
 				   (or prompt ""))
 			   (and path (file-name-directory path))
 			   nil nil
 			   (and path (file-name-nondirectory path))
 			   'hg-file-history))
 	path))))
 
 (defun hg-read-config ()
   "Return an alist of (key . value) pairs of Mercurial config data.
 Each key is of the form (section . name)."
   (let (items)
     (dolist (line (split-string (hg-chomp (hg-run0 "debugconfig")) "\n") items)
       (string-match "^\\([^=]*\\)=\\(.*\\)" line)
       (let* ((left (substring line (match-beginning 1) (match-end 1)))
 	     (right (substring line (match-beginning 2) (match-end 2)))
 	     (key (split-string left "\\."))
 	     (value (hg-replace-in-string right "\\\\n" "\n" t)))
 	(setq items (cons (cons (cons (car key) (cadr key)) value) items))))))
-  
+
 (defun hg-config-section (section config)
   "Return an alist of (name . value) pairs for SECTION of CONFIG."
   (let (items)
     (dolist (item config items)
       (when (equal (caar item) section)
 	(setq items (cons (cons (cdar item) (cdr item)) items))))))
 
 (defun hg-string-starts-with (sub str)
   "Indicate whether string STR starts with the substring or character SUB."
   (if (not (stringp sub))
       (and (> (length str) 0) (equal (elt str 0) sub))
     (let ((sub-len (length sub)))
       (and (<= sub-len (length str))
 	   (string= sub (substring str 0 sub-len))))))
 
 (defun hg-complete-repo (string predicate all)
   "Attempt to complete a repository name.
 We complete on either symbolic names from Mercurial's config or real
 directory names from the file system.  We do not penalise URLs."
   (or (if all
 	  (all-completions string hg-repo-completion-table predicate)
 	(try-completion string hg-repo-completion-table predicate))
       (let* ((str (expand-file-name string))
 	     (dir (file-name-directory str))
 	     (file (file-name-nondirectory str)))
 	(if all
 	    (let (completions)
 	      (dolist (name (delete "./" (file-name-all-completions file dir))
 			    completions)
 		(let ((path (concat dir name)))
 		  (when (file-directory-p path)
 		    (setq completions (cons name completions))))))
 	  (let ((comp (file-name-completion file dir)))
 	    (if comp
 		(hg-abbrev-file-name (concat dir comp))))))))
 
 (defun hg-read-repo-name (&optional prompt initial-contents default)
   "Read the location of a repository."
   (save-excursion
     (while hg-prev-buffer
       (set-buffer hg-prev-buffer))
     (let (hg-repo-completion-table)
       (if current-prefix-arg
 	  (progn
 	    (dolist (path (hg-config-section "paths" (hg-read-config)))
 	      (setq hg-repo-completion-table
 		    (cons (cons (car path) t) hg-repo-completion-table))
 	      (unless (hg-string-starts-with directory-sep-char (cdr path))
 		(setq hg-repo-completion-table
 		      (cons (cons (cdr path) t) hg-repo-completion-table))))
 	    (completing-read (format "Repository%s: " (or prompt ""))
 			     'hg-complete-repo
 			     nil
 			     nil
 			     initial-contents
 			     'hg-repo-history
 			     default))
 	default))))
 
 (defun hg-read-rev (&optional prompt default)
   "Read a revision or tag, offering completions."
   (save-excursion
     (while hg-prev-buffer
       (set-buffer hg-prev-buffer))
     (let ((rev (or default "tip")))
       (if current-prefix-arg
 	  (let ((revs (split-string
 		       (hg-chomp
 			(hg-run0 "-q" "log" "-r"
 				 (format "-%d:tip" hg-rev-completion-limit)))
 		       "[\n:]")))
 	    (dolist (line (split-string (hg-chomp (hg-run0 "tags")) "\n"))
 	      (setq revs (cons (car (split-string line "\\s-")) revs)))
 	    (completing-read (format "Revision%s (%s): "
 				     (or prompt "")
 				     (or default "tip"))
 			     (map 'list 'cons revs revs)
 			     nil
 			     nil
 			     nil
 			     'hg-rev-history
 			     (or default "tip")))
 	rev))))
 
 (defmacro hg-do-across-repo (path &rest body)
   (let ((root-name (gensym "root-"))
 	(buf-name (gensym "buf-")))
     `(let ((,root-name (hg-root ,path)))
        (save-excursion
 	 (dolist (,buf-name (buffer-list))
 	   (set-buffer ,buf-name)
 	   (when (and hg-status (equal (hg-root buffer-file-name) ,root-name))
 	     ,@body))))))
 
 (put 'hg-do-across-repo 'lisp-indent-function 1)
 
 
 ;;; View mode bits.
 
 (defun hg-exit-view-mode (buf)
   "Exit from hg-view-mode.
 We delete the current window if entering hg-view-mode split the
 current frame."
   (when (and (eq buf (current-buffer))
 	     (> (length (window-list)) 1))
     (delete-window))
   (when (buffer-live-p buf)
     (kill-buffer buf)))
 
 (defun hg-view-mode (prev-buffer &optional file-name)
   (goto-char (point-min))
   (set-buffer-modified-p nil)
   (toggle-read-only t)
   (view-minor-mode prev-buffer 'hg-exit-view-mode)
   (use-local-map hg-view-mode-map)
   (setq truncate-lines t)
   (when file-name
     (set (make-local-variable 'hg-view-file-name)
 	 (hg-abbrev-file-name file-name))))
-  
+
 (defun hg-file-status (file)
   "Return status of FILE, or nil if FILE does not exist or is unmanaged."
   (let* ((s (hg-run "status" file))
 	 (exit (car s))
 	 (output (cdr s)))
     (if (= exit 0)
 	(let ((state (assoc (substring output 0 (min (length output) 2))
 			    '(("M " . modified)
 			      ("A " . added)
 			      ("R " . removed)
 			      ("? " . nil)))))
 	  (if state
 	      (cdr state)
 	    'normal)))))
 
 (defun hg-tip ()
   (split-string (hg-chomp (hg-run0 "-q" "tip")) ":"))
 
 (defmacro hg-view-output (args &rest body)
   "Execute BODY in a clean buffer, then quickly display that buffer.
 If the buffer contains one line, its contents are displayed in the
 minibuffer.  Otherwise, the buffer is displayed in view-mode.
 ARGS is of the form (BUFFER-NAME &optional FILE), where BUFFER-NAME is
 the name of the buffer to create, and FILE is the name of the file
 being viewed."
   (let ((prev-buf (gensym "prev-buf-"))
 	(v-b-name (car args))
 	(v-m-rest (cdr args)))
     `(let ((view-buf-name ,v-b-name)
 	   (,prev-buf (current-buffer)))
        (get-buffer-create view-buf-name)
        (kill-buffer view-buf-name)
        (get-buffer-create view-buf-name)
        (set-buffer view-buf-name)
        (save-excursion
 	 ,@body)
        (case (count-lines (point-min) (point-max))
 	 ((0)
 	  (kill-buffer view-buf-name)
 	  (message "(No output)"))
 	 ((1)
 	  (let ((msg (hg-chomp (buffer-substring (point-min) (point-max)))))
 	    (kill-buffer view-buf-name)
 	    (message "%s" msg)))
 	 (t
 	  (pop-to-buffer view-buf-name)
 	  (setq hg-prev-buffer ,prev-buf)
 	  (hg-view-mode ,prev-buf ,@v-m-rest))))))
 
 (put 'hg-view-output 'lisp-indent-function 1)
 
 ;;; Context save and restore across revert.
 
 (defun hg-position-context (pos)
   "Return information to help find the given position again."
   (let* ((end (min (point-max) (+ pos 98))))
     (list pos
 	  (buffer-substring (max (point-min) (- pos 2)) end)
 	  (- end pos))))
 
 (defun hg-buffer-context ()
   "Return information to help restore a user's editing context.
 This is useful across reverts and merges, where a context is likely
 to have moved a little, but not really changed."
   (let ((point-context (hg-position-context (point)))
 	(mark-context (let ((mark (mark-marker)))
 			(and mark (hg-position-context mark)))))
     (list point-context mark-context)))
-	
+
 (defun hg-find-context (ctx)
   "Attempt to find a context in the given buffer.
 Always returns a valid, hopefully sane, position."
   (let ((pos (nth 0 ctx))
 	(str (nth 1 ctx))
 	(fixup (nth 2 ctx)))
     (save-excursion
       (goto-char (max (point-min) (- pos 15000)))
       (if (and (not (equal str ""))
 	       (search-forward str nil t))
 	  (- (point) fixup)
 	(max pos (point-min))))))
 
 (defun hg-restore-context (ctx)
   "Attempt to restore the user's editing context."
   (let ((point-context (nth 0 ctx))
 	(mark-context (nth 1 ctx)))
     (goto-char (hg-find-context point-context))
     (when mark-context
       (set-mark (hg-find-context mark-context)))))
 
 
 ;;; Hooks.
 
 (defun hg-mode-line (&optional force)
   "Update the modeline with the current status of a file.
 An update occurs if optional argument FORCE is non-nil,
 hg-update-modeline is non-nil, or we have not yet checked the state of
 the file."
   (when (and (hg-root) (or force hg-update-modeline (not hg-mode)))
     (let ((status (hg-file-status buffer-file-name)))
       (setq hg-status status
 	    hg-mode (and status (concat " Hg:"
 					(car (hg-tip))
 					(cdr (assq status
 						   '((normal . "")
 						     (removed . "r")
 						     (added . "a")
 						     (modified . "m")))))))
       status)))
 
 (defun hg-mode ()
   "Minor mode for Mercurial distributed SCM integration.
 
 The Mercurial mode user interface is based on that of VC mode, so if
 you're already familiar with VC, the same keybindings and functions
 will generally work.
 
 Below is a list of many common SCM tasks.  In the list, `G/L'
 indicates whether a key binding is global (G) to a repository or local
 (L) to a file.  Many commands take a prefix argument.
 
 SCM Task                              G/L  Key Binding  Command Name
 --------                              ---  -----------  ------------
 Help overview (what you are reading)  G    C-c h h      hg-help-overview
 
 Tell Mercurial to manage a file       G    C-c h a      hg-add
 Commit changes to current file only   L    C-x v n      hg-commit-start
 Undo changes to file since commit     L    C-x v u      hg-revert-buffer
 
 Diff file vs last checkin             L    C-x v =      hg-diff
 
 View file change history              L    C-x v l      hg-log
 View annotated file                   L    C-x v a      hg-annotate
 
 Diff repo vs last checkin             G    C-c h =      hg-diff-repo
 View status of files in repo          G    C-c h s      hg-status
 Commit all changes                    G    C-c h c      hg-commit-start
 
 Undo all changes since last commit    G    C-c h U      hg-revert
 View repo change history              G    C-c h l      hg-log-repo
 
 See changes that can be pulled        G    C-c h ,      hg-incoming
 Pull changes                          G    C-c h <      hg-pull
 Update working directory after pull   G    C-c h u      hg-update
 See changes that can be pushed        G    C-c h .      hg-outgoing
 Push changes                          G    C-c h >      hg-push"
   (run-hooks 'hg-mode-hook))
 
 (defun hg-find-file-hook ()
   (when (hg-mode-line)
     (hg-mode)))
 
 (add-hook 'find-file-hooks 'hg-find-file-hook)
 
 (defun hg-after-save-hook ()
   (let ((old-status hg-status))
     (hg-mode-line)
     (if (and (not old-status) hg-status)
 	(hg-mode))))
 
 (add-hook 'after-save-hook 'hg-after-save-hook)
 
 
 ;;; User interface functions.
 
 (defun hg-help-overview ()
   "This is an overview of the Mercurial SCM mode for Emacs.
 
 You can find the source code, license (GPL v2), and credits for this
 code by typing `M-x find-library mercurial RET'."
   (interactive)
   (hg-view-output ("Mercurial Help Overview")
     (insert (documentation 'hg-help-overview))
     (let ((pos (point)))
       (insert (documentation 'hg-mode))
       (goto-char pos)
       (kill-line))))
 
 (defun hg-add (path)
   "Add PATH to the Mercurial repository on the next commit.
 With a prefix argument, prompt for the path to add."
   (interactive (list (hg-read-file-name " to add")))
   (let ((buf (current-buffer))
 	(update (equal buffer-file-name path)))
     (hg-view-output (hg-output-buffer-name)
       (apply 'call-process (hg-binary) nil t nil (list "add" path)))
     (when update
       (with-current-buffer buf
 	(hg-mode-line)))))
 
 (defun hg-addremove ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-annotate ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-commit-toggle-file (pos)
   "Toggle whether or not the file at POS will be committed."
   (interactive "d")
   (save-excursion
     (goto-char pos)
     (let ((face (get-text-property pos 'face))
 	  (inhibit-read-only t)
 	  bol)
       (beginning-of-line)
       (setq bol (+ (point) 4))
       (end-of-line)
       (if (eq face 'bold)
 	  (progn
 	    (remove-text-properties bol (point) '(face nil))
 	    (message "%s will not be committed"
 		     (buffer-substring bol (point))))
 	(add-text-properties bol (point) '(face bold))
 	(message "%s will be committed"
 		 (buffer-substring bol (point)))))))
-	
+
 (defun hg-commit-mouse-clicked (event)
   "Toggle whether or not the file at POS will be committed."
   (interactive "@e")
   (hg-commit-toggle-file (hg-event-point event)))
 
 (defun hg-commit-kill ()
   "Kill the commit currently being prepared."
   (interactive)
   (when (or (not (buffer-modified-p)) (y-or-n-p "Really kill this commit? "))
     (let ((buf hg-prev-buffer))
       (kill-buffer nil)
       (switch-to-buffer buf))))
 
 (defun hg-commit-finish ()
   "Finish preparing a commit, and perform the actual commit.
 The hook hg-pre-commit-hook is run before anything else is done.  If
 the commit message is empty and hg-commit-allow-empty-message is nil,
 an error is raised.  If the list of files to commit is empty and
 hg-commit-allow-empty-file-list is nil, an error is raised."
   (interactive)
   (let ((root hg-root))
     (save-excursion
       (run-hooks 'hg-pre-commit-hook)
       (goto-char (point-min))
       (search-forward hg-commit-message-start)
       (let (message files)
 	(let ((start (point)))
 	  (goto-char (point-max))
 	  (search-backward hg-commit-message-end)
 	  (setq message (hg-strip (buffer-substring start (point)))))
 	(when (and (= (length message) 0)
 		   (not hg-commit-allow-empty-message))
 	  (error "Cannot proceed - commit message is empty"))
 	(forward-line 1)
 	(beginning-of-line)
 	(while (< (point) (point-max))
 	  (let ((pos (+ (point) 4)))
 	    (end-of-line)
 	    (when (eq (get-text-property pos 'face) 'bold)
 	      (end-of-line)
 	      (setq files (cons (buffer-substring pos (point)) files))))
 	  (forward-line 1))
 	(when (and (= (length files) 0)
 		   (not hg-commit-allow-empty-file-list))
 	  (error "Cannot proceed - no files to commit"))
 	(setq message (concat message "\n"))
 	(apply 'hg-run0 "--cwd" hg-root "commit" "-m" message files))
       (let ((buf hg-prev-buffer))
 	(kill-buffer nil)
 	(switch-to-buffer buf))
       (hg-do-across-repo root
 	(hg-mode-line)))))
 
 (defun hg-commit-mode ()
   "Mode for describing a commit of changes to a Mercurial repository.
 This involves two actions: describing the changes with a commit
 message, and choosing the files to commit.
 
 To describe the commit, simply type some text in the designated area.
 
 By default, all modified, added and removed files are selected for
 committing.  Files that will be committed are displayed in bold face\;
 those that will not are displayed in normal face.
 
 To toggle whether a file will be committed, move the cursor over a
 particular file and hit space or return.  Alternatively, middle click
 on the file.
 
 Key bindings
 ------------
 \\[hg-commit-finish]		proceed with commit
 \\[hg-commit-kill]		kill commit
 
 \\[hg-diff-repo]		view diff of pending changes"
   (interactive)
   (use-local-map hg-commit-mode-map)
   (set-syntax-table text-mode-syntax-table)
   (setq local-abbrev-table text-mode-abbrev-table
 	major-mode 'hg-commit-mode
 	mode-name "Hg-Commit")
   (set-buffer-modified-p nil)
   (setq buffer-undo-list nil)
   (run-hooks 'text-mode-hook 'hg-commit-mode-hook))
 
 (defun hg-commit-start ()
   "Prepare a commit of changes to the repository containing the current file."
   (interactive)
   (while hg-prev-buffer
     (set-buffer hg-prev-buffer))
   (let ((root (hg-root))
 	(prev-buffer (current-buffer))
 	modified-files)
     (unless root
       (error "Cannot commit outside a repository!"))
     (hg-sync-buffers root)
     (setq modified-files (hg-chomp (hg-run0 "--cwd" root "status" "-arm")))
     (when (and (= (length modified-files) 0)
 	       (not hg-commit-allow-empty-file-list))
       (error "No pending changes to commit"))
     (let* ((buf-name (format "*Mercurial: Commit %s*" root)))
       (pop-to-buffer (get-buffer-create buf-name))
       (when (= (point-min) (point-max))
 	(set (make-local-variable 'hg-root) root)
 	(setq hg-prev-buffer prev-buffer)
 	(insert "\n")
 	(let ((bol (point)))
 	  (insert hg-commit-message-end)
 	  (add-text-properties bol (point) '(face bold-italic)))
 	(let ((file-area (point)))
 	  (insert modified-files)
 	  (goto-char file-area)
 	  (while (< (point) (point-max))
 	    (let ((bol (point)))
 	      (forward-char 1)
 	      (insert "  ")
 	      (end-of-line)
 	      (add-text-properties (+ bol 4) (point)
 				   '(face bold mouse-face highlight)))
 	    (forward-line 1))
 	  (goto-char file-area)
 	  (add-text-properties (point) (point-max)
 			       `(keymap ,hg-commit-mode-file-map))
 	  (goto-char (point-min))
 	  (insert hg-commit-message-start)
 	  (add-text-properties (point-min) (point) '(face bold-italic))
 	  (insert "\n\n")
 	  (forward-line -1)
 	  (save-excursion
 	    (goto-char (point-max))
 	    (search-backward hg-commit-message-end)
 	    (add-text-properties (match-beginning 0) (point-max)
 				 '(read-only t))
 	    (goto-char (point-min))
 	    (search-forward hg-commit-message-start)
 	    (add-text-properties (match-beginning 0) (match-end 0)
 				 '(read-only t)))
 	  (hg-commit-mode))))))
 
 (defun hg-diff (path &optional rev1 rev2)
   "Show the differences between REV1 and REV2 of PATH.
 When called interactively, the default behaviour is to treat REV1 as
 the tip revision, REV2 as the current edited version of the file, and
 PATH as the file edited in the current buffer.
 With a prefix argument, prompt for all of these."
   (interactive (list (hg-read-file-name " to diff")
 		     (hg-read-rev " to start with")
 		     (let ((rev2 (hg-read-rev " to end with" 'working-dir)))
 		       (and (not (eq rev2 'working-dir)) rev2))))
   (hg-sync-buffers path)
   (let ((a-path (hg-abbrev-file-name path))
 	(r1 (or rev1 "tip"))
 	diff)
     (hg-view-output ((cond
 		      ((and (equal r1 "tip") (not rev2))
 		       (format "Mercurial: Diff against tip of %s" a-path))
 		      ((equal r1 rev2)
 		       (format "Mercurial: Diff of rev %s of %s" r1 a-path))
 		      (t
 		       (format "Mercurial: Diff from rev %s to %s of %s"
 			       r1 (or rev2 "Current") a-path))))
       (if rev2
 	  (call-process (hg-binary) nil t nil "diff" "-r" r1 "-r" rev2 path)
 	(call-process (hg-binary) nil t nil "diff" "-r" r1 path))
       (diff-mode)
       (setq diff (not (= (point-min) (point-max))))
       (font-lock-fontify-buffer))
     diff))
 
 (defun hg-diff-repo ()
   "Show the differences between the working copy and the tip revision."
   (interactive)
   (hg-diff (hg-root)))
 
 (defun hg-forget (path)
   "Lose track of PATH, which has been added, but not yet committed.
 This will prevent the file from being incorporated into the Mercurial
 repository on the next commit.
 With a prefix argument, prompt for the path to forget."
   (interactive (list (hg-read-file-name " to forget")))
   (let ((buf (current-buffer))
 	(update (equal buffer-file-name path)))
     (hg-view-output (hg-output-buffer-name)
       (apply 'call-process (hg-binary) nil t nil (list "forget" path)))
     (when update
       (with-current-buffer buf
 	(hg-mode-line)))))
-  
+
 (defun hg-incoming (&optional repo)
   "Display changesets present in REPO that are not present locally."
   (interactive (list (hg-read-repo-name " where changes would come from")))
   (hg-view-output ((format "Mercurial: Incoming from %s to %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-incoming-repository))))
     (call-process (hg-binary) nil t nil "incoming"
 		  (or repo hg-incoming-repository))
     (hg-log-mode)))
 
 (defun hg-init ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-log-mode ()
   "Mode for viewing a Mercurial change log."
   (goto-char (point-min))
   (when (looking-at "^searching for changes")
     (kill-entire-line))
   (run-hooks 'hg-log-mode-hook))
 
 (defun hg-log (path &optional rev1 rev2)
   "Display the revision history of PATH, between REV1 and REV2.
 REV1 defaults to hg-log-limit changes from the tip revision, while
 REV2 defaults to the tip.
 With a prefix argument, prompt for each parameter."
   (interactive (list (hg-read-file-name " to log")
 		     (hg-read-rev " to start with" "-1")
 		     (hg-read-rev " to end with" (format "-%d" hg-log-limit))))
   (let ((a-path (hg-abbrev-file-name path))
 	(r1 (or rev1 (format "-%d" hg-log-limit)))
 	(r2 (or rev2 rev1 "-1")))
     (hg-view-output ((if (equal r1 r2)
 			 (format "Mercurial: Log of rev %s of %s" rev1 a-path)
 		       (format "Mercurial: Log from rev %s to %s of %s"
 			       r1 r2 a-path)))
       (let ((revs (format "%s:%s" r1 r2)))
 	(if (> (length path) (length (hg-root path)))
 	    (call-process (hg-binary) nil t nil "log" "-r" revs path)
 	  (call-process (hg-binary) nil t nil "log" "-r" revs)))
       (hg-log-mode))))
 
 (defun hg-log-repo (path &optional rev1 rev2)
   "Display the revision history of the repository containing PATH.
 History is displayed between REV1, which defaults to the tip, and
 REV2, which defaults to the initial revision.
 Variable hg-log-limit controls the number of log entries displayed."
   (interactive (list (hg-read-file-name " to log")
 		     (hg-read-rev " to start with" "tip")
 		     (hg-read-rev " to end with" (format "-%d" hg-log-limit))))
   (hg-log (hg-root path) rev1 rev2))
 
 (defun hg-outgoing (&optional repo)
   "Display changesets present locally that are not present in REPO."
   (interactive (list (hg-read-repo-name " where changes would go to" nil
 					hg-outgoing-repository)))
   (hg-view-output ((format "Mercurial: Outgoing from %s to %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-outgoing-repository))))
     (call-process (hg-binary) nil t nil "outgoing"
 		  (or repo hg-outgoing-repository))
     (hg-log-mode)))
 
 (defun hg-pull (&optional repo)
   "Pull changes from repository REPO.
 This does not update the working directory."
   (interactive (list (hg-read-repo-name " to pull from")))
   (hg-view-output ((format "Mercurial: Pull to %s from %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-incoming-repository))))
     (call-process (hg-binary) nil t nil "pull"
 		  (or repo hg-incoming-repository))))
 
 (defun hg-push (&optional repo)
   "Push changes to repository REPO."
   (interactive (list (hg-read-repo-name " to push to")))
   (hg-view-output ((format "Mercurial: Push from %s to %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-outgoing-repository))))
     (call-process (hg-binary) nil t nil "push"
 		  (or repo hg-outgoing-repository))))
 
 (defun hg-revert-buffer-internal ()
   (let ((ctx (hg-buffer-context)))
     (message "Reverting %s..." buffer-file-name)
     (hg-run0 "revert" buffer-file-name)
     (revert-buffer t t t)
     (hg-restore-context ctx)
     (hg-mode-line)
     (message "Reverting %s...done" buffer-file-name)))
 
 (defun hg-revert-buffer ()
   "Revert current buffer's file back to the latest committed version.
 If the file has not changed, nothing happens.  Otherwise, this
 displays a diff and asks for confirmation before reverting."
   (interactive)
   (let ((vc-suppress-confirm nil)
 	(obuf (current-buffer))
 	diff)
     (vc-buffer-sync)
     (unwind-protect
 	(setq diff (hg-diff buffer-file-name))
       (when diff
 	(unless (yes-or-no-p "Discard changes? ")
 	  (error "Revert cancelled")))
       (when diff
 	(let ((buf (current-buffer)))
 	  (delete-window (selected-window))
 	  (kill-buffer buf))))
     (set-buffer obuf)
     (when diff
       (hg-revert-buffer-internal))))
 
 (defun hg-root (&optional path)
   "Return the root of the repository that contains the given path.
 If the path is outside a repository, return nil.
 When called interactively, the root is printed.  A prefix argument
 prompts for a path to check."
   (interactive (list (hg-read-file-name)))
   (if (or path (not hg-root))
       (let ((root (do ((prev nil dir)
 		       (dir (file-name-directory (or path buffer-file-name ""))
 			    (file-name-directory (directory-file-name dir))))
 		      ((equal prev dir))
 		    (when (file-directory-p (concat dir ".hg"))
 		      (return dir)))))
 	(when (interactive-p)
 	  (if root
 	      (message "The root of this repository is `%s'." root)
 	    (message "The path `%s' is not in a Mercurial repository."
 		     (hg-abbrev-file-name path))))
 	root)
     hg-root))
 
 (defun hg-status (path)
   "Print revision control status of a file or directory.
 With prefix argument, prompt for the path to give status for.
 Names are displayed relative to the repository root."
   (interactive (list (hg-read-file-name " for status" (hg-root))))
   (let ((root (hg-root)))
     (hg-view-output ((format "Mercurial: Status of %s in %s"
 			     (let ((name (substring (expand-file-name path)
 						    (length root))))
 			       (if (> (length name) 0)
 				   name
 				 "*"))
 			     (hg-abbrev-file-name root)))
       (apply 'call-process (hg-binary) nil t nil
 	     (list "--cwd" root "status" path)))))
 
 (defun hg-undo ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-update ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-version-other-window ()
   (interactive)
   (error "not implemented"))
 
 
 (provide 'mercurial)
 
 
 ;;; Local Variables:
 ;;; prompt-to-byte-compile: nil
 ;;; end:

contrib/tcsh_completion

@@ -1,42 +1,42 b''
 #
 # tcsh completion for Mercurial
 #
 # This file has been auto-generated by tcsh_completion_build.sh for
-# Mercurial Distributed SCM (version 325c07fd2ebd) 
+# Mercurial Distributed SCM (version 325c07fd2ebd)
 #
 # Copyright (C) 2005 TK Soh.
 #
 # This is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free
 # Software Foundation; either version 2 of the License, or (at your
-# option) any later version. 
+# option) any later version.
 #
 
 complete hg \
   'n/--cwd/d/' 'n/-R/d/' 'n/--repository/d/' \
   'C/-/( -R --repository \
     --cwd \
     -y --noninteractive \
     -q --quiet \
     -v --verbose \
     --debug \
     --debugger \
     --traceback \
     --time \
     --profile \
     --version \
     -h --help)/' \
   'p/1/(add addremove annotate bundle cat \
     clone commit ci copy cp \
     debugancestor debugcheckstate debugconfig debugdata debugindex \
     debugindexdot debugrename debugstate debugwalk diff \
     export forget grep heads help \
     identify id import patch incoming \
     in init locate log history \
     manifest outgoing out parents paths \
     pull push rawcommit recover remove \
     rm rename mv revert root \
     serve status tag tags tip \
     unbundle undo update up checkout \
     co verify version)/'
 

contrib/tcsh_completion_build.sh

@@ -1,73 +1,73 b''
 #!/bin/sh
 
 #
 # tcsh_completion_build.sh - script to generate tcsh completion
 #
 #
 # Copyright (C) 2005 TK Soh.
 #
 # This is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free
 # Software Foundation; either version 2 of the License, or (at your
-# option) any later version. 
+# option) any later version.
 #
 #
 # Description
 # -----------
 # This script generates a tcsh source file to support completion
 # of Mercurial commands and options.
 #
 # Instruction:
 # -----------
 # Run this script to generate the tcsh source file, and source
 # the file to add command completion support for Mercurial.
 #
 #    tcsh% tcsh_completion.sh FILE
 #    tcsh% source FILE
 #
 # If FILE is not specified, tcsh_completion will be generated.
 #
 # Bugs:
 # ----
 # 1. command specific options are not supported
 # 2. hg commands must be specified immediately after 'hg'.
 #
 
 tcsh_file=${1-tcsh_completion}
 
 hg_commands=`hg --debug help | \
         sed -e '1,/^list of commands:/d' \
             -e '/^global options:/,$d' \
             -e '/^ [^ ]/!d; s/[,:]//g;' | \
         xargs -n5 | \
         sed -e '$!s/$/ \\\\/g; 2,$s/^ */    /g'`
 
 hg_global_options=`hg -v help | \
         sed -e '1,/global/d;/^ *-/!d; s/ [^- ].*//' | \
         sed -e 's/ *$//; $!s/$/ \\\\/g; 2,$s/^ */    /g'`
 
 hg_version=`hg version | sed -e '1q'`
 
 script_name=`basename $0`
 
 cat > $tcsh_file <<END
 #
 # tcsh completion for Mercurial
 #
 # This file has been auto-generated by $script_name for
-# $hg_version 
+# $hg_version
 #
 # Copyright (C) 2005 TK Soh.
 #
 # This is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free
 # Software Foundation; either version 2 of the License, or (at your
-# option) any later version. 
+# option) any later version.
 #
 
 complete hg \\
   'n/--cwd/d/' 'n/-R/d/' 'n/--repository/d/' \\
   'C/-/($hg_global_options)/' \\
   'p/1/($hg_commands)/'
 
 END

doc/hg.1.txt

@@ -1,807 +1,807 b''
 HG(1)
 =====
 Matt Mackall <[e-mail]>
 
 NAME
 ----
 hg - Mercurial source code management system
 
 SYNOPSIS
 --------
 'hg' [-v -d -q -y] <command> [command options] [files]
 
 DESCRIPTION
 -----------
 The hg(1) command provides a command line interface to the Mercurial system.
 
 OPTIONS
 -------
 
 -R, --repository::
     repository root directory
 
 --cwd::
     change working directory
 
 -y, --noninteractive::
     do not prompt, assume 'yes' for any required answers
 
 -q, --quiet::
     suppress output
 
 -v, --verbose::
     enable additional output
 
 --debug::
     enable debugging output
 
 --traceback::
     print traceback on exception
 
 --time::
     time how long the command takes
 
 --profile::
     print command execution profile
 
 --version::
     output version information and exit
 
 -h, --help::
     display help and exit
 
 COMMAND ELEMENTS
 ----------------
 
 files ...::
     indicates one or more filename or relative path filenames; see
     "FILE NAME PATTERNS" for information on pattern matching
 
 path::
     indicates a path on the local machine
 
 revision::
     indicates a changeset which can be specified as a changeset revision
     number, a tag, or a unique substring of the changeset hash value
 
 repository path::
     either the pathname of a local repository or the URI of a remote
     repository.  There are two available URI protocols, http:// which is
     fast and the old-http:// protocol which is much slower but does not
     require a special server on the web host.
 
 COMMANDS
 --------
 
 add [options] [files ...]::
     Schedule files to be version controlled and added to the repository.
 
     The files will be added to the repository at the next commit.
 
     If no names are given, add all files in the current directory and
     its subdirectories.
 
 addremove [options] [files ...]::
     Add all new files and remove all missing files from the repository.
 
     New files are ignored if they match any of the patterns in .hgignore. As
     with add, these changes take effect at the next commit.
 
 annotate [-r <rev> -u -n -c] [files ...]::
     List changes in files, showing the revision id responsible for each line
 
     This command is useful to discover who did a change or when a change took
     place.
 
     Without the -a option, annotate will avoid processing files it
     detects as binary. With -a, annotate will generate an annotation
     anyway, probably with undesirable results.
 
     options:
     -a, --text            treat all files as text
     -I, --include <pat>   include names matching the given patterns
     -X, --exclude <pat>   exclude names matching the given patterns
     -r, --revision <rev>  annotate the specified revision
     -u, --user            list the author
     -c, --changeset       list the changeset
     -n, --number          list the revision number (default)
 
 bundle <file> <other>::
     (EXPERIMENTAL)
 
     Generate a compressed changegroup file collecting all changesets
     not found in the other repository.
 
     This file can then be transferred using conventional means and
     applied to another repository with the unbundle command. This is
     useful when native push and pull are not available or when
     exporting an entire repository is undesirable. The standard file
     extension is ".hg".
 
     Unlike import/export, this exactly preserves all changeset
     contents including permissions, rename data, and revision history.
 
 cat [options] <file ...>::
     Print the specified files as they were at the given revision.
     If no revision is given then the tip is used.
 
     Output may be to a file, in which case the name of the file is
     given using a format string.  The formatting rules are the same as
     for the export command, with the following additions:
 
     %s   basename of file being printed
     %d   dirname of file being printed, or '.' if in repo root
     %p   root-relative path name of file being printed
 
     options:
     -I, --include <pat>       include names matching the given patterns
     -X, --exclude <pat>       exclude names matching the given patterns
     -o, --output <filespec>   print output to file with formatted name
     -r, --rev <rev>           print the given revision
 
 clone [options] <source> [dest]::
     Create a copy of an existing repository in a new directory.
 
     If no destination directory name is specified, it defaults to the
     basename of the source.
 
     The location of the source is added to the new repository's
     .hg/hgrc file, as the default to be used for future pulls.
 
     For efficiency, hardlinks are used for cloning whenever the source
     and destination are on the same filesystem.  Some filesystems,
     such as AFS, implement hardlinking incorrectly, but do not report
     errors.  In these cases, use the --pull option to avoid
     hardlinking.
 
     options:
     -U, --noupdate   do not update the new working directory
     --pull           use pull protocol to copy metadata
     -e, --ssh        specify ssh command to use
     --remotecmd      specify hg command to run on the remote side
 
 commit [options] [files...]::
     Commit changes to the given files into the repository.
 
     If a list of files is omitted, all changes reported by "hg status"
     from the root of the repository will be commited.
 
     The HGEDITOR or EDITOR environment variables are used to start an
     editor to add a commit comment.
 
     Options:
 
     -A, --addremove       run addremove during commit
     -I, --include <pat>   include names matching the given patterns
     -X, --exclude <pat>   exclude names matching the given patterns
     -m, --message <text>  use <text> as commit message
     -l, --logfile <file>  read the commit message from <file>
     -d, --date <datecode> record datecode as commit date
     -u, --user <user>     record user as commiter
 
     aliases: ci
 
 copy <source ...> <dest>::
     Mark dest as having copies of source files.  If dest is a
     directory, copies are put in that directory.  If dest is a file,
     there can only be one source.
 
     By default, this command copies the contents of files as they
     stand in the working directory.  If invoked with --after, the
     operation is recorded, but no copying is performed.
 
     This command takes effect in the next commit.
 
     NOTE: This command should be treated as experimental. While it
     should properly record copied files, this information is not yet
     fully used by merge, nor fully reported by log.
 
     Options:
     -A, --after           record a copy that has already occurred
     -I, --include <pat>   include names matching the given patterns
     -X, --exclude <pat>   exclude names matching the given patterns
     -f, --force           forcibly copy over an existing managed file
     -p, --parents         append source path to dest
-    
+
     aliases: cp
 
 diff [-a] [-r revision] [-r revision] [files ...]::
     Show differences between revisions for the specified files.
 
     Differences between files are shown using the unified diff format.
 
     When two revision arguments are given, then changes are shown
     between those revisions. If only one revision is specified then
     that revision is compared to the working directory, and, when no
     revisions are specified, the working directory files are compared
     to its parent.
 
     Without the -a option, diff will avoid generating diffs of files
     it detects as binary. With -a, diff will generate a diff anyway,
     probably with undesirable results.
 
     options:
     -a, --text           treat all files as text
     -I, --include <pat>  include names matching the given patterns
     -X, --exclude <pat>  exclude names matching the given patterns
 
 export [-o filespec] [revision] ...::
     Print the changeset header and diffs for one or more revisions.
 
     The information shown in the changeset header is: author,
     changeset hash, parent and commit comment.
 
     Output may be to a file, in which case the name of the file is
     given using a format string.  The formatting rules are as follows:
 
     %%   literal "%" character
     %H   changeset hash (40 bytes of hexadecimal)
     %N   number of patches being generated
     %R   changeset revision number
     %b   basename of the exporting repository
     %h   short-form changeset hash (12 bytes of hexadecimal)
     %n   zero-padded sequence number, starting at 1
     %r   zero-padded changeset revision number
 
     Without the -a option, export will avoid generating diffs of files
     it detects as binary. With -a, export will generate a diff anyway,
     probably with undesirable results.
 
     options:
     -a, --text                treat all files as text
     -o, --output <filespec>   print output to file with formatted name
 
 forget [options] [files]::
     Undo an 'hg add' scheduled for the next commit.
 
     options:
     -I, --include <pat>  include names matching the given patterns
     -X, --exclude <pat>  exclude names matching the given patterns
 
 grep [options] pattern [files]::
     Search revisions of files for a regular expression.
 
     This command behaves differently than Unix grep.  It only accepts
     Python/Perl regexps.  It searches repository history, not the
     working directory.  It always prints the revision number in which
     a match appears.
 
     By default, grep only prints output for the first revision of a
     file in which it finds a match.  To get it to print every revision
     that contains a change in match status ("-" for a match that
     becomes a non-match, or "+" for a non-match that becomes a match),
     use the --all flag.
 
     options:
     -0, --print0              end fields with NUL
     -I, --include <pat>       include names matching the given patterns
     -X, --exclude <pat>       exclude names matching the given patterns
         --all                 print all revisions that match
     -i, --ignore-case         ignore case when matching
     -l, --files-with-matches  print only filenames and revs that match
     -n, --line-number         print matching line numbers
     -r <rev>, --rev <rev>     search in given revision range
     -u, --user                print user who committed change
 
 heads::
     Show all repository head changesets.
 
     Repository "heads" are changesets that don't have children
     changesets. They are where development generally takes place and
     are the usual targets for update and merge operations.
 
 identify::
     Print a short summary of the current state of the repo.
 
     This summary identifies the repository state using one or two parent
     hash identifiers, followed by a "+" if there are uncommitted changes
     in the working directory, followed by a list of tags for this revision.
 
     aliases: id
 
 import [-p <n> -b <base> -f] <patches>::
     Import a list of patches and commit them individually.
 
     If there are outstanding changes in the working directory, import
     will abort unless given the -f flag.
 
     If a patch looks like a mail message (its first line starts with
     "From " or looks like an RFC822 header), it will not be applied
     unless the -f option is used.  The importer neither parses nor
     discards mail headers, so use -f only to override the "mailness"
     safety check, not to import a real mail message.
 
     options:
     -p, --strip <n>   directory strip option for patch. This has the same
                       meaning as the corresponding patch option
     -b <path>         base directory to read patches from
     -f, --force       skip check for outstanding uncommitted changes
 
     aliases: patch
 
 incoming [-p] [source]::
     Show new changesets found in the specified repo or the default
     pull repo. These are the changesets that would be pulled if a pull
     was requested.
 
     Currently only local repositories are supported.
 
     options:
     -p, --patch           show patch
 
     aliases: in
 
 init [dest]::
     Initialize a new repository in the given directory.  If the given
     directory does not exist, it is created.
 
     If no directory is given, the current directory is used.
 
 locate [options] [files]::
     Print all files under Mercurial control whose names match the
     given patterns.
 
     This command searches the current directory and its
     subdirectories.  To search an entire repository, move to the root
     of the repository.
 
     If no patterns are given to match, this command prints all file
     names.
 
     If you want to feed the output of this command into the "xargs"
     command, use the "-0" option to both this command and "xargs".
     This will avoid the problem of "xargs" treating single filenames
     that contain white space as multiple filenames.
 
     options:
 
     -0, --print0         end filenames with NUL, for use with xargs
     -f, --fullpath       print complete paths from the filesystem root
     -I, --include <pat>  include names matching the given patterns
     -r, --rev <rev>      search the repository as it stood at rev
     -X, --exclude <pat>  exclude names matching the given patterns
 
 log [-r revision ...] [-p] [files]::
     Print the revision history of the specified files or the entire project.
 
     By default this command outputs: changeset id and hash, tags,
     parents, user, date and time, and a summary for each commit. The
     -v switch adds some more detail, such as changed files, manifest
     hashes or message signatures.
 
     options:
     -I, --include <pat>   include names matching the given patterns
     -X, --exclude <pat>   exclude names matching the given patterns
     -r, --rev <A>         show the specified revision or range
     -p, --patch           show patch
 
     aliases: history
 
 manifest [revision]::
     Print a list of version controlled files for the given revision.
 
     The manifest is the list of files being version controlled. If no revision
     is given then the tip is used.
 
 outgoing [-p] [dest]::
     Show changesets not found in the specified destination repo or the
     default push repo. These are the changesets that would be pushed
     if a push was requested.
 
     options:
     -p, --patch           show patch
 
     aliases: out
 
 parents::
     Print the working directory's parent revisions.
 
 paths [NAME]::
     Show definition of symbolic path name NAME. If no name is given, show
     definition of available names.
 
     Path names are defined in the [paths] section of /etc/mercurial/hgrc
     and $HOME/.hgrc.  If run inside a repository, .hg/hgrc is used, too.
 
 pull <repository path>::
     Pull changes from a remote repository to a local one.
 
     This finds all changes from the repository at the specified path
     or URL and adds them to the local repository. By default, this
     does not update the copy of the project in the working directory.
 
     Valid URLs are of the form:
 
       local/filesystem/path
       http://[user@]host[:port][/path]
       https://[user@]host[:port][/path]
       ssh://[user@]host[:port][/path]
 
     SSH requires an accessible shell account on the destination machine
     and a copy of hg in the remote path.  With SSH, paths are relative
     to the remote user's home directory by default; use two slashes at
     the start of a path to specify it as relative to the filesystem root.
 
     options:
     -u, --update   update the working directory to tip after pull
     -e, --ssh    specify ssh command to use
     --remotecmd  specify hg command to run on the remote side
 
 push <destination>::
     Push changes from the local repository to the given destination.
 
     This is the symmetrical operation for pull. It helps to move
     changes from the current repository to a different one. If the
     destination is local this is identical to a pull in that directory
     from the current one.
 
     By default, push will refuse to run if it detects the result would
     increase the number of remote heads. This generally indicates the
     the client has forgotten to sync and merge before pushing.
 
     Valid URLs are of the form:
 
       local/filesystem/path
       ssh://[user@]host[:port][/path]
 
     SSH requires an accessible shell account on the destination
     machine and a copy of hg in the remote path.
 
     options:
 
     -f, --force  force update
     -e, --ssh    specify ssh command to use
     --remotecmd  specify hg command to run on the remote side
 
 rawcommit [-p -d -u -F -m -l]::
     Lowlevel commit, for use in helper scripts.
 
     This command is not intended to be used by normal users, as it is
     primarily useful for importing from other SCMs.
 
 recover::
     Recover from an interrupted commit or pull.
 
     This command tries to fix the repository status after an interrupted
     operation. It should only be necessary when Mercurial suggests it.
 
 remove [options] [files ...]::
     Schedule the indicated files for removal from the repository.
 
     This command schedules the files to be removed at the next commit.
     This only removes files from the current branch, not from the
     entire project history.  If the files still exist in the working
     directory, they will be deleted from it.
 
     aliases: rm
 
 rename <source ...> <dest>::
     Mark dest as copies of sources; mark sources for deletion.  If
     dest is a directory, copies are put in that directory.  If dest is
     a file, there can only be one source.
 
     By default, this command copies the contents of files as they
     stand in the working directory.  If invoked with --after, the
     operation is recorded, but no copying is performed.
 
     This command takes effect in the next commit.
 
     NOTE: This command should be treated as experimental. While it
     should properly record rename files, this information is not yet
     fully used by merge, nor fully reported by log.
 
     Options:
     -A, --after        record a rename that has already occurred
     -f, --force        forcibly copy over an existing managed file
     -p, --parents      append source path to dest
 
     aliases: mv
 
 revert [names ...]::
     Revert any uncommitted modifications made to the named files or
     directories.  This restores the contents of the affected files to
     an unmodified state.
 
     If a file has been deleted, it is recreated.  If the executable
     mode of a file was changed, it is reset.
 
     If a directory is given, all files in that directory and its
     subdirectories are reverted.
 
     If no arguments are given, all files in the current directory and
     its subdirectories are reverted.
 
     options:
     -r, --rev <rev>       revision to revert to
     -n, --nonrecursive    do not recurse into subdirectories
 
 root::
     Print the root directory of the current repository.
 
 serve [options]::
     Start a local HTTP repository browser and pull server.
 
     By default, the server logs accesses to stdout and errors to
     stderr.  Use the "-A" and "-E" options to log to files.
 
     options:
     -A, --accesslog <file>   name of access log file to write to
     -E, --errorlog <file>    name of error log file to write to
     -a, --address <addr>     address to use
     -p, --port <n>           port to use (default: 8000)
     -n, --name <name>        name to show in web pages (default: working dir)
     -t, --templatedir <path> web templates to use
     -6, --ipv6               use IPv6 in addition to IPv4
 
 status [options] [files]::
     Show changed files in the working directory.  If no names are
     given, all files are shown.  Otherwise, only files matching the
     given names are shown.
 
     The codes used to show the status of files are:
 
     M = changed
     A = added
     R = removed
     ? = not tracked
 
     options:
 
     -m, --modified       show only modified files
     -a, --added          show only added files
     -r, --removed        show only removed files
     -u, --unknown        show only unknown (not tracked) files
     -n, --no-status      hide status prefix
     -0, --print0         end filenames with NUL, for use with xargs
     -I, --include <pat>  include names matching the given patterns
     -X, --exclude <pat>  exclude names matching the given patterns
 
 tag [-l -m <text> -d <datecode> -u <user>] <name> [revision]::
     Name a particular revision using <name>.
 
     Tags are used to name particular revisions of the repository and are
     very useful to compare different revision, to go back to significant
     earlier versions or to mark branch points as releases, etc.
 
     If no revision is given, the tip is used.
 
     To facilitate version control, distribution, and merging of tags,
     they are stored as a file named ".hgtags" which is managed
     similarly to other project files and can be hand-edited if
     necessary.
 
     options:
     -l, --local           make the tag local
     -m, --message <text>  message for tag commit log entry
     -d, --date <datecode> datecode for commit
     -u, --user <user>     user for commit
 
     Note: Local tags are not version-controlled or distributed and are
     stored in the .hg/localtags file. If there exists a local tag and
     a public tag with the same name, local tag is used.
 
 tags::
     List the repository tags.
 
     This lists both regular and local tags.
 
 tip::
     Show the tip revision.
 
 unbundle <file>::
     (EXPERIMENTAL)
 
     Apply a compressed changegroup file generated by the bundle
     command.
 
 undo::
     Undo the last commit or pull transaction.
 
     Roll back the last pull or commit transaction on the
     repository, restoring the project to its earlier state.
 
     This command should be used with care. There is only one level of
     undo and there is no redo.
 
     This command is not intended for use on public repositories. Once
     a change is visible for pull by other users, undoing it locally is
     ineffective.
 
 update [-m -C] [revision]::
     Update the working directory to the specified revision.
 
     By default, update will refuse to run if doing so would require
     merging or discarding local changes.
 
     With the -m option, a merge will be performed.
 
     With the -C option, local changes will be lost.
 
     options:
     -m, --merge       allow merging of branches
     -C, --clean       overwrite locally modified files
 
     aliases: up checkout co
 
 verify::
     Verify the integrity of the current repository.
 
     This will perform an extensive check of the repository's
     integrity, validating the hashes and checksums of each entry in
     the changelog, manifest, and tracked files, as well as the
     integrity of their crosslinks and indices.
 
 FILE NAME PATTERNS
 ------------------
 
     Mercurial accepts several notations for identifying one or more
     files at a time.
 
     By default, Mercurial treats filenames as shell-style extended
     glob patterns.
 
     Alternate pattern notations must be specified explicitly.
 
     To use a plain path name without any pattern matching, start a
     name with "path:".  These path names must match completely, from
     the root of the current repository.
 
     To use an extended glob, start a name with "glob:".  Globs are
     rooted at the current directory; a glob such as "*.c" will match
     files ending in ".c" in the current directory only.
 
     The supported glob syntax extensions are "**" to match any string
     across path separators, and "{a,b}" to mean "a or b".
 
     To use a Perl/Python regular expression, start a name with "re:".
     Regexp pattern matching is anchored at the root of the repository.
 
     Plain examples:
 
     path:foo/bar   a name bar in a directory named foo in the root of
                    the repository
     path:path:name a file or directory named "path:name"
 
     Glob examples:
 
     glob:*.c       any name ending in ".c" in the current directory
     *.c            any name ending in ".c" in the current directory
     **.c           any name ending in ".c" in the current directory, or
                    any subdirectory
     foo/*.c        any name ending in ".c" in the directory foo
     foo/**.c       any name ending in ".c" in the directory foo, or any
                    subdirectory
 
     Regexp examples:
 
     re:.*\.c$      any name ending in ".c", anywhere in the repository
 
 
 SPECIFYING SINGLE REVISIONS
 ---------------------------
 
     Mercurial accepts several notations for identifying individual
     revisions.
 
     A plain integer is treated as a revision number.  Negative
     integers are treated as offsets from the tip, with -1 denoting the
     tip.
 
     A 40-digit hexadecimal string is treated as a unique revision
     identifier.
 
     A hexadecimal string less than 40 characters long is treated as a
     unique revision identifier, and referred to as a short-form
     identifier.  A short-form identifier is only valid if it is the
     prefix of one full-length identifier.
 
     Any other string is treated as a tag name, which is a symbolic
     name associated with a revision identifier.  Tag names may not
     contain the ":" character.
 
     The reserved name "tip" is a special tag that always identifies
     the most recent revision.
 
 SPECIFYING MULTIPLE REVISIONS
 -----------------------------
 
     When Mercurial accepts more than one revision, they may be
     specified individually, or provided as a continuous range,
     separated by the ":" character.
 
     The syntax of range notation is [BEGIN]:[END], where BEGIN and END
     are revision identifiers.  Both BEGIN and END are optional.  If
     BEGIN is not specified, it defaults to revision number 0.  If END
     is not specified, it defaults to the tip.  The range ":" thus
     means "all revisions".
 
     If BEGIN is greater than END, revisions are treated in reverse
     order.
 
     A range acts as a closed interval.  This means that a range of 3:5
     gives 3, 4 and 5.  Similarly, a range of 4:2 gives 4, 3, and 2.
 
 ENVIRONMENT VARIABLES
 ---------------------
 
 HGEDITOR::
     This is the name of the editor to use when committing. Defaults to the
     value of EDITOR.
 
     (deprecated, use .hgrc)
 
 HGMERGE::
     An executable to use for resolving merge conflicts. The program
     will be executed with three arguments: local file, remote file,
     ancestor file.
 
     The default program is "hgmerge", which is a shell script provided
     by Mercurial with some sensible defaults.
 
     (deprecated, use .hgrc)
 
 HGUSER::
     This is the string used for the author of a commit.
 
     (deprecated, use .hgrc)
 
 EMAIL::
     If HGUSER is not set, this will be used as the author for a commit.
 
 LOGNAME::
     If neither HGUSER nor EMAIL is set, LOGNAME will be used (with
     '@hostname' appended) as the author value for a commit.
 
 EDITOR::
     This is the name of the editor used in the hgmerge script. It will be
     used for commit messages if HGEDITOR isn't set. Defaults to 'vi'.
 
 PYTHONPATH::
     This is used by Python to find imported modules and may need to be set
     appropriately if Mercurial is not installed system-wide.
 
 FILES
 -----
  .hgignore::
     This file contains regular expressions (one per line) that describe file
     names that should be ignored by hg.
 
  .hgtags::
     This file contains changeset hash values and text tag names (one of each
     separated by spaces) that correspond to tagged versions of the repository
     contents.
 
  /etc/mercurial/hgrc, $HOME/.hgrc, .hg/hgrc::
     This file contains defaults and configuration. Values in .hg/hgrc
     override those in $HOME/.hgrc, and these override settings made in the
     global /etc/mercurial/hgrc configuration.  See hgrc(5) for details of
     the contents and format of these files.
 
 BUGS
 ----
 Probably lots, please post them to the mailing list (See Resources below)
 when you find them.
 
 SEE ALSO
 --------
 hgrc(5)
 
 AUTHOR
 ------
 Written by Matt Mackall <[e-mail]>
 
 RESOURCES
 ---------
 http://selenic.com/mercurial[Main Web Site]
 
 http://www.serpentine.com/mercurial[Wiki site]
 
 http://selenic.com/hg[Source code repository]
 
 http://selenic.com/mailman/listinfo/mercurial[Mailing list]
 
 COPYING
 -------
 Copyright (C) 2005 Matt Mackall.
 Free use of this software is granted under the terms of the GNU General
 Public License (GPL).

doc/hgrc.5.txt

@@ -1,192 +1,192 b''
 HGRC(5)
 =======
 Bryan O'Sullivan <[e-mail]>
 
 NAME
 ----
 hgrc - configuration files for Mercurial
 
 SYNOPSIS
 --------
 
 The Mercurial system uses a set of configuration files to control
 aspects of its behaviour.
 
 FILES
 -----
 
 Mercurial reads configuration data from three files:
 
 /etc/mercurial/hgrc::
     Options in this global configuration file apply to all Mercurial
     commands executed by any user in any directory.
 
 $HOME/.hgrc::
     Per-user configuration options that apply to all Mercurial commands,
     no matter from which directory they are run.  Values in this file
     override global settings.
 
 <repo>/.hg/hgrc::
     Per-repository configuration options that only apply in a
     particular repository.  This file is not version-controlled, and
     will not get transferred during a "clone" operation.  Values in
     this file override global and per-user settings.
 
 SYNTAX
 ------
 
 A configuration file consists of sections, led by a "[section]" header
 and followed by "name: value" entries; "name=value" is also accepted.
 
     [spam]
     eggs=ham
     green=
        eggs
 
 Each line contains one entry.  If the lines that follow are indented,
 they are treated as continuations of that entry.
 
 Leading whitespace is removed from values.  Empty lines are skipped.
 
 The optional values can contain format strings which refer to other
 values in the same section, or values in a special DEFAULT section.
 
 Lines beginning with "#" or ";" are ignored and may be used to provide
 comments.
 
 SECTIONS
 --------
 
 This section describes the different sections that may appear in a
 Mercurial "hgrc" file, the purpose of each section, its possible
 keys, and their possible values.
 
-decode/encode:: 
+decode/encode::
   Filters for transforming files on checkout/checkin. This would
   typically be used for newline processing or other
   localization/canonicalization of files.
 
   Filters consist of a filter pattern followed by a filter command.
   The command must accept data on stdin and return the transformed
   data on stdout.
 
   Example:
 
     [encode]
     # uncompress gzip files on checkin to improve delta compression
     # note: not necessarily a good idea, just an example
     *.gz = gunzip
 
     [decode]
     # recompress gzip files when writing them to the working dir
     *.gz = gzip
 
 hooks::
   Commands that get automatically executed by various actions such as
   starting or finishing a commit.
   changegroup;;
     Run after a changegroup has been added via push or pull.
   commit;;
     Run after a changeset has been created. Passed the ID of the newly
     created changeset.
   precommit;;
     Run before starting a commit.  Exit status 0 allows the commit to
     proceed.  Non-zero status will cause the commit to fail.
 
 http_proxy::
   Used to access web-based Mercurial repositories through a HTTP
   proxy.
   host;;
     Host name and (optional) port of the proxy server, for example
     "myproxy:8000".
   no;;
     Optional.  Comma-separated list of host names that should bypass
     the proxy.
   passwd;;
     Optional.  Password to authenticate with at the proxy server.
   user;;
     Optional.  User name to authenticate with at the proxy server.
 
 paths::
   Assigns symbolic names to repositories.  The left side is the
   symbolic name, and the right gives the directory or URL that is the
   location of the repository.
 
 ui::
   User interface controls.
   debug;;
     Print debugging information.  True or False.  Default is False.
   editor;;
     The editor to use during a commit.  Default is $EDITOR or "vi".
   interactive;;
     Allow to prompt the user.  True or False.  Default is True.
   merge;;
     The conflict resolution program to use during a manual merge.
     Default is "hgmerge".
   quiet;;
     Reduce the amount of output printed.  True or False.  Default is False.
   remotecmd;;
     remote command to use for clone/push/pull operations. Default is 'hg'.
   ssh;;
     command to use for SSH connections. Default is 'ssh'.
   username;;
     The committer of a changeset created when running "commit".
     Typically a person's name and email address, e.g. "Fred Widget
     <[e-mail]>".  Default is $EMAIL or username@hostname.
   verbose;;
     Increase the amount of output printed.  True or False.  Default is False.
 
 
 web::
   Web interface configuration.
   accesslog;;
     Where to output the access log. Default is stdout.
   address;;
     Interface address to bind to. Default is all.
   allowbz2;;
     Whether to allow .tar.bz2 downloading of repo revisions. Default is false.
   allowgz;;
     Whether to allow .tar.gz downloading of repo revisions. Default is false.
   allowpull;;
     Whether to allow pulling from the repository. Default is true.
   allowzip;;
     Whether to allow .zip downloading of repo revisions. Default is false.
     This feature creates temporary files.
   description;;
     Textual description of the repository's purpose or contents.
     Default is "unknown".
   errorlog;;
     Where to output the error log. Default is stderr.
   ipv6;;
     Whether to use IPv6. Default is false.
   name;;
     Repository name to use in the web interface. Default is current
     working directory.
   maxchanges;;
     Maximum number of changes to list on the changelog. Default is 10.
   maxfiles;;
     Maximum number of files to list per changeset. Default is 10.
   port;;
     Port to listen on. Default is 8000.
   style;;
     Which template map style to use.
   templates;;
     Where to find the HTML templates. Default is install path.
 
 
 AUTHOR
 ------
 Bryan O'Sullivan <[e-mail]>.
 
 Mercurial was written by Matt Mackall <[e-mail]>.
 
 SEE ALSO
 --------
 hg(1)
 
 COPYING
 -------
 This manual page is copyright 2005 Bryan O'Sullivan.
 Mercurial is copyright 2005 Matt Mackall.
 Free use of this software is granted under the terms of the GNU General
 Public License (GPL).

mercurial/hgweb.py

@@ -1,987 +1,987 b''
 # hgweb.py - web interface to a mercurial repository
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import os, cgi, sys
 from demandload import demandload
 demandload(globals(), "mdiff time re socket zlib errno ui hg ConfigParser")
 demandload(globals(), "zipfile tempfile StringIO tarfile BaseHTTPServer")
 from node import *
 
 def templatepath():
     for f in "templates", "../templates":
         p = os.path.join(os.path.dirname(__file__), f)
         if os.path.isdir(p):
             return p
 
 def age(t):
     def plural(t, c):
         if c == 1:
             return t
         return t + "s"
     def fmt(t, c):
         return "%d %s" % (c, plural(t, c))
 
     now = time.time()
     delta = max(1, int(now - t))
 
     scales = [["second", 1],
               ["minute", 60],
               ["hour", 3600],
               ["day", 3600 * 24],
               ["week", 3600 * 24 * 7],
               ["month", 3600 * 24 * 30],
               ["year", 3600 * 24 * 365]]
 
     scales.reverse()
 
     for t, s in scales:
         n = delta / s
         if n >= 2 or s == 1:
             return fmt(t, n)
 
 def nl2br(text):
     return text.replace('\n', '<br/>\n')
 
 def obfuscate(text):
     return ''.join(['&#%d;' % ord(c) for c in text])
 
 def up(p):
     if p[0] != "/":
         p = "/" + p
     if p[-1] == "/":
         p = p[:-1]
     up = os.path.dirname(p)
     if up == "/":
         return "/"
     return up + "/"
 
 class hgrequest:
     def __init__(self, inp=None, out=None, env=None):
         self.inp = inp or sys.stdin
         self.out = out or sys.stdout
         self.env = env or os.environ
         self.form = cgi.parse(self.inp, self.env)
 
     def write(self, *things):
         for thing in things:
             if hasattr(thing, "__iter__"):
                 for part in thing:
                     self.write(part)
             else:
                 try:
                     self.out.write(str(thing))
                 except socket.error, inst:
                     if inst[0] != errno.ECONNRESET:
                         raise
 
     def header(self, headers=[('Content-type','text/html')]):
         for header in headers:
             self.out.write("%s: %s\r\n" % header)
         self.out.write("\r\n")
 
     def httphdr(self, type, file="", size=0):
 
         headers = [('Content-type', type)]
         if file:
             headers.append(('Content-disposition', 'attachment; filename=%s' % file))
         if size > 0:
             headers.append(('Content-length', str(size)))
         self.header(headers)
 
 class templater:
     def __init__(self, mapfile, filters={}, defaults={}):
         self.cache = {}
         self.map = {}
         self.base = os.path.dirname(mapfile)
         self.filters = filters
         self.defaults = defaults
 
         for l in file(mapfile):
             m = re.match(r'(\S+)\s*=\s*"(.*)"$', l)
             if m:
                 self.cache[m.group(1)] = m.group(2)
             else:
                 m = re.match(r'(\S+)\s*=\s*(\S+)', l)
                 if m:
                     self.map[m.group(1)] = os.path.join(self.base, m.group(2))
                 else:
                     raise LookupError("unknown map entry '%s'" % l)
 
     def __call__(self, t, **map):
         m = self.defaults.copy()
         m.update(map)
         try:
             tmpl = self.cache[t]
         except KeyError:
             tmpl = self.cache[t] = file(self.map[t]).read()
         return self.template(tmpl, self.filters, **m)
 
     def template(self, tmpl, filters={}, **map):
         while tmpl:
             m = re.search(r"#([a-zA-Z0-9]+)((%[a-zA-Z0-9]+)*)((\|[a-zA-Z0-9]+)*)#", tmpl)
             if m:
                 yield tmpl[:m.start(0)]
                 v = map.get(m.group(1), "")
                 v = callable(v) and v(**map) or v
 
                 format = m.group(2)
                 fl = m.group(4)
 
                 if format:
                     q = v.__iter__
                     for i in q():
                         lm = map.copy()
                         lm.update(i)
                         yield self(format[1:], **lm)
 
                     v = ""
 
                 elif fl:
                     for f in fl.split("|")[1:]:
                         v = filters[f](v)
 
                 yield v
                 tmpl = tmpl[m.end(0):]
             else:
                 yield tmpl
                 return
 
 def rfc822date(x):
     return time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(x))
 
 common_filters = {
     "escape": cgi.escape,
     "age": age,
     "date": (lambda x: time.asctime(time.gmtime(x))),
     "addbreaks": nl2br,
     "obfuscate": obfuscate,
     "short": (lambda x: x[:12]),
     "firstline": (lambda x: x.splitlines(1)[0]),
     "permissions": (lambda x: x and "-rwxr-xr-x" or "-rw-r--r--"),
     "rfc822date": rfc822date,
     }
 
 
 
 class hgweb:
     def __init__(self, repo, name=None):
         if type(repo) == type(""):
             self.repo = hg.repository(ui.ui(), repo)
         else:
             self.repo = repo
 
         self.mtime = -1
         self.reponame = name
         self.archives = 'zip', 'gz', 'bz2'
 
     def refresh(self):
         s = os.stat(os.path.join(self.repo.root, ".hg", "00changelog.i"))
         if s.st_mtime != self.mtime:
             self.mtime = s.st_mtime
             self.repo = hg.repository(self.repo.ui, self.repo.root)
             self.maxchanges = int(self.repo.ui.config("web", "maxchanges", 10))
             self.maxfiles = int(self.repo.ui.config("web", "maxfiles", 10))
             self.allowpull = self.repo.ui.configbool("web", "allowpull", True)
 
     def date(self, cs):
         return time.asctime(time.gmtime(float(cs[2].split(' ')[0])))
 
     def listfiles(self, files, mf):
         for f in files[:self.maxfiles]:
             yield self.t("filenodelink", node=hex(mf[f]), file=f)
         if len(files) > self.maxfiles:
             yield self.t("fileellipses")
 
     def listfilediffs(self, files, changeset):
         for f in files[:self.maxfiles]:
             yield self.t("filedifflink", node=hex(changeset), file=f)
         if len(files) > self.maxfiles:
             yield self.t("fileellipses")
 
     def parents(self, t1, nodes=[], rev=None,**args):
         if not rev:
             rev = lambda x: ""
         for node in nodes:
             if node != nullid:
                 yield self.t(t1, node=hex(node), rev=rev(node), **args)
 
     def showtag(self, t1, node=nullid, **args):
         for t in self.repo.nodetags(node):
              yield self.t(t1, tag=t, **args)
 
     def diff(self, node1, node2, files):
         def filterfiles(list, files):
             l = [x for x in list if x in files]
 
             for f in files:
                 if f[-1] != os.sep:
                     f += os.sep
                 l += [x for x in list if x.startswith(f)]
             return l
 
         parity = [0]
         def diffblock(diff, f, fn):
             yield self.t("diffblock",
                          lines=prettyprintlines(diff),
                          parity=parity[0],
                          file=f,
                          filenode=hex(fn or nullid))
             parity[0] = 1 - parity[0]
 
         def prettyprintlines(diff):
             for l in diff.splitlines(1):
                 if l.startswith('+'):
                     yield self.t("difflineplus", line=l)
                 elif l.startswith('-'):
                     yield self.t("difflineminus", line=l)
                 elif l.startswith('@'):
                     yield self.t("difflineat", line=l)
                 else:
                     yield self.t("diffline", line=l)
 
         r = self.repo
         cl = r.changelog
         mf = r.manifest
         change1 = cl.read(node1)
         change2 = cl.read(node2)
         mmap1 = mf.read(change1[0])
         mmap2 = mf.read(change2[0])
         date1 = self.date(change1)
         date2 = self.date(change2)
 
         c, a, d, u = r.changes(node1, node2)
         if files:
             c, a, d = map(lambda x: filterfiles(x, files), (c, a, d))
 
         for f in c:
             to = r.file(f).read(mmap1[f])
             tn = r.file(f).read(mmap2[f])
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f), f, tn)
         for f in a:
             to = None
             tn = r.file(f).read(mmap2[f])
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f), f, tn)
         for f in d:
             to = r.file(f).read(mmap1[f])
             tn = None
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f), f, tn)
 
     def changelog(self, pos):
         def changenav(**map):
             def seq(factor=1):
                 yield 1 * factor
                 yield 3 * factor
                 #yield 5 * factor
                 for f in seq(factor * 10):
                     yield f
 
             l = []
             for f in seq():
                 if f < self.maxchanges / 2:
                     continue
                 if f > count:
                     break
                 r = "%d" % f
                 if pos + f < count:
                     l.append(("+" + r, pos + f))
                 if pos - f >= 0:
                     l.insert(0, ("-" + r, pos - f))
 
             yield {"rev": 0, "label": "(0)"}
 
             for label, rev in l:
                 yield {"label": label, "rev": rev}
 
             yield {"label": "tip", "rev": ""}
 
         def changelist(**map):
             parity = (start - end) & 1
             cl = self.repo.changelog
             l = [] # build a list in forward order for efficiency
             for i in range(start, end):
                 n = cl.node(i)
                 changes = cl.read(n)
                 hn = hex(n)
                 t = float(changes[2].split(' ')[0])
 
                 l.insert(0, {"parity": parity,
                              "author": changes[1],
                              "parent": self.parents("changelogparent",
                                                     cl.parents(n), cl.rev),
                              "changelogtag": self.showtag("changelogtag",n),
                              "manifest": hex(changes[0]),
                              "desc": changes[4],
                              "date": t,
                              "files": self.listfilediffs(changes[3], n),
                              "rev": i,
                              "node": hn})
                 parity = 1 - parity
 
             for e in l:
                 yield e
 
         cl = self.repo.changelog
         mf = cl.read(cl.tip())[0]
         count = cl.count()
         start = max(0, pos - self.maxchanges + 1)
         end = min(count, start + self.maxchanges)
         pos = end - 1
 
         yield self.t('changelog',
                      changenav=changenav,
                      manifest=hex(mf),
                      rev=pos, changesets=count, entries=changelist)
 
     def search(self, query):
 
         def changelist(**map):
             cl = self.repo.changelog
             count = 0
             qw = query.lower().split()
 
             def revgen():
                 for i in range(cl.count() - 1, 0, -100):
                     l = []
                     for j in range(max(0, i - 100), i):
                         n = cl.node(j)
                         changes = cl.read(n)
                         l.append((n, j, changes))
                     l.reverse()
                     for e in l:
                         yield e
 
             for n, i, changes in revgen():
                 miss = 0
                 for q in qw:
                     if not (q in changes[1].lower() or
                             q in changes[4].lower() or
                             q in " ".join(changes[3][:20]).lower()):
                         miss = 1
                         break
                 if miss:
                     continue
 
                 count += 1
                 hn = hex(n)
                 t = float(changes[2].split(' ')[0])
 
                 yield self.t('searchentry',
                              parity=count & 1,
                              author=changes[1],
                              parent=self.parents("changelogparent",
                                                  cl.parents(n), cl.rev),
                              changelogtag=self.showtag("changelogtag",n),
                              manifest=hex(changes[0]),
                              desc=changes[4],
                              date=t,
                              files=self.listfilediffs(changes[3], n),
                              rev=i,
                              node=hn)
 
                 if count >= self.maxchanges:
                     break
 
         cl = self.repo.changelog
         mf = cl.read(cl.tip())[0]
 
         yield self.t('search',
                      query=query,
                      manifest=hex(mf),
                      entries=changelist)
 
     def changeset(self, nodeid):
         n = bin(nodeid)
         cl = self.repo.changelog
         changes = cl.read(n)
         p1 = cl.parents(n)[0]
         t = float(changes[2].split(' ')[0])
 
         files = []
         mf = self.repo.manifest.read(changes[0])
         for f in changes[3]:
             files.append(self.t("filenodelink",
                                 filenode=hex(mf.get(f, nullid)), file=f))
 
         def diff(**map):
             yield self.diff(p1, n, None)
 
         def archivelist():
             for i in self.archives:
                 if self.repo.ui.configbool("web", "allow" + i, False):
                     yield {"type" : i, "node" : nodeid}
 
         yield self.t('changeset',
                      diff=diff,
                      rev=cl.rev(n),
                      node=nodeid,
                      parent=self.parents("changesetparent",
                                          cl.parents(n), cl.rev),
                      changesettag=self.showtag("changesettag",n),
                      manifest=hex(changes[0]),
                      author=changes[1],
                      desc=changes[4],
                      date=t,
                      files=files,
                      archives=archivelist())
 
     def filelog(self, f, filenode):
         cl = self.repo.changelog
         fl = self.repo.file(f)
         count = fl.count()
 
         def entries(**map):
             l = []
             parity = (count - 1) & 1
 
             for i in range(count):
                 n = fl.node(i)
                 lr = fl.linkrev(n)
                 cn = cl.node(lr)
                 cs = cl.read(cl.node(lr))
                 t = float(cs[2].split(' ')[0])
 
                 l.insert(0, {"parity": parity,
                              "filenode": hex(n),
                              "filerev": i,
                              "file": f,
                              "node": hex(cn),
                              "author": cs[1],
                              "date": t,
                              "parent": self.parents("filelogparent",
                                                     fl.parents(n),
                                                     fl.rev, file=f),
                              "desc": cs[4]})
                 parity = 1 - parity
 
             for e in l:
                 yield e
 
         yield self.t("filelog", file=f, filenode=filenode, entries=entries)
 
     def filerevision(self, f, node):
         fl = self.repo.file(f)
         n = bin(node)
         text = fl.read(n)
         changerev = fl.linkrev(n)
         cl = self.repo.changelog
         cn = cl.node(changerev)
         cs = cl.read(cn)
         t = float(cs[2].split(' ')[0])
         mfn = cs[0]
 
         def lines():
             for l, t in enumerate(text.splitlines(1)):
                 yield {"line": t,
                        "linenumber": "% 6d" % (l + 1),
                        "parity": l & 1}
 
         yield self.t("filerevision",
                      file=f,
                      filenode=node,
                      path=up(f),
                      text=lines(),
                      rev=changerev,
                      node=hex(cn),
                      manifest=hex(mfn),
                      author=cs[1],
                      date=t,
                      parent=self.parents("filerevparent",
                                          fl.parents(n), fl.rev, file=f),
                      permissions=self.repo.manifest.readflags(mfn)[f])
 
     def fileannotate(self, f, node):
         bcache = {}
         ncache = {}
         fl = self.repo.file(f)
         n = bin(node)
         changerev = fl.linkrev(n)
 
         cl = self.repo.changelog
         cn = cl.node(changerev)
         cs = cl.read(cn)
         t = float(cs[2].split(' ')[0])
         mfn = cs[0]
 
         def annotate(**map):
             parity = 1
             last = None
             for r, l in fl.annotate(n):
                 try:
                     cnode = ncache[r]
                 except KeyError:
                     cnode = ncache[r] = self.repo.changelog.node(r)
 
                 try:
                     name = bcache[r]
                 except KeyError:
                     cl = self.repo.changelog.read(cnode)
                     bcache[r] = name = self.repo.ui.shortuser(cl[1])
 
                 if last != cnode:
                     parity = 1 - parity
                     last = cnode
 
                 yield {"parity": parity,
                        "node": hex(cnode),
                        "rev": r,
                        "author": name,
                        "file": f,
                        "line": l}
 
         yield self.t("fileannotate",
                      file=f,
                      filenode=node,
                      annotate=annotate,
                      path=up(f),
                      rev=changerev,
                      node=hex(cn),
                      manifest=hex(mfn),
                      author=cs[1],
                      date=t,
                      parent=self.parents("fileannotateparent",
                                          fl.parents(n), fl.rev, file=f),
                      permissions=self.repo.manifest.readflags(mfn)[f])
 
     def manifest(self, mnode, path):
         mf = self.repo.manifest.read(bin(mnode))
         rev = self.repo.manifest.rev(bin(mnode))
         node = self.repo.changelog.node(rev)
         mff=self.repo.manifest.readflags(bin(mnode))
 
         files = {}
 
         p = path[1:]
         l = len(p)
 
         for f,n in mf.items():
             if f[:l] != p:
                 continue
             remain = f[l:]
             if "/" in remain:
                 short = remain[:remain.find("/") + 1] # bleah
                 files[short] = (f, None)
             else:
                 short = os.path.basename(remain)
                 files[short] = (f, n)
 
         def filelist(**map):
             parity = 0
             fl = files.keys()
             fl.sort()
             for f in fl:
                 full, fnode = files[f]
                 if not fnode:
                     continue
 
                 yield {"file": full,
                        "manifest": mnode,
                        "filenode": hex(fnode),
                        "parity": parity,
                        "basename": f,
                        "permissions": mff[full]}
                 parity = 1 - parity
 
         def dirlist(**map):
             parity = 0
             fl = files.keys()
             fl.sort()
             for f in fl:
                 full, fnode = files[f]
                 if fnode:
                     continue
 
                 yield {"parity": parity,
                        "path": os.path.join(path, f),
                        "manifest": mnode,
                        "basename": f[:-1]}
                 parity = 1 - parity
 
         yield self.t("manifest",
                      manifest=mnode,
                      rev=rev,
                      node=hex(node),
                      path=path,
                      up=up(path),
                      fentries=filelist,
                      dentries=dirlist)
 
     def tags(self):
         cl = self.repo.changelog
         mf = cl.read(cl.tip())[0]
 
         i = self.repo.tagslist()
         i.reverse()
 
         def entries(**map):
             parity = 0
             for k,n in i:
                 yield {"parity": parity,
                        "tag": k,
                        "node": hex(n)}
                 parity = 1 - parity
 
         yield self.t("tags",
                      manifest=hex(mf),
                      entries=entries)
 
     def filediff(self, file, changeset):
         n = bin(changeset)
         cl = self.repo.changelog
         p1 = cl.parents(n)[0]
         cs = cl.read(n)
         mf = self.repo.manifest.read(cs[0])
 
         def diff(**map):
             yield self.diff(p1, n, file)
 
         yield self.t("filediff",
                      file=file,
                      filenode=hex(mf.get(file, nullid)),
                      node=changeset,
                      rev=self.repo.changelog.rev(n),
                      parent=self.parents("filediffparent",
                                          cl.parents(n), cl.rev),
                      diff=diff)
 
     def archive(self, req, cnode, type):
         cs = self.repo.changelog.read(cnode)
         mnode = cs[0]
         mf = self.repo.manifest.read(mnode)
         rev = self.repo.manifest.rev(mnode)
         reponame = re.sub(r"\W+", "-", self.reponame)
         name = "%s-%s/" % (reponame, short(cnode))
 
         files = mf.keys()
         files.sort()
 
         if type == 'zip':
             tmp = tempfile.mkstemp()[1]
             try:
                 zf = zipfile.ZipFile(tmp, "w", zipfile.ZIP_DEFLATED)
 
                 for f in files:
                     zf.writestr(name + f, self.repo.file(f).read(mf[f]))
                 zf.close()
 
                 f = open(tmp, 'r')
                 req.httphdr('application/zip', name[:-1] + '.zip',
                         os.path.getsize(tmp))
                 req.write(f.read())
                 f.close()
             finally:
                 os.unlink(tmp)
 
         else:
             tf = tarfile.TarFile.open(mode='w|' + type, fileobj=req.out)
             mff = self.repo.manifest.readflags(mnode)
             mtime = int(time.time())
 
             if type == "gz":
                 encoding = "gzip"
             else:
                 encoding = "x-bzip2"
-            req.header([('Content-type', 'application/x-tar'), 
+            req.header([('Content-type', 'application/x-tar'),
                     ('Content-disposition', 'attachment; filename=%s%s%s' %
                         (name[:-1], '.tar.', type)),
                     ('Content-encoding', encoding)])
             for fname in files:
                 rcont = self.repo.file(fname).read(mf[fname])
                 finfo = tarfile.TarInfo(name + fname)
                 finfo.mtime = mtime
                 finfo.size = len(rcont)
                 finfo.mode = mff[fname] and 0755 or 0644
                 tf.addfile(finfo, StringIO.StringIO(rcont))
             tf.close()
 
     # add tags to things
     # tags -> list of changesets corresponding to tags
     # find tag, changeset, file
 
     def run(self, req=hgrequest()):
         def header(**map):
             yield self.t("header", **map)
 
         def footer(**map):
             yield self.t("footer", **map)
 
         self.refresh()
 
         t = self.repo.ui.config("web", "templates", templatepath())
         m = os.path.join(t, "map")
         style = self.repo.ui.config("web", "style", "")
         if req.form.has_key('style'):
             style = req.form['style'][0]
         if style:
             b = os.path.basename("map-" + style)
             p = os.path.join(t, b)
             if os.path.isfile(p):
                 m = p
 
         port = req.env["SERVER_PORT"]
         port = port != "80" and (":" + port) or ""
         uri = req.env["REQUEST_URI"]
         if "?" in uri:
             uri = uri.split("?")[0]
         url = "http://%s%s%s" % (req.env["SERVER_NAME"], port, uri)
         if not self.reponame:
             self.reponame = (self.repo.ui.config("web", "name")
                              or uri.strip('/') or self.repo.root)
 
         self.t = templater(m, common_filters,
                            {"url": url,
                             "repo": self.reponame,
                             "header": header,
                             "footer": footer,
                            })
 
         if not req.form.has_key('cmd'):
             req.form['cmd'] = [self.t.cache['default'],]
 
         if req.form['cmd'][0] == 'changelog':
             c = self.repo.changelog.count() - 1
             hi = c
             if req.form.has_key('rev'):
                 hi = req.form['rev'][0]
                 try:
                     hi = self.repo.changelog.rev(self.repo.lookup(hi))
                 except hg.RepoError:
                     req.write(self.search(hi))
                     return
 
             req.write(self.changelog(hi))
 
         elif req.form['cmd'][0] == 'changeset':
             req.write(self.changeset(req.form['node'][0]))
 
         elif req.form['cmd'][0] == 'manifest':
             req.write(self.manifest(req.form['manifest'][0], req.form['path'][0]))
 
         elif req.form['cmd'][0] == 'tags':
             req.write(self.tags())
 
         elif req.form['cmd'][0] == 'filediff':
             req.write(self.filediff(req.form['file'][0], req.form['node'][0]))
 
         elif req.form['cmd'][0] == 'file':
             req.write(self.filerevision(req.form['file'][0], req.form['filenode'][0]))
 
         elif req.form['cmd'][0] == 'annotate':
             req.write(self.fileannotate(req.form['file'][0], req.form['filenode'][0]))
 
         elif req.form['cmd'][0] == 'filelog':
             req.write(self.filelog(req.form['file'][0], req.form['filenode'][0]))
 
         elif req.form['cmd'][0] == 'heads':
             req.httphdr("application/mercurial-0.1")
             h = self.repo.heads()
             req.write(" ".join(map(hex, h)) + "\n")
 
         elif req.form['cmd'][0] == 'branches':
             req.httphdr("application/mercurial-0.1")
             nodes = []
             if req.form.has_key('nodes'):
                 nodes = map(bin, req.form['nodes'][0].split(" "))
             for b in self.repo.branches(nodes):
                 req.write(" ".join(map(hex, b)) + "\n")
 
         elif req.form['cmd'][0] == 'between':
             req.httphdr("application/mercurial-0.1")
             nodes = []
             if req.form.has_key('pairs'):
                 pairs = [map(bin, p.split("-"))
                          for p in req.form['pairs'][0].split(" ")]
             for b in self.repo.between(pairs):
                 req.write(" ".join(map(hex, b)) + "\n")
 
         elif req.form['cmd'][0] == 'changegroup':
             req.httphdr("application/mercurial-0.1")
             nodes = []
             if not self.allowpull:
                 return
 
             if req.form.has_key('roots'):
                 nodes = map(bin, req.form['roots'][0].split(" "))
 
             z = zlib.compressobj()
             f = self.repo.changegroup(nodes)
             while 1:
                 chunk = f.read(4096)
                 if not chunk:
                     break
                 req.write(z.compress(chunk))
 
             req.write(z.flush())
 
         elif req.form['cmd'][0] == 'archive':
             changeset = bin(req.form['node'][0])
             type = req.form['type'][0]
             if (type in self.archives and
                 self.repo.ui.configbool("web", "allow" + type, False)):
                 self.archive(req, changeset, type)
                 return
 
             req.write(self.t("error"))
 
         else:
             req.write(self.t("error"))
 
 def create_server(repo):
 
     def openlog(opt, default):
         if opt and opt != '-':
             return open(opt, 'w')
         return default
 
     address = repo.ui.config("web", "address", "")
     port = int(repo.ui.config("web", "port", 8000))
     use_ipv6 = repo.ui.configbool("web", "ipv6")
     accesslog = openlog(repo.ui.config("web", "accesslog", "-"), sys.stdout)
     errorlog = openlog(repo.ui.config("web", "errorlog", "-"), sys.stderr)
 
     class IPv6HTTPServer(BaseHTTPServer.HTTPServer):
         address_family = getattr(socket, 'AF_INET6', None)
 
         def __init__(self, *args, **kwargs):
             if self.address_family is None:
                 raise hg.RepoError('IPv6 not available on this system')
             BaseHTTPServer.HTTPServer.__init__(self, *args, **kwargs)
 
     class hgwebhandler(BaseHTTPServer.BaseHTTPRequestHandler):
         def log_error(self, format, *args):
             errorlog.write("%s - - [%s] %s\n" % (self.address_string(),
                                                  self.log_date_time_string(),
                                                  format % args))
 
         def log_message(self, format, *args):
             accesslog.write("%s - - [%s] %s\n" % (self.address_string(),
                                                   self.log_date_time_string(),
                                                   format % args))
 
         def do_POST(self):
             try:
                 self.do_hgweb()
             except socket.error, inst:
                 if inst[0] != errno.EPIPE:
                     raise
 
         def do_GET(self):
             self.do_POST()
 
         def do_hgweb(self):
             query = ""
             p = self.path.find("?")
             if p:
                 query = self.path[p + 1:]
                 query = query.replace('+', ' ')
 
             env = {}
             env['GATEWAY_INTERFACE'] = 'CGI/1.1'
             env['REQUEST_METHOD'] = self.command
             env['SERVER_NAME'] = self.server.server_name
             env['SERVER_PORT'] = str(self.server.server_port)
             env['REQUEST_URI'] = "/"
             if query:
                 env['QUERY_STRING'] = query
             host = self.address_string()
             if host != self.client_address[0]:
                 env['REMOTE_HOST'] = host
                 env['REMOTE_ADDR'] = self.client_address[0]
 
             if self.headers.typeheader is None:
                 env['CONTENT_TYPE'] = self.headers.type
             else:
                 env['CONTENT_TYPE'] = self.headers.typeheader
             length = self.headers.getheader('content-length')
             if length:
                 env['CONTENT_LENGTH'] = length
             accept = []
             for line in self.headers.getallmatchingheaders('accept'):
                 if line[:1] in "\t\n\r ":
                     accept.append(line.strip())
                 else:
                     accept = accept + line[7:].split(',')
             env['HTTP_ACCEPT'] = ','.join(accept)
 
             req = hgrequest(self.rfile, self.wfile, env)
             self.send_response(200, "Script output follows")
             hg.run(req)
 
     hg = hgweb(repo)
     if use_ipv6:
         return IPv6HTTPServer((address, port), hgwebhandler)
     else:
         return BaseHTTPServer.HTTPServer((address, port), hgwebhandler)
 
 def server(path, name, templates, address, port, use_ipv6=False,
            accesslog=sys.stdout, errorlog=sys.stderr):
     httpd = create_server(path, name, templates, address, port, use_ipv6,
                           accesslog, errorlog)
     httpd.serve_forever()
 
 # This is a stopgap
 class hgwebdir:
     def __init__(self, config):
         def cleannames(items):
             return [(name.strip('/'), path) for name, path in items]
 
         if type(config) == type([]):
             self.repos = cleannames(config)
         elif type(config) == type({}):
             self.repos = cleannames(config.items())
             self.repos.sort()
         else:
             cp = ConfigParser.SafeConfigParser()
             cp.read(config)
             self.repos = cleannames(cp.items("paths"))
             self.repos.sort()
 
     def run(self, req=hgrequest()):
         def header(**map):
             yield tmpl("header", **map)
 
         def footer(**map):
             yield tmpl("footer", **map)
 
         m = os.path.join(templatepath(), "map")
         tmpl = templater(m, common_filters,
                          {"header": header, "footer": footer})
 
         def entries(**map):
             parity = 0
             for name, path in self.repos:
                 u = ui.ui()
                 try:
                     u.readconfig(file(os.path.join(path, '.hg', 'hgrc')))
                 except IOError:
                     pass
                 get = u.config
 
                 url = ('/'.join([req.env["REQUEST_URI"].split('?')[0], name])
                        .replace("//", "/"))
 
                 yield dict(contact=(get("ui", "username") or # preferred
                                     get("web", "contact") or # deprecated
                                     get("web", "author", "unknown")), # also
                            name=get("web", "name", name),
                            url=url,
                            parity=parity,
                            shortdesc=get("web", "description", "unknown"),
                            lastupdate=os.stat(os.path.join(path, ".hg",
                                               "00changelog.d")).st_mtime)
 
                 parity = 1 - parity
 
         virtual = req.env.get("PATH_INFO", "").strip('/')
         if virtual:
             real = dict(self.repos).get(virtual)
             if real:
                 hgweb(real).run(req)
             else:
                 req.write(tmpl("notfound", repo=virtual))
         else:
             req.write(tmpl("index", entries=entries))

mercurial/packagescan.py

@@ -1,74 +1,74 b''
-# packagescan.py - Helper module for identifing used modules. 
+# packagescan.py - Helper module for identifing used modules.
 # Used for the py2exe distutil.
 #
 # Copyright 2005 Volker Kleinfeld <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 import glob
 import os
 import sys
 import demandload
 import ihooks
 
 requiredmodules = {} # Will contain the modules imported by demandload
 def demandload(scope, modules):
     """ fake demandload function that collects the required modules """
     for m in modules.split():
         mod = None
         mod = __import__(m,scope,scope)
         scope[m] = mod
         requiredmodules[mod.__name__] = 1
 
 def getmodules(libpath,packagename):
     """ helper for finding all required modules of package <packagename> """
     # Use the package in the build directory
     libpath = os.path.abspath(libpath)
     sys.path.insert(0,libpath)
     packdir = os.path.join(libpath,packagename)
-    # A normal import would not find the package in 
+    # A normal import would not find the package in
     # the build directory. ihook is used to force the import.
-    # After the package is imported the import scope for 
+    # After the package is imported the import scope for
     # the following imports is settled.
     p = importfrom(packdir)
     globals()[packagename] = p
     sys.modules[packagename] = p
     # Fetch the python modules in the package
     cwd = os.getcwd()
     os.chdir(packdir)
     pymodulefiles = glob.glob('*.py')
     extmodulefiles = glob.glob('*.pyd')
     os.chdir(cwd)
     # Install a fake demandload module
     sys.modules['mercurial.demandload'] = sys.modules['mercurial.packagescan']
     # Import all python modules and by that run the fake demandload
     for m in pymodulefiles:
         if m == '__init__.py': continue
         tmp = {}
         mname,ext = os.path.splitext(m)
-        fullname = packagename+'.'+mname 
+        fullname = packagename+'.'+mname
         __import__(fullname,tmp,tmp)
         requiredmodules[fullname] = 1
     # Import all extension modules and by that run the fake demandload
     for m in extmodulefiles:
         tmp = {}
         mname,ext = os.path.splitext(m)
         fullname = packagename+'.'+mname
         __import__(fullname,tmp,tmp)
         requiredmodules[fullname] = 1
     includes = requiredmodules.keys()
     return includes
 
 def importfrom(filename):
     """
     import module/package from a named file and returns the module.
     It does not check on sys.modules or includes the module in the scope.
     """
     loader = ihooks.BasicModuleLoader()
     path, file = os.path.split(filename)
     name, ext  = os.path.splitext(file)
     m = loader.find_module_in_dir(name, path)
     if not m:
         raise ImportError, name
     m = loader.load_module(name, m)
     return m

mercurial/util.py

@@ -1,500 +1,500 b''
 """
 util.py - Mercurial utility functions and platform specfic implementations
 
  Copyright 2005 K. Thananchayan <[e-mail]>
 
 This software may be used and distributed according to the terms
 of the GNU General Public License, incorporated herein by reference.
 
 This contains helper routines that are independent of the SCM core and hide
 platform-specific details from the core.
 """
 
 import os, errno
 from demandload import *
 demandload(globals(), "re cStringIO shutil popen2 threading")
 
 def filter(s, cmd):
     "filter a string through a command that transforms its input to its output"
     (pout, pin) = popen2.popen2(cmd, -1, 'b')
     def writer():
         pin.write(s)
         pin.close()
 
     # we should use select instead on UNIX, but this will work on most
     # systems, including Windows
     w = threading.Thread(target=writer)
     w.start()
     f = pout.read()
     pout.close()
     w.join()
     return f
 
 def patch(strip, patchname, ui):
     """apply the patch <patchname> to the working directory.
     a list of patched files is returned"""
     fp = os.popen('patch -p%d < "%s"' % (strip, patchname))
     files = {}
     for line in fp:
         line = line.rstrip()
         ui.status("%s\n" % line)
         if line.startswith('patching file '):
             pf = parse_patch_output(line)
             files.setdefault(pf, 1)
     code = fp.close()
     if code:
         raise Abort("patch command failed: exit status %s " % code)
     return files.keys()
-    
+
 def binary(s):
     """return true if a string is binary data using diff's heuristic"""
     if s and '\0' in s[:4096]:
         return True
     return False
 
 def unique(g):
     """return the uniq elements of iterable g"""
     seen = {}
     for f in g:
         if f not in seen:
             seen[f] = 1
             yield f
 
 class Abort(Exception):
     """Raised if a command needs to print an error and exit."""
 
 def always(fn): return True
 def never(fn): return False
 
 def globre(pat, head='^', tail='$'):
     "convert a glob pattern into a regexp"
     i, n = 0, len(pat)
     res = ''
     group = False
     def peek(): return i < n and pat[i]
     while i < n:
         c = pat[i]
         i = i+1
         if c == '*':
             if peek() == '*':
                 i += 1
                 res += '.*'
             else:
                 res += '[^/]*'
         elif c == '?':
             res += '.'
         elif c == '[':
             j = i
             if j < n and pat[j] in '!]':
                 j += 1
             while j < n and pat[j] != ']':
                 j += 1
             if j >= n:
                 res += '\\['
             else:
                 stuff = pat[i:j].replace('\\','\\\\')
                 i = j + 1
                 if stuff[0] == '!':
                     stuff = '^' + stuff[1:]
                 elif stuff[0] == '^':
                     stuff = '\\' + stuff
                 res = '%s[%s]' % (res, stuff)
         elif c == '{':
             group = True
             res += '(?:'
         elif c == '}' and group:
             res += ')'
             group = False
         elif c == ',' and group:
             res += '|'
         else:
             res += re.escape(c)
     return head + res + tail
 
 _globchars = {'[': 1, '{': 1, '*': 1, '?': 1}
 
 def pathto(n1, n2):
     '''return the relative path from one place to another.
     this returns a path in the form used by the local filesystem, not hg.'''
     if not n1: return localpath(n2)
     a, b = n1.split('/'), n2.split('/')
     a.reverse(), b.reverse()
     while a and b and a[-1] == b[-1]:
         a.pop(), b.pop()
     b.reverse()
     return os.sep.join((['..'] * len(a)) + b)
 
 def canonpath(root, cwd, myname):
     """return the canonical path of myname, given cwd and root"""
     rootsep = root + os.sep
     name = myname
     if not name.startswith(os.sep):
         name = os.path.join(root, cwd, name)
     name = os.path.normpath(name)
     if name.startswith(rootsep):
         return pconvert(name[len(rootsep):])
     elif name == root:
         return ''
     else:
         raise Abort('%s not under root' % myname)
 
 def matcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head=''):
     """build a function to match a set of file patterns
 
     arguments:
     canonroot - the canonical root of the tree you're matching against
     cwd - the current working directory, if relevant
     names - patterns to find
     inc - patterns to include
     exc - patterns to exclude
     head - a regex to prepend to patterns to control whether a match is rooted
 
     a pattern is one of:
     'glob:<rooted glob>'
     're:<rooted regexp>'
     'path:<rooted path>'
     'relglob:<relative glob>'
     'relpath:<relative path>'
     'relre:<relative regexp>'
     '<rooted path or regexp>'
 
     returns:
     a 3-tuple containing
     - list of explicit non-pattern names passed in
     - a bool match(filename) function
     - a bool indicating if any patterns were passed in
 
     todo:
     make head regex a rooted bool
     """
 
     def patkind(name):
         for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre':
             if name.startswith(prefix + ':'): return name.split(':', 1)
         for c in name:
             if c in _globchars: return 'glob', name
         return 'relpath', name
 
     def regex(kind, name, tail):
         '''convert a pattern into a regular expression'''
         if kind == 're':
             return name
         elif kind == 'path':
             return '^' + re.escape(name) + '(?:/|$)'
         elif kind == 'relglob':
             return head + globre(name, '(?:|.*/)', tail)
         elif kind == 'relpath':
             return head + re.escape(name) + tail
         elif kind == 'relre':
             if name.startswith('^'):
                 return name
             return '.*' + name
         return head + globre(name, '', tail)
 
     def matchfn(pats, tail):
         """build a matching function from a set of patterns"""
         if pats:
             pat = '(?:%s)' % '|'.join([regex(k, p, tail) for (k, p) in pats])
             return re.compile(pat).match
 
     def globprefix(pat):
         '''return the non-glob prefix of a path, e.g. foo/* -> foo'''
         root = []
         for p in pat.split(os.sep):
             if patkind(p)[0] == 'glob': break
             root.append(p)
         return '/'.join(root)
 
     pats = []
     files = []
     roots = []
     for kind, name in map(patkind, names):
         if kind in ('glob', 'relpath'):
             name = canonpath(canonroot, cwd, name)
             if name == '':
                 kind, name = 'glob', '**'
         if kind in ('glob', 'path', 're'):
             pats.append((kind, name))
         if kind == 'glob':
             root = globprefix(name)
             if root: roots.append(root)
         elif kind == 'relpath':
             files.append((kind, name))
             roots.append(name)
 
     patmatch = matchfn(pats, '$') or always
     filematch = matchfn(files, '(?:/|$)') or always
     incmatch = always
     if inc:
         incmatch = matchfn(map(patkind, inc), '(?:/|$)')
     excmatch = lambda fn: False
     if exc:
         excmatch = matchfn(map(patkind, exc), '(?:/|$)')
 
     return (roots,
             lambda fn: (incmatch(fn) and not excmatch(fn) and
                         (fn.endswith('/') or
                          (not pats and not files) or
                          (pats and patmatch(fn)) or
                          (files and filematch(fn)))),
             (inc or exc or (pats and pats != [('glob', '**')])) and True)
 
 def system(cmd, errprefix=None):
     """execute a shell command that must succeed"""
     rc = os.system(cmd)
     if rc:
         errmsg = "%s %s" % (os.path.basename(cmd.split(None, 1)[0]),
                             explain_exit(rc)[0])
         if errprefix:
             errmsg = "%s: %s" % (errprefix, errmsg)
         raise Abort(errmsg)
 
 def rename(src, dst):
     """forcibly rename a file"""
     try:
         os.rename(src, dst)
     except:
         os.unlink(dst)
         os.rename(src, dst)
 
 def copyfiles(src, dst, hardlink=None):
     """Copy a directory tree using hardlinks if possible"""
 
     if hardlink is None:
         hardlink = (os.stat(src).st_dev ==
                     os.stat(os.path.dirname(dst)).st_dev)
 
     if os.path.isdir(src):
         os.mkdir(dst)
         for name in os.listdir(src):
             srcname = os.path.join(src, name)
             dstname = os.path.join(dst, name)
             copyfiles(srcname, dstname, hardlink)
     else:
         if hardlink:
             try:
                 os_link(src, dst)
             except:
                 hardlink = False
                 shutil.copy2(src, dst)
         else:
             shutil.copy2(src, dst)
 
 def opener(base):
     """
     return a function that opens files relative to base
 
     this function is used to hide the details of COW semantics and
     remote file access from higher level code.
     """
     p = base
     def o(path, mode="r"):
         f = os.path.join(p, path)
 
         mode += "b" # for that other OS
 
         if mode[0] != "r":
             try:
                 nlink = nlinks(f)
             except OSError:
                 d = os.path.dirname(f)
                 if not os.path.isdir(d):
                     os.makedirs(d)
             else:
                 if nlink > 1:
                     file(f + ".tmp", "wb").write(file(f, "rb").read())
                     rename(f+".tmp", f)
 
         return file(f, mode)
 
     return o
 
 def _makelock_file(info, pathname):
     ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
     os.write(ld, info)
     os.close(ld)
 
 def _readlock_file(pathname):
     return file(pathname).read()
 
 def nlinks(pathname):
     """Return number of hardlinks for the given file."""
     return os.stat(pathname).st_nlink
 
 if hasattr(os, 'link'):
     os_link = os.link
 else:
     def os_link(src, dst):
         raise OSError(0, "Hardlinks not supported")
 
 # Platform specific variants
 if os.name == 'nt':
     nulldev = 'NUL:'
 
     def parse_patch_output(output_line):
         """parses the output produced by patch and returns the file name"""
         pf = output_line[14:]
         if pf[0] == '`':
             pf = pf[1:-1] # Remove the quotes
         return pf
 
     try: # ActivePython can create hard links using win32file module
         import win32file
 
         def os_link(src, dst): # NB will only succeed on NTFS
             win32file.CreateHardLink(dst, src)
 
         def nlinks(pathname):
             """Return number of hardlinks for the given file."""
             try:
                 fh = win32file.CreateFile(pathname,
                     win32file.GENERIC_READ, win32file.FILE_SHARE_READ,
                     None, win32file.OPEN_EXISTING, 0, None)
                 res = win32file.GetFileInformationByHandle(fh)
                 fh.Close()
                 return res[7]
             except:
                 return os.stat(pathname).st_nlink
 
     except ImportError:
         pass
 
     def is_exec(f, last):
         return last
 
     def set_exec(f, mode):
         pass
 
     def pconvert(path):
         return path.replace("\\", "/")
 
     def localpath(path):
         return path.replace('/', '\\')
 
     def normpath(path):
         return pconvert(os.path.normpath(path))
 
     makelock = _makelock_file
     readlock = _readlock_file
 
     def explain_exit(code):
         return "exited with status %d" % code, code
 
 else:
     nulldev = '/dev/null'
 
     def parse_patch_output(output_line):
         """parses the output produced by patch and returns the file name"""
         return output_line[14:]
 
     def is_exec(f, last):
         """check whether a file is executable"""
         return (os.stat(f).st_mode & 0100 != 0)
 
     def set_exec(f, mode):
         s = os.stat(f).st_mode
         if (s & 0100 != 0) == mode:
             return
         if mode:
             # Turn on +x for every +r bit when making a file executable
             # and obey umask.
             umask = os.umask(0)
             os.umask(umask)
             os.chmod(f, s | (s & 0444) >> 2 & ~umask)
         else:
             os.chmod(f, s & 0666)
 
     def pconvert(path):
         return path
 
     def localpath(path):
         return path
 
     normpath = os.path.normpath
 
     def makelock(info, pathname):
         try:
             os.symlink(info, pathname)
         except OSError, why:
             if why.errno == errno.EEXIST:
                 raise
             else:
                 _makelock_file(info, pathname)
 
     def readlock(pathname):
         try:
             return os.readlink(pathname)
         except OSError, why:
             if why.errno == errno.EINVAL:
                 return _readlock_file(pathname)
             else:
                 raise
 
     def explain_exit(code):
         """return a 2-tuple (desc, code) describing a process's status"""
         if os.WIFEXITED(code):
             val = os.WEXITSTATUS(code)
             return "exited with status %d" % val, val
         elif os.WIFSIGNALED(code):
             val = os.WTERMSIG(code)
             return "killed by signal %d" % val, val
         elif os.WIFSTOPPED(code):
             val = os.WSTOPSIG(code)
             return "stopped by signal %d" % val, val
         raise ValueError("invalid exit code")
 
 class chunkbuffer(object):
     """Allow arbitrary sized chunks of data to be efficiently read from an
     iterator over chunks of arbitrary size."""
 
     def __init__(self, in_iter, targetsize = 2**16):
         """in_iter is the iterator that's iterating over the input chunks.
         targetsize is how big a buffer to try to maintain."""
         self.in_iter = iter(in_iter)
         self.buf = ''
         self.targetsize = int(targetsize)
         if self.targetsize <= 0:
             raise ValueError("targetsize must be greater than 0, was %d" %
                              targetsize)
         self.iterempty = False
 
     def fillbuf(self):
         """Ignore target size; read every chunk from iterator until empty."""
         if not self.iterempty:
             collector = cStringIO.StringIO()
             collector.write(self.buf)
             for ch in self.in_iter:
                 collector.write(ch)
             self.buf = collector.getvalue()
             self.iterempty = True
 
     def read(self, l):
         """Read L bytes of data from the iterator of chunks of data.
-	Returns less than L bytes if the iterator runs dry."""
+        Returns less than L bytes if the iterator runs dry."""
         if l > len(self.buf) and not self.iterempty:
             # Clamp to a multiple of self.targetsize
             targetsize = self.targetsize * ((l // self.targetsize) + 1)
             collector = cStringIO.StringIO()
             collector.write(self.buf)
             collected = len(self.buf)
             for chunk in self.in_iter:
                 collector.write(chunk)
                 collected += len(chunk)
                 if collected >= targetsize:
                     break
             if collected < targetsize:
                 self.iterempty = True
             self.buf = collector.getvalue()
         s, self.buf = self.buf[:l], buffer(self.buf, l)
         return s
 
 def filechunkiter(f, size = 65536):
     """Create a generator that produces all the data in the file size
     (default 65536) bytes at a time.  Chunks may be less than size
     bytes if the chunk is the last chunk in the file, or the file is a
     socket or some other type of file that sometimes reads less data
     than is requested."""
     s = f.read(size)
     while len(s) >= 0:
         yield s
         s = f.read(size)

notes.txt

@@ -1,146 +1,146 b''
 Some notes about Mercurial's design
 
 Revlogs:
 
 The fundamental storage type in Mercurial is a "revlog". A revlog is
 the set of all revisions to a file. Each revision is either stored
 compressed in its entirety or as a compressed binary delta against the
 previous version. The decision of when to store a full version is made
 based on how much data would be needed to reconstruct the file. This
 lets us ensure that we never need to read huge amounts of data to
 reconstruct a file, regardless of how many revisions of it we store.
 
 In fact, we should always be able to do it with a single read,
 provided we know when and where to read. This is where the index comes
 in. Each revlog has an index containing a special hash (nodeid) of the
 text, hashes for its parents, and where and how much of the revlog
 data we need to read to reconstruct it. Thus, with one read of the
 index and one read of the data, we can reconstruct any version in time
 proportional to the file size.
 
 Similarly, revlogs and their indices are append-only. This means that
 adding a new version is also O(1) seeks.
 
 Generally revlogs are used to represent revisions of files, but they
 also are used to represent manifests and changesets.
 
 Manifests:
 
 A manifest is simply a list of all files in a given revision of a
 project along with the nodeids of the corresponding file revisions. So
 grabbing a given version of the project means simply looking up its
 manifest and reconstruction all the file revisions pointed to by it.
 
 Changesets:
 
 A changeset is a list of all files changed in a check-in along with a
 change description and some metadata like user and date. It also
 contains a nodeid to the relevent revision of the manifest. Changesets
 and manifests are one-to-one, but contain different data for
 convenience.
 
 Nodeids:
 
 Nodeids are unique ids that are used to represent the contents of a
 file AND its position in the project history. That is, if you change a
 file and then change it back, the result will have a different nodeid
 because it has different history. This is accomplished by including
 the parents of a given revision's nodeids with the revision's text
 when calculating the hash.
 
 Graph merging:
 
 Nodeids are implemented as they are to simplify merging. Merging a
 pair of directed acyclic graphs (aka "the family tree" of the file
 history) requires some method of determining if nodes in different
 graphs correspond. Simply comparing the contents of the node (by
 comparing text of given revisions or their hashes) can get confused by
 identical revisions in the tree.
 
 The nodeid approach makes it trivial - the hash uniquely describes a
 revision's contents and its graph position relative to the root, so
 merge is simply checking whether each nodeid in graph A is in the hash
 table of graph B. If not, we pull them in, adding them sequentially to
 the revlog.
 
 Branching and merging:
 
 Everything in Mercurial is potentially a branch and every user
 effectively works in their own branch. When you do a checkout,
 Mercurial remembers what the parent changeset was and uses it for the
 next check in.
 
 To do a merge of branches in Mercurial, you check out the heads of the
 two branches into the same working directory which causes a merge to
 be performed, and then check in the result once you're happy with it.
 The resulting checkin will have two parents.
 
 It decides when a merge is necessary by first determining if there are
 any uncommitted changes in the working directory. This effectively
 makes the working directory a branch off the checked in version it's
 based on. Then it also determines if the working directory is a direct
 ancestor or descendent of the second version we're attempting to
 checkout. If neither is true, we simply replace the working directory
 version with the new version. Otherwise we perform a merge between the
 two versions.
 
 Merging files and manifests:
 
 We begin by comparing two versions manifests and deciding which files
 need to be added, deleted, and merged.
 
 Then for each file, we perform a graph merge and resolve as above.
 It's important to merge files using per-file DAGs rather than just
-changeset level DAGs as this diagram illustrates: 
+changeset level DAGs as this diagram illustrates:
 
 M   M1   M2
 
 AB
  |`-------v     M2 clones M
 aB       AB     file A is change in mainline
  |`---v  AB'    file B is changed in M2
  |   aB / |     M1 clones M
  |   ab/  |     M1 changes B
  |   ab'  |     M1 merges from M2, changes to B conflict
  |    |  A'B'   M2 changes A
   `---+--.|
       |  a'B'   M2 merges from mainline, changes to A conflict
       `--.|
          ???    depending on which ancestor we choose, we will have
 	        to redo A hand-merge, B hand-merge, or both
                 but if we look at the files independently, everything
 		is fine
 
 The result is a merged version in the working directory, waiting for
 check-in.
 
 Rollback:
 
 When performing a commit or a merge, we order things so that the
 changeset entry gets added last. We keep a transaction log of the name
 of each file touched and its length prior to the transaction. On
 abort, we simply truncate each file to its prior length. This is one
 of the nice properties of the append-only structure of the revlogs.
 We can also reuse this journal for "undo".
 
 Merging between repositories:
 
 One of the key features of Mercurial is the ability to merge between
 independent repositories in a decentralized fashion. Each repository
 can act as a read-only server or a client. Clients operating by
 pulling all branches that it hasn't seen from the server and adding
 them into its graph. This is done in two steps: searching for new
 "roots" and pulling a "changegroup"
 
 Searching for new "roots" begins by finding all new heads and
 searching backwards from those heads to the first unknown nodes in
 their respective branches. These nodes are the 'roots' that are used
 to calculate the 'changegroup': the set of all changesets starting at
 those roots. Mercurial takes pains to make this search efficient in
 both bandwidth and round-trips.
 
 Once the roots are found, the changegroup can be transferred as a
 single streaming transfer. This is organized as an ordered set of
 deltas for changesets, manifests, and files. Large chunks of deltas
 can be directly added to the repository without unpacking so it's
 fairly fast.

setup.py

@@ -1,75 +1,75 b''
 #!/usr/bin/env python
 #
 # This is the mercurial setup script.
 #
 # './setup.py install', or
 # './setup.py --help' for more options
 
 import glob
 from distutils.core import setup, Extension
 from distutils.command.install_data import install_data
 
 import mercurial.version
 
 # py2exe needs to be installed to work
 try:
-    import py2exe 
+    import py2exe
 
     # Due to the use of demandload py2exe is not finding the modules.
-    # packagescan.getmodules creates a list of modules included in 
+    # packagescan.getmodules creates a list of modules included in
     # the mercurial package plus depdent modules.
-    import mercurial.packagescan 
-    from py2exe.build_exe import py2exe as build_exe 
+    import mercurial.packagescan
+    from py2exe.build_exe import py2exe as build_exe
 
     class py2exe_for_demandload(build_exe):
         """ overwrites the py2exe command class for getting the build
         directory and for setting the 'includes' option."""
         def initialize_options(self):
             self.build_lib = None
             build_exe.initialize_options(self)
         def finalize_options(self):
             # Get the build directory, ie. where to search for modules.
             self.set_undefined_options('build',
                                        ('build_lib', 'build_lib'))
             # Sets the 'includes' option with the list of needed modules
             if not self.includes:
                 self.includes = []
             self.includes += mercurial.packagescan.getmodules(self.build_lib,'mercurial')
             build_exe.finalize_options(self)
 except ImportError:
     py2exe_for_demandload = None
 
 
 # specify version string, otherwise 'hg identify' will be used:
 version = ''
 
 class install_package_data(install_data):
     def finalize_options(self):
         self.set_undefined_options('install',
                                    ('install_lib', 'install_dir'))
         install_data.finalize_options(self)
 
 try:
     mercurial.version.remember_version(version)
     cmdclass = {'install_data': install_package_data}
     if py2exe_for_demandload is not None:
         cmdclass['py2exe'] = py2exe_for_demandload
     setup(name='mercurial',
           version=mercurial.version.get_version(),
           author='Matt Mackall',
           author_email='[e-mail]',
           url='http://selenic.com/mercurial',
           description='scalable distributed SCM',
           license='GNU GPL',
           packages=['mercurial'],
           ext_modules=[Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
                        Extension('mercurial.bdiff', ['mercurial/bdiff.c'])],
           data_files=[('mercurial/templates',
                        ['templates/map'] +
                        glob.glob('templates/map-*') +
                        glob.glob('templates/*.tmpl'))],
           cmdclass=cmdclass,
           scripts=['hg', 'hgmerge'],
           console = ['hg'])
 finally:
     mercurial.version.forget_version()

templates/header.tmpl

@@ -1,54 +1,54 b''
 Content-type: text/html
 
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
 <style type="text/css">
 <!--
 a { text-decoration:none; }
 .parity0 { background-color: #dddddd; }
 .parity1 { background-color: #eeeeee; }
 .lineno { width: 60px; color: #aaaaaa; font-size: smaller; }
 .plusline { color: green; }
 .minusline { color: red; }
 .atline { color: purple; }
 .annotate { font-size: smaller; text-align: right; padding-right: 1em; }
 .buttons a {
   background-color: #666666;
   padding: 2pt;
   color: white;
   font-family: sans;
   font-weight: bold;
 }
 .metatag {
   background-color: #888888;
   color: white;
-  text-align: right; 
+  text-align: right;
 }
 
 /* Common */
 pre { margin: 0; }
 
 
 /* Changelog entries */
 .changelogEntry { width: 100%; }
 .changelogEntry th { font-weight: normal; text-align: right; vertical-align: top; width: 15%;}
 .changelogEntry th.age, .changelogEntry th.firstline { font-weight: bold; }
 .changelogEntry th.firstline { text-align: left; width: inherit; }
 
 /* Tag entries */
 #tagEntries { list-style: none; margin: 0; padding: 0; }
 #tagEntries .tagEntry { list-style: none; margin: 0; padding: 0; }
 #tagEntries .tagEntry span.node { font-family: monospace; }
 
 /* Changeset entry */
 #changesetEntry { }
 #changesetEntry th { font-weight: normal; background-color: #888; color: #fff; text-align: right; }
 #changesetEntry th.files, #changesetEntry th.description { vertical-align: top; }
 
 /* File diff view */
 #filediffEntry { }
 #filediffEntry th { font-weight: normal; background-color: #888; color: #fff; text-align: right; }
 
 -->
 </style>

tests/run-tests

@@ -1,145 +1,145 b''
 #!/bin/sh -e
 
 LANG="C"; export LANG
 LC_CTYPE="C"; export LC_CTYPE
 LC_NUMERIC="C"; export LC_NUMERIC
 LC_TIME="C"; export LC_TIME
 LC_COLLATE="C"; export LC_COLLATE
 LC_MONETARY="C"; export LC_MONETARY
 LC_MESSAGES="C"; export LC_MESSAGES
 LC_PAPER="C"; export LC_PAPER
 LC_NAME="C"; export LC_NAME
 LC_ADDRESS="C"; export LC_ADDRESS
 LC_TELEPHONE="C"; export LC_TELEPHONE
 LC_MEASUREMENT="C"; export LC_MEASUREMENT
 LC_IDENTIFICATION="C"; export LC_IDENTIFICATION
 LC_ALL=""; export LC_ALL
 TZ=GMT; export TZ
 HGEDITOR=true; export HGEDITOR
 HGMERGE=true; export HGMERGE
 HGUSER="test"; export HGUSER
 
 umask 022
 
 tests=0
 failed=0
 
 HGTMP=""
 cleanup_exit() {
     rm -rf "$HGTMP"
 }
 
 # Remove temporary files even if we get interrupted
 trap "cleanup_exit" 0 # normal exit
 trap "exit 255" 1 2 3 6 15 # HUP INT QUIT ABRT TERM
 
 HGTMP="${TMPDIR-/tmp}/hgtests.$RANDOM.$RANDOM.$RANDOM.$$"
 (umask 077 && mkdir "$HGTMP") || {
     echo "Could not create temporary directory! Exiting." 1>&2
     exit 1
 }
 
 TESTDIR="$PWD"
 
 if [ -d /usr/lib64 ]; then
     lib=lib64
 else
     lib=lib
 fi
 
 INST="$HGTMP/install"
 cd ..
 if ${PYTHON-python} setup.py install --home="$INST" > tests/install.err 2>&1
 then
     rm tests/install.err
 else
     cat tests/install.err
     exit 1
 fi
 cd "$TESTDIR"
 
 PATH="$INST/bin:$PATH"; export PATH
 PYTHONPATH="$INST/$lib/python"; export PYTHONPATH
 
 
 run_one() {
     rm -f "$1.err"
 
     mkdir "$HGTMP/$1"
     cd "$HGTMP/$1"
     fail=0
     HOME="$HGTMP/$1"; export HOME
     OUT="$HGTMP/$1.out"
     OUTOK="$TESTDIR/$1.out"
     ERR="$TESTDIR/$1.err"
 
     if "$TESTDIR/$1" > "$OUT" 2>&1; then
 	: no error
     else
 	echo "$1 failed with error code $?"
 	fail=1
     fi
 
     if [ -s "$OUT" -a ! -s "$OUTOK" ] ; then
 	cp "$OUT" "$ERR"
 	echo
 	echo "$1 generated unexpected output:"
 	cat "$ERR"
 	fail=1
     elif [ -r "$OUTOK" ]; then
 	if diff -u "$OUTOK" "$OUT" > /dev/null; then
 	    : no differences
 	else
 	    cp "$OUT" "$ERR"
 	    echo
 	    echo "$1 output changed:"
 	    diff -u "$OUTOK" "$ERR" || true
 	    fail=1
 	fi
     fi
 
     cd "$TESTDIR"
     rm -f "$HGTMP/$1.out"
     rm -rf "$HGTMP/$1"
     return $fail
 }
 
-# list of prerequisite programs 
+# list of prerequisite programs
 # stuff from coreutils (cat, rm, etc) are not tested
 prereqs="python merge diff grep unzip md5sum gunzip sed"
 missing=''
 for pre in $prereqs ; do
     if type $pre > /dev/null 2>&1 ; then
         : prereq exists
-    else 
+    else
         missing="$pre $missing"
     fi
 done
 
 if [ "$missing" != ''  ] ; then
     echo "ERROR: the test suite needs some programs to execute correctly."
     echo "The following programs are missing: "
     for pre in $missing; do
         echo "   $pre"
     done
     exit 1
 fi
 
 TESTS="$*"
 if [ -z "$TESTS" ] ; then
     TESTS=`ls test-* | grep -v "[.~]"`
 fi
 
 for f in $TESTS ; do
     echo -n "."
     run_one $f || failed=`expr $failed + 1`
     tests=`expr $tests + 1`
 done
 
 echo
 echo "Ran $tests tests, $failed failed."
 
 if [ $failed -gt 0 ] ; then
     exit 1
 fi
 exit 0

tests/test-rawcommit1

@@ -1,33 +1,33 b''
 #!/bin/sh
 hg --debug init
 echo this is a1 > a
 hg add a
-hg commit -m0 -d "0 0" 
+hg commit -m0 -d "0 0"
 echo this is b1 > b
 hg add b
-hg commit -m1 -d "0 0" 
+hg commit -m1 -d "0 0"
 hg manifest 1
 echo this is c1 > c
 hg rawcommit -p 1 -d "0 0" -m2 c
 hg manifest 2
 hg parents
 rm b
 hg rawcommit -p 2 -d "0 0" -m3 b
 hg manifest 3
 hg parents
 echo this is a22 > a
 hg rawcommit -p 3 -d "0 0" -m4 a
 hg manifest 4
 hg parents
 echo this is c22 > c
 hg rawcommit -p 1 -d "0 0" -m5 c
 hg manifest 5
 hg parents
 # merge, but no files changed
 hg rawcommit -p 4 -p 5 -d "0 0" -m6
 hg manifest 6
 hg parents
 # no changes what-so-ever
 hg rawcommit -p 6 -d "0 0" -m7
 hg manifest 7
 hg parents

tests/test-tag

@@ -1,13 +1,13 b''
 #!/bin/sh
 
 hg init
 echo a > a
 hg add a
 hg commit -m "test" -d "0 0"
 hg history
-hg tag -d "0 0" "bleah" 
+hg tag -d "0 0" "bleah"
 hg history
 
 echo foo >> .hgtags
-hg tag -d "0 0" "bleah2" || echo "failed" 
+hg tag -d "0 0" "bleah2" || echo "failed"
 

tests/test-unrelated-pull

@@ -1,19 +1,19 b''
 #!/bin/sh
 
 mkdir a
 cd a
 hg init
 echo 123 > a
 hg add a
 hg commit -m "a" -u a -d "0 0"
 
 cd ..
 mkdir b
 cd b
-hg init 
+hg init
 echo 321 > b
 hg add b
 hg commit -m "b" -u b -d "0 0"
 
 hg pull ../a
 hg heads

tests/test-update-reverse

@@ -1,34 +1,34 b''
 #!/bin/sh
 
 hg init
 touch a
 hg add a
 hg commit -m "Added a" -d "0 0"
 
 touch main
 hg add main
 hg commit -t "Added main" -d "0 0"
 hg checkout 0
 
 echo Main should be gone
 ls
 
-touch side1 
+touch side1
 hg add side1
 hg commit -m "Added side1" -d "0 0"
 touch side2
 hg add side2
 hg commit -m "Added side2" -d "0 0"
 
 hg log
 
 echo Should have two heads, side2 and main
 hg heads
 
 echo Should show "a side1 side2"
 ls
 
 hg update --debug -C 1
 echo Should only show "a main"
 ls