Merge branch 'hv/bitshift-constants-in-blame'
[git] / git-gui / lib / diff.tcl
1 # git-gui diff viewer
2 # Copyright (C) 2006, 2007 Shawn Pearce
3
4 proc apply_tab_size {{firsttab {}}} {
5         global have_tk85 repo_config ui_diff
6
7         set w [font measure font_diff "0"]
8         if {$have_tk85 && $firsttab != 0} {
9                 $ui_diff configure -tabs [list [expr {$firsttab * $w}] [expr {($firsttab + $repo_config(gui.tabsize)) * $w}]]
10         } elseif {$have_tk85 || $repo_config(gui.tabsize) != 8} {
11                 $ui_diff configure -tabs [expr {$repo_config(gui.tabsize) * $w}]
12         } else {
13                 $ui_diff configure -tabs {}
14         }
15 }
16
17 proc clear_diff {} {
18         global ui_diff current_diff_path current_diff_header
19         global ui_index ui_workdir
20
21         $ui_diff conf -state normal
22         $ui_diff delete 0.0 end
23         $ui_diff conf -state disabled
24
25         set current_diff_path {}
26         set current_diff_header {}
27
28         $ui_index tag remove in_diff 0.0 end
29         $ui_workdir tag remove in_diff 0.0 end
30 }
31
32 proc reshow_diff {{after {}}} {
33         global file_states file_lists
34         global current_diff_path current_diff_side
35         global ui_diff
36
37         set p $current_diff_path
38         if {$p eq {}} {
39                 # No diff is being shown.
40         } elseif {$current_diff_side eq {}} {
41                 clear_diff
42         } elseif {[catch {set s $file_states($p)}]
43                 || [lsearch -sorted -exact $file_lists($current_diff_side) $p] == -1} {
44
45                 if {[find_next_diff $current_diff_side $p {} {[^O]}]} {
46                         next_diff $after
47                 } else {
48                         clear_diff
49                 }
50         } else {
51                 set save_pos [lindex [$ui_diff yview] 0]
52                 show_diff $p $current_diff_side {} $save_pos $after
53         }
54 }
55
56 proc force_diff_encoding {enc} {
57         global current_diff_path
58
59         if {$current_diff_path ne {}} {
60                 force_path_encoding $current_diff_path $enc
61                 reshow_diff
62         }
63 }
64
65 proc handle_empty_diff {} {
66         global current_diff_path file_states file_lists
67         global diff_empty_count
68
69         set path $current_diff_path
70         set s $file_states($path)
71         if {[lindex $s 0] ne {_M} || [has_textconv $path]} return
72
73         # Prevent infinite rescan loops
74         incr diff_empty_count
75         if {$diff_empty_count > 1} return
76
77         info_popup [mc "No differences detected.
78
79 %s has no changes.
80
81 The modification date of this file was updated by another application, but the content within the file was not changed.
82
83 A rescan will be automatically started to find other files which may have the same state." [short_path $path]]
84
85         clear_diff
86         display_file $path __
87         rescan ui_ready 0
88 }
89
90 proc show_diff {path w {lno {}} {scroll_pos {}} {callback {}}} {
91         global file_states file_lists
92         global is_3way_diff is_conflict_diff diff_active repo_config
93         global ui_diff ui_index ui_workdir
94         global current_diff_path current_diff_side current_diff_header
95         global current_diff_queue
96
97         if {$diff_active || ![lock_index read]} return
98
99         clear_diff
100         if {$lno == {}} {
101                 set lno [lsearch -sorted -exact $file_lists($w) $path]
102                 if {$lno >= 0} {
103                         incr lno
104                 }
105         }
106         if {$lno >= 1} {
107                 $w tag add in_diff $lno.0 [expr {$lno + 1}].0
108                 $w see $lno.0
109         }
110
111         set s $file_states($path)
112         set m [lindex $s 0]
113         set is_conflict_diff 0
114         set current_diff_path $path
115         set current_diff_side $w
116         set current_diff_queue {}
117         ui_status [mc "Loading diff of %s..." [escape_path $path]]
118
119         set cont_info [list $scroll_pos $callback]
120
121         apply_tab_size 0
122
123         if {[string first {U} $m] >= 0} {
124                 merge_load_stages $path [list show_unmerged_diff $cont_info]
125         } elseif {$m eq {_O}} {
126                 show_other_diff $path $w $m $cont_info
127         } else {
128                 start_show_diff $cont_info
129         }
130
131         global current_diff_path selected_paths
132         set selected_paths($current_diff_path) 1
133 }
134
135 proc show_unmerged_diff {cont_info} {
136         global current_diff_path current_diff_side
137         global merge_stages ui_diff is_conflict_diff
138         global current_diff_queue
139
140         if {$merge_stages(2) eq {}} {
141                 set is_conflict_diff 1
142                 lappend current_diff_queue \
143                         [list [mc "LOCAL: deleted\nREMOTE:\n"] d= \
144                             [list ":1:$current_diff_path" ":3:$current_diff_path"]]
145         } elseif {$merge_stages(3) eq {}} {
146                 set is_conflict_diff 1
147                 lappend current_diff_queue \
148                         [list [mc "REMOTE: deleted\nLOCAL:\n"] d= \
149                             [list ":1:$current_diff_path" ":2:$current_diff_path"]]
150         } elseif {[lindex $merge_stages(1) 0] eq {120000}
151                 || [lindex $merge_stages(2) 0] eq {120000}
152                 || [lindex $merge_stages(3) 0] eq {120000}} {
153                 set is_conflict_diff 1
154                 lappend current_diff_queue \
155                         [list [mc "LOCAL:\n"] d= \
156                             [list ":1:$current_diff_path" ":2:$current_diff_path"]]
157                 lappend current_diff_queue \
158                         [list [mc "REMOTE:\n"] d= \
159                             [list ":1:$current_diff_path" ":3:$current_diff_path"]]
160         } else {
161                 start_show_diff $cont_info
162                 return
163         }
164
165         advance_diff_queue $cont_info
166 }
167
168 proc advance_diff_queue {cont_info} {
169         global current_diff_queue ui_diff
170
171         set item [lindex $current_diff_queue 0]
172         set current_diff_queue [lrange $current_diff_queue 1 end]
173
174         $ui_diff conf -state normal
175         $ui_diff insert end [lindex $item 0] [lindex $item 1]
176         $ui_diff conf -state disabled
177
178         start_show_diff $cont_info [lindex $item 2]
179 }
180
181 proc show_other_diff {path w m cont_info} {
182         global file_states file_lists
183         global is_3way_diff diff_active repo_config
184         global ui_diff ui_index ui_workdir
185         global current_diff_path current_diff_side current_diff_header
186
187         # - Git won't give us the diff, there's nothing to compare to!
188         #
189         if {$m eq {_O}} {
190                 set max_sz 100000
191                 set type unknown
192                 if {[catch {
193                                 set type [file type $path]
194                                 switch -- $type {
195                                 directory {
196                                         set type submodule
197                                         set content {}
198                                         set sz 0
199                                 }
200                                 link {
201                                         set content [file readlink $path]
202                                         set sz [string length $content]
203                                 }
204                                 file {
205                                         set fd [open $path r]
206                                         fconfigure $fd \
207                                                 -eofchar {} \
208                                                 -encoding [get_path_encoding $path]
209                                         set content [read $fd $max_sz]
210                                         close $fd
211                                         set sz [file size $path]
212                                 }
213                                 default {
214                                         error "'$type' not supported"
215                                 }
216                                 }
217                         } err ]} {
218                         set diff_active 0
219                         unlock_index
220                         ui_status [mc "Unable to display %s" [escape_path $path]]
221                         error_popup [strcat [mc "Error loading file:"] "\n\n$err"]
222                         return
223                 }
224                 $ui_diff conf -state normal
225                 if {$type eq {submodule}} {
226                         $ui_diff insert end \
227                                 "* [mc "Git Repository (subproject)"]\n" \
228                                 d_info
229                 } elseif {![catch {set type [exec file $path]}]} {
230                         set n [string length $path]
231                         if {[string equal -length $n $path $type]} {
232                                 set type [string range $type $n end]
233                                 regsub {^:?\s*} $type {} type
234                         }
235                         $ui_diff insert end "* $type\n" d_info
236                 }
237                 if {[string first "\0" $content] != -1} {
238                         $ui_diff insert end \
239                                 [mc "* Binary file (not showing content)."] \
240                                 d_info
241                 } else {
242                         if {$sz > $max_sz} {
243                                 $ui_diff insert end [mc \
244 "* Untracked file is %d bytes.
245 * Showing only first %d bytes.
246 " $sz $max_sz] d_info
247                         }
248                         $ui_diff insert end $content
249                         if {$sz > $max_sz} {
250                                 $ui_diff insert end [mc "
251 * Untracked file clipped here by %s.
252 * To see the entire file, use an external editor.
253 " [appname]] d_info
254                         }
255                 }
256                 $ui_diff conf -state disabled
257                 set diff_active 0
258                 unlock_index
259                 set scroll_pos [lindex $cont_info 0]
260                 if {$scroll_pos ne {}} {
261                         update
262                         $ui_diff yview moveto $scroll_pos
263                 }
264                 ui_ready
265                 set callback [lindex $cont_info 1]
266                 if {$callback ne {}} {
267                         eval $callback
268                 }
269                 return
270         }
271 }
272
273 proc start_show_diff {cont_info {add_opts {}}} {
274         global file_states file_lists
275         global is_3way_diff is_submodule_diff diff_active repo_config
276         global ui_diff ui_index ui_workdir
277         global current_diff_path current_diff_side current_diff_header
278
279         set path $current_diff_path
280         set w $current_diff_side
281
282         set s $file_states($path)
283         set m [lindex $s 0]
284         set is_3way_diff 0
285         set is_submodule_diff 0
286         set diff_active 1
287         set current_diff_header {}
288         set conflict_size [gitattr $path conflict-marker-size 7]
289
290         set cmd [list]
291         if {$w eq $ui_index} {
292                 lappend cmd diff-index
293                 lappend cmd --cached
294                 if {[git-version >= "1.7.2"]} {
295                         lappend cmd --ignore-submodules=dirty
296                 }
297         } elseif {$w eq $ui_workdir} {
298                 if {[string first {U} $m] >= 0} {
299                         lappend cmd diff
300                 } else {
301                         lappend cmd diff-files
302                 }
303         }
304         if {![is_config_false gui.textconv] && [git-version >= 1.6.1]} {
305                 lappend cmd --textconv
306         }
307
308         if {[string match {160000 *} [lindex $s 2]]
309          || [string match {160000 *} [lindex $s 3]]} {
310                 set is_submodule_diff 1
311
312                 if {[git-version >= "1.6.6"]} {
313                         lappend cmd --submodule
314                 }
315         }
316
317         lappend cmd -p
318         lappend cmd --color
319         set cmd [concat $cmd $repo_config(gui.diffopts)]
320         if {$repo_config(gui.diffcontext) >= 1} {
321                 lappend cmd "-U$repo_config(gui.diffcontext)"
322         }
323         if {$w eq $ui_index} {
324                 lappend cmd [PARENT]
325         }
326         if {$add_opts ne {}} {
327                 eval lappend cmd $add_opts
328         } else {
329                 lappend cmd --
330                 lappend cmd $path
331         }
332
333         if {$is_submodule_diff && [git-version < "1.6.6"]} {
334                 if {$w eq $ui_index} {
335                         set cmd [list submodule summary --cached -- $path]
336                 } else {
337                         set cmd [list submodule summary --files -- $path]
338                 }
339         }
340
341         if {[catch {set fd [eval git_read --nice $cmd]} err]} {
342                 set diff_active 0
343                 unlock_index
344                 ui_status [mc "Unable to display %s" [escape_path $path]]
345                 error_popup [strcat [mc "Error loading diff:"] "\n\n$err"]
346                 return
347         }
348
349         set ::current_diff_inheader 1
350         # Detect pre-image lines of the diff3 conflict-style. They are just
351         # '++' lines which is not bijective. Thus, we need to maintain a state
352         # across lines.
353         set ::conflict_in_pre_image 0
354         fconfigure $fd \
355                 -blocking 0 \
356                 -encoding [get_path_encoding $path] \
357                 -translation lf
358         fileevent $fd readable [list read_diff $fd $conflict_size $cont_info]
359 }
360
361 proc parse_color_line {line} {
362         set start 0
363         set result ""
364         set markup [list]
365         set regexp {\033\[((?:\d+;)*\d+)?m}
366         set need_reset 0
367         while {[regexp -indices -start $start $regexp $line match code]} {
368                 foreach {begin end} $match break
369                 append result [string range $line $start [expr {$begin - 1}]]
370                 set pos [string length $result]
371                 set col [eval [linsert $code 0 string range $line]]
372                 set start [incr end]
373                 if {$col eq "0" || $col eq ""} {
374                         if {!$need_reset} continue
375                         set need_reset 0
376                 } else {
377                         set need_reset 1
378                 }
379                 lappend markup $pos $col
380         }
381         append result [string range $line $start end]
382         if {[llength $markup] < 4} {set markup {}}
383         return [list $result $markup]
384 }
385
386 proc read_diff {fd conflict_size cont_info} {
387         global ui_diff diff_active is_submodule_diff
388         global is_3way_diff is_conflict_diff current_diff_header
389         global current_diff_queue
390         global diff_empty_count
391
392         $ui_diff conf -state normal
393         while {[gets $fd line] >= 0} {
394                 foreach {line markup} [parse_color_line $line] break
395                 set line [string map {\033 ^} $line]
396
397                 set tags {}
398
399                 # -- Check for start of diff header.
400                 if {   [string match {diff --git *}      $line]
401                     || [string match {diff --cc *}       $line]
402                     || [string match {diff --combined *} $line]} {
403                         set ::current_diff_inheader 1
404                 }
405
406                 # -- Check for end of diff header (any hunk line will do this).
407                 #
408                 if {[regexp {^@@+ } $line]} {set ::current_diff_inheader 0}
409
410                 # -- Automatically detect if this is a 3 way diff.
411                 #
412                 if {[string match {@@@ *} $line]} {
413                         set is_3way_diff 1
414                         apply_tab_size 1
415                 }
416
417                 if {$::current_diff_inheader} {
418
419                         # -- These two lines stop a diff header and shouldn't be in there
420                         if {   [string match {Binary files * and * differ} $line]
421                             || [regexp {^\* Unmerged path }                $line]} {
422                                 set ::current_diff_inheader 0
423                         } else {
424                                 append current_diff_header $line "\n"
425                         }
426
427                         # -- Cleanup uninteresting diff header lines.
428                         #
429                         if {   [string match {diff --git *}      $line]
430                             || [string match {diff --cc *}       $line]
431                             || [string match {diff --combined *} $line]
432                             || [string match {--- *}             $line]
433                             || [string match {+++ *}             $line]
434                             || [string match {index *}           $line]} {
435                                 continue
436                         }
437
438                         # -- Name it symlink, not 120000
439                         #    Note, that the original line is in $current_diff_header
440                         regsub {^(deleted|new) file mode 120000} $line {\1 symlink} line
441
442                 } elseif {   $line eq {\ No newline at end of file}} {
443                         # -- Handle some special lines
444                 } elseif {$is_3way_diff} {
445                         set op [string range $line 0 1]
446                         switch -- $op {
447                         {  } {set tags {}}
448                         {@@} {set tags d_@}
449                         { +} {set tags d_s+}
450                         { -} {set tags d_s-}
451                         {+ } {set tags d_+s}
452                         {- } {set tags d_-s}
453                         {--} {set tags d_--}
454                         {++} {
455                                 set regexp [string map [list %conflict_size $conflict_size]\
456                                                                 {^\+\+([<>=|]){%conflict_size}(?: |$)}]
457                                 if {[regexp $regexp $line _g op]} {
458                                         set is_conflict_diff 1
459                                         set line [string replace $line 0 1 {  }]
460                                         set tags d$op
461
462                                         # The ||| conflict-marker marks the start of the pre-image.
463                                         # All those lines are also prefixed with '++'. Thus we need
464                                         # to maintain this state.
465                                         set ::conflict_in_pre_image [expr {$op eq {|}}]
466                                 } elseif {$::conflict_in_pre_image} {
467                                         # This is a pre-image line. It is the one which both sides
468                                         # are based on. As it has also the '++' line start, it is
469                                         # normally shown as 'added'. Invert this to '--' to make
470                                         # it a 'removed' line.
471                                         set line [string replace $line 0 1 {--}]
472                                         set tags d_--
473                                 } else {
474                                         set tags d_++
475                                 }
476                         }
477                         default {
478                                 puts "error: Unhandled 3 way diff marker: {$op}"
479                                 set tags {}
480                         }
481                         }
482                 } elseif {$is_submodule_diff} {
483                         if {$line == ""} continue
484                         if {[regexp {^Submodule } $line]} {
485                                 set tags d_info
486                         } elseif {[regexp {^\* } $line]} {
487                                 set line [string replace $line 0 1 {Submodule }]
488                                 set tags d_info
489                         } else {
490                                 set op [string range $line 0 2]
491                                 switch -- $op {
492                                 {  <} {set tags d_-}
493                                 {  >} {set tags d_+}
494                                 {  W} {set tags {}}
495                                 default {
496                                         puts "error: Unhandled submodule diff marker: {$op}"
497                                         set tags {}
498                                 }
499                                 }
500                         }
501                 } else {
502                         set op [string index $line 0]
503                         switch -- $op {
504                         { } {set tags {}}
505                         {@} {set tags d_@}
506                         {-} {set tags d_-}
507                         {+} {
508                                 set regexp [string map [list %conflict_size $conflict_size]\
509                                                                 {^\+([<>=]){%conflict_size}(?: |$)}]
510                                 if {[regexp $regexp $line _g op]} {
511                                         set is_conflict_diff 1
512                                         set tags d$op
513                                 } else {
514                                         set tags d_+
515                                 }
516                         }
517                         default {
518                                 puts "error: Unhandled 2 way diff marker: {$op}"
519                                 set tags {}
520                         }
521                         }
522                 }
523                 set mark [$ui_diff index "end - 1 line linestart"]
524                 $ui_diff insert end $line $tags
525                 if {[string index $line end] eq "\r"} {
526                         $ui_diff tag add d_cr {end - 2c}
527                 }
528                 $ui_diff insert end "\n" $tags
529
530                 foreach {posbegin colbegin posend colend} $markup {
531                         set prefix clr
532                         foreach style [lsort -integer [split $colbegin ";"]] {
533                                 if {$style eq "7"} {append prefix i; continue}
534                                 if {$style != 4 && ($style < 30 || $style > 47)} {continue}
535                                 set a "$mark linestart + $posbegin chars"
536                                 set b "$mark linestart + $posend chars"
537                                 catch {$ui_diff tag add $prefix$style $a $b}
538                         }
539                 }
540         }
541         $ui_diff conf -state disabled
542
543         if {[eof $fd]} {
544                 close $fd
545
546                 if {$current_diff_queue ne {}} {
547                         advance_diff_queue $cont_info
548                         return
549                 }
550
551                 set diff_active 0
552                 unlock_index
553                 set scroll_pos [lindex $cont_info 0]
554                 if {$scroll_pos ne {}} {
555                         update
556                         $ui_diff yview moveto $scroll_pos
557                 }
558                 ui_ready
559
560                 if {[$ui_diff index end] eq {2.0}} {
561                         handle_empty_diff
562                 } else {
563                         set diff_empty_count 0
564                 }
565
566                 set callback [lindex $cont_info 1]
567                 if {$callback ne {}} {
568                         eval $callback
569                 }
570         }
571 }
572
573 proc apply_or_revert_hunk {x y revert} {
574         global current_diff_path current_diff_header current_diff_side
575         global ui_diff ui_index file_states last_revert last_revert_enc
576
577         if {$current_diff_path eq {} || $current_diff_header eq {}} return
578         if {![lock_index apply_hunk]} return
579
580         set apply_cmd {apply --whitespace=nowarn}
581         set mi [lindex $file_states($current_diff_path) 0]
582         if {$current_diff_side eq $ui_index} {
583                 set failed_msg [mc "Failed to unstage selected hunk."]
584                 lappend apply_cmd --reverse --cached
585                 if {[string index $mi 0] ne {M}} {
586                         unlock_index
587                         return
588                 }
589         } else {
590                 if {$revert} {
591                         set failed_msg [mc "Failed to revert selected hunk."]
592                         lappend apply_cmd --reverse
593                 } else {
594                         set failed_msg [mc "Failed to stage selected hunk."]
595                         lappend apply_cmd --cached
596                 }
597
598                 if {[string index $mi 1] ne {M}} {
599                         unlock_index
600                         return
601                 }
602         }
603
604         set s_lno [lindex [split [$ui_diff index @$x,$y] .] 0]
605         set s_lno [$ui_diff search -backwards -regexp ^@@ $s_lno.0 0.0]
606         if {$s_lno eq {}} {
607                 unlock_index
608                 return
609         }
610
611         set e_lno [$ui_diff search -forwards -regexp ^@@ "$s_lno + 1 lines" end]
612         if {$e_lno eq {}} {
613                 set e_lno end
614         }
615
616         set wholepatch "$current_diff_header[$ui_diff get $s_lno $e_lno]"
617
618         if {[catch {
619                 set enc [get_path_encoding $current_diff_path]
620                 set p [eval git_write $apply_cmd]
621                 fconfigure $p -translation binary -encoding $enc
622                 puts -nonewline $p $wholepatch
623                 close $p} err]} {
624                 error_popup "$failed_msg\n\n$err"
625                 unlock_index
626                 return
627         }
628
629         if {$revert} {
630                 # Save a copy of this patch for undoing reverts.
631                 set last_revert $wholepatch
632                 set last_revert_enc $enc
633         }
634
635         $ui_diff conf -state normal
636         $ui_diff delete $s_lno $e_lno
637         $ui_diff conf -state disabled
638
639         # Check if the hunk was the last one in the file.
640         if {[$ui_diff get 1.0 end] eq "\n"} {
641                 set o _
642         } else {
643                 set o ?
644         }
645
646         # Update the status flags.
647         if {$revert} {
648                 set mi [string index $mi 0]$o
649         } elseif {$current_diff_side eq $ui_index} {
650                 set mi ${o}M
651         } elseif {[string index $mi 0] eq {_}} {
652                 set mi M$o
653         } else {
654                 set mi ?$o
655         }
656         unlock_index
657         display_file $current_diff_path $mi
658         # This should trigger shift to the next changed file
659         if {$o eq {_}} {
660                 reshow_diff
661         }
662 }
663
664 proc apply_or_revert_range_or_line {x y revert} {
665         global current_diff_path current_diff_header current_diff_side
666         global ui_diff ui_index file_states last_revert
667
668         set selected [$ui_diff tag nextrange sel 0.0]
669
670         if {$selected == {}} {
671                 set first [$ui_diff index "@$x,$y"]
672                 set last $first
673         } else {
674                 set first [lindex $selected 0]
675                 set last [lindex $selected 1]
676         }
677
678         set first_l [$ui_diff index "$first linestart"]
679         set last_l [$ui_diff index "$last lineend"]
680
681         if {$current_diff_path eq {} || $current_diff_header eq {}} return
682         if {![lock_index apply_hunk]} return
683
684         set apply_cmd {apply --whitespace=nowarn}
685         set mi [lindex $file_states($current_diff_path) 0]
686         if {$current_diff_side eq $ui_index} {
687                 set failed_msg [mc "Failed to unstage selected line."]
688                 set to_context {+}
689                 lappend apply_cmd --reverse --cached
690                 if {[string index $mi 0] ne {M}} {
691                         unlock_index
692                         return
693                 }
694         } else {
695                 if {$revert} {
696                         set failed_msg [mc "Failed to revert selected line."]
697                         set to_context {+}
698                         lappend apply_cmd --reverse
699                 } else {
700                         set failed_msg [mc "Failed to stage selected line."]
701                         set to_context {-}
702                         lappend apply_cmd --cached
703                 }
704
705                 if {[string index $mi 1] ne {M}} {
706                         unlock_index
707                         return
708                 }
709         }
710
711         set wholepatch {}
712
713         while {$first_l < $last_l} {
714                 set i_l [$ui_diff search -backwards -regexp ^@@ $first_l 0.0]
715                 if {$i_l eq {}} {
716                         # If there's not a @@ above, then the selected range
717                         # must have come before the first_l @@
718                         set i_l [$ui_diff search -regexp ^@@ $first_l $last_l]
719                 }
720                 if {$i_l eq {}} {
721                         unlock_index
722                         return
723                 }
724                 # $i_l is now at the beginning of a line
725
726                 # pick start line number from hunk header
727                 set hh [$ui_diff get $i_l "$i_l + 1 lines"]
728                 set hh [lindex [split $hh ,] 0]
729                 set hln [lindex [split $hh -] 1]
730                 set hln [lindex [split $hln " "] 0]
731
732                 # There is a special situation to take care of. Consider this
733                 # hunk:
734                 #
735                 #    @@ -10,4 +10,4 @@
736                 #     context before
737                 #    -old 1
738                 #    -old 2
739                 #    +new 1
740                 #    +new 2
741                 #     context after
742                 #
743                 # We used to keep the context lines in the order they appear in
744                 # the hunk. But then it is not possible to correctly stage only
745                 # "-old 1" and "+new 1" - it would result in this staged text:
746                 #
747                 #    context before
748                 #    old 2
749                 #    new 1
750                 #    context after
751                 #
752                 # (By symmetry it is not possible to *un*stage "old 2" and "new
753                 # 2".)
754                 #
755                 # We resolve the problem by introducing an asymmetry, namely,
756                 # when a "+" line is *staged*, it is moved in front of the
757                 # context lines that are generated from the "-" lines that are
758                 # immediately before the "+" block. That is, we construct this
759                 # patch:
760                 #
761                 #    @@ -10,4 +10,5 @@
762                 #     context before
763                 #    +new 1
764                 #     old 1
765                 #     old 2
766                 #     context after
767                 #
768                 # But we do *not* treat "-" lines that are *un*staged in a
769                 # special way.
770                 #
771                 # With this asymmetry it is possible to stage the change "old
772                 # 1" -> "new 1" directly, and to stage the change "old 2" ->
773                 # "new 2" by first staging the entire hunk and then unstaging
774                 # the change "old 1" -> "new 1".
775                 #
776                 # Applying multiple lines adds complexity to the special
777                 # situation.  The pre_context must be moved after the entire
778                 # first block of consecutive staged "+" lines, so that
779                 # staging both additions gives the following patch:
780                 #
781                 #    @@ -10,4 +10,6 @@
782                 #     context before
783                 #    +new 1
784                 #    +new 2
785                 #     old 1
786                 #     old 2
787                 #     context after
788
789                 # This is non-empty if and only if we are _staging_ changes;
790                 # then it accumulates the consecutive "-" lines (after
791                 # converting them to context lines) in order to be moved after
792                 # "+" change lines.
793                 set pre_context {}
794
795                 set n 0
796                 set m 0
797                 set i_l [$ui_diff index "$i_l + 1 lines"]
798                 set patch {}
799                 while {[$ui_diff compare $i_l < "end - 1 chars"] &&
800                        [$ui_diff get $i_l "$i_l + 2 chars"] ne {@@}} {
801                         set next_l [$ui_diff index "$i_l + 1 lines"]
802                         set c1 [$ui_diff get $i_l]
803                         if {[$ui_diff compare $first_l <= $i_l] &&
804                             [$ui_diff compare $i_l < $last_l] &&
805                             ($c1 eq {-} || $c1 eq {+})} {
806                                 # a line to stage/unstage
807                                 set ln [$ui_diff get $i_l $next_l]
808                                 if {$c1 eq {-}} {
809                                         set n [expr $n+1]
810                                         set patch "$patch$pre_context$ln"
811                                         set pre_context {}
812                                 } else {
813                                         set m [expr $m+1]
814                                         set patch "$patch$ln"
815                                 }
816                         } elseif {$c1 ne {-} && $c1 ne {+}} {
817                                 # context line
818                                 set ln [$ui_diff get $i_l $next_l]
819                                 set patch "$patch$pre_context$ln"
820                                 # Skip the "\ No newline at end of
821                                 # file". Depending on the locale setting
822                                 # we don't know what this line looks
823                                 # like exactly. The only thing we do
824                                 # know is that it starts with "\ "
825                                 if {![string match {\\ *} $ln]} {
826                                         set n [expr $n+1]
827                                         set m [expr $m+1]
828                                 }
829                                 set pre_context {}
830                         } elseif {$c1 eq $to_context} {
831                                 # turn change line into context line
832                                 set ln [$ui_diff get "$i_l + 1 chars" $next_l]
833                                 if {$c1 eq {-}} {
834                                         set pre_context "$pre_context $ln"
835                                 } else {
836                                         set patch "$patch $ln"
837                                 }
838                                 set n [expr $n+1]
839                                 set m [expr $m+1]
840                         } else {
841                                 # a change in the opposite direction of
842                                 # to_context which is outside the range of
843                                 # lines to apply.
844                                 set patch "$patch$pre_context"
845                                 set pre_context {}
846                         }
847                         set i_l $next_l
848                 }
849                 set patch "$patch$pre_context"
850                 set wholepatch "$wholepatch@@ -$hln,$n +$hln,$m @@\n$patch"
851                 set first_l [$ui_diff index "$next_l + 1 lines"]
852         }
853
854         if {[catch {
855                 set enc [get_path_encoding $current_diff_path]
856                 set p [eval git_write $apply_cmd]
857                 fconfigure $p -translation binary -encoding $enc
858                 puts -nonewline $p $current_diff_header
859                 puts -nonewline $p $wholepatch
860                 close $p} err]} {
861                 error_popup "$failed_msg\n\n$err"
862                 unlock_index
863                 return
864         }
865
866         if {$revert} {
867                 # Save a copy of this patch for undoing reverts.
868                 set last_revert $current_diff_header$wholepatch
869                 set last_revert_enc $enc
870         }
871
872         unlock_index
873 }
874
875 # Undo the last line/hunk reverted. When hunks and lines are reverted, a copy
876 # of the diff applied is saved. Re-apply that diff to undo the revert.
877 #
878 # Right now, we only use a single variable to hold the copy, and not a
879 # stack/deque for simplicity, so multiple undos are not possible. Maybe this
880 # can be added if the need for something like this is felt in the future.
881 proc undo_last_revert {} {
882         global last_revert current_diff_path current_diff_header
883         global last_revert_enc
884
885         if {$last_revert eq {}} return
886         if {![lock_index apply_hunk]} return
887
888         set apply_cmd {apply --whitespace=nowarn}
889         set failed_msg [mc "Failed to undo last revert."]
890
891         if {[catch {
892                 set enc $last_revert_enc
893                 set p [eval git_write $apply_cmd]
894                 fconfigure $p -translation binary -encoding $enc
895                 puts -nonewline $p $last_revert
896                 close $p} err]} {
897                 error_popup "$failed_msg\n\n$err"
898                 unlock_index
899                 return
900         }
901
902         set last_revert {}
903
904         unlock_index
905 }