?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Second batch for 2.6
[alt-git.git] / git-gui / lib / diff.tcl
blob0d569862156d9e984f3c04f5662880148f92bc21
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
132 proc show_unmerged_diff {cont_info} {
133 global current_diff_path current_diff_side
134 global merge_stages ui_diff is_conflict_diff
135 global current_diff_queue
136
137 if {$merge_stages(2) eq {}} {
138 set is_conflict_diff 1
139 lappend current_diff_queue \
140 [list [mc "LOCAL: deleted\nREMOTE:\n"] d= \
141 [list ":1:$current_diff_path" ":3:$current_diff_path"]]
142 } elseif {$merge_stages(3) eq {}} {
143 set is_conflict_diff 1
144 lappend current_diff_queue \
145 [list [mc "REMOTE: deleted\nLOCAL:\n"] d= \
146 [list ":1:$current_diff_path" ":2:$current_diff_path"]]
147 } elseif {[lindex $merge_stages(1) 0] eq {120000}
148 || [lindex $merge_stages(2) 0] eq {120000}
149 || [lindex $merge_stages(3) 0] eq {120000}} {
150 set is_conflict_diff 1
151 lappend current_diff_queue \
152 [list [mc "LOCAL:\n"] d= \
153 [list ":1:$current_diff_path" ":2:$current_diff_path"]]
154 lappend current_diff_queue \
155 [list [mc "REMOTE:\n"] d= \
156 [list ":1:$current_diff_path" ":3:$current_diff_path"]]
157 } else {
158 start_show_diff $cont_info
159 return
160 }
161
162 advance_diff_queue $cont_info
163 }
164
165 proc advance_diff_queue {cont_info} {
166 global current_diff_queue ui_diff
167
168 set item [lindex $current_diff_queue 0]
169 set current_diff_queue [lrange $current_diff_queue 1 end]
170
171 $ui_diff conf -state normal
172 $ui_diff insert end [lindex $item 0] [lindex $item 1]
173 $ui_diff conf -state disabled
174
175 start_show_diff $cont_info [lindex $item 2]
176 }
177
178 proc show_other_diff {path w m cont_info} {
179 global file_states file_lists
180 global is_3way_diff diff_active repo_config
181 global ui_diff ui_index ui_workdir
182 global current_diff_path current_diff_side current_diff_header
183
184 # - Git won't give us the diff, there's nothing to compare to!
185 #
186 if {$m eq {_O}} {
187 set max_sz 100000
188 set type unknown
189 if {[catch {
190 set type [file type $path]
191 switch -- $type {
192 directory {
193 set type submodule
194 set content {}
195 set sz 0
196 }
197 link {
198 set content [file readlink $path]
199 set sz [string length $content]
200 }
201 file {
202 set fd [open $path r]
203 fconfigure $fd \
204 -eofchar {} \
205 -encoding [get_path_encoding $path]
206 set content [read $fd $max_sz]
207 close $fd
208 set sz [file size $path]
209 }
210 default {
211 error "'$type' not supported"
212 }
213 }
214 } err ]} {
215 set diff_active 0
216 unlock_index
217 ui_status [mc "Unable to display %s" [escape_path $path]]
218 error_popup [strcat [mc "Error loading file:"] "\n\n$err"]
219 return
220 }
221 $ui_diff conf -state normal
222 if {$type eq {submodule}} {
223 $ui_diff insert end [append \
224 "* " \
225 [mc "Git Repository (subproject)"] \
226 "\n"] d_info
227 } elseif {![catch {set type [exec file $path]}]} {
228 set n [string length $path]
229 if {[string equal -length $n $path $type]} {
230 set type [string range $type $n end]
231 regsub {^:?\s*} $type {} type
232 }
233 $ui_diff insert end "* $type\n" d_info
234 }
235 if {[string first "\0" $content] != -1} {
236 $ui_diff insert end \
237 [mc "* Binary file (not showing content)."] \
238 d_info
239 } else {
240 if {$sz > $max_sz} {
241 $ui_diff insert end [mc \
242 "* Untracked file is %d bytes.
243 * Showing only first %d bytes.
244 " $sz $max_sz] d_info
245 }
246 $ui_diff insert end $content
247 if {$sz > $max_sz} {
248 $ui_diff insert end [mc "
249 * Untracked file clipped here by %s.
250 * To see the entire file, use an external editor.
251 " [appname]] d_info
252 }
253 }
254 $ui_diff conf -state disabled
255 set diff_active 0
256 unlock_index
257 set scroll_pos [lindex $cont_info 0]
258 if {$scroll_pos ne {}} {
259 update
260 $ui_diff yview moveto $scroll_pos
261 }
262 ui_ready
263 set callback [lindex $cont_info 1]
264 if {$callback ne {}} {
265 eval $callback
266 }
267 return
268 }
269 }
270
271 proc get_conflict_marker_size {path} {
272 set size 7
273 catch {
274 set fd_rc [eval [list git_read check-attr "conflict-marker-size" -- $path]]
275 set ret [gets $fd_rc line]
276 close $fd_rc
277 if {$ret > 0} {
278 regexp {.*: conflict-marker-size: (\d+)$} $line line size
279 }
280 }
281 return $size
282 }
283
284 proc start_show_diff {cont_info {add_opts {}}} {
285 global file_states file_lists
286 global is_3way_diff is_submodule_diff diff_active repo_config
287 global ui_diff ui_index ui_workdir
288 global current_diff_path current_diff_side current_diff_header
289
290 set path $current_diff_path
291 set w $current_diff_side
292
293 set s $file_states($path)
294 set m [lindex $s 0]
295 set is_3way_diff 0
296 set is_submodule_diff 0
297 set diff_active 1
298 set current_diff_header {}
299 set conflict_size [get_conflict_marker_size $path]
300
301 set cmd [list]
302 if {$w eq $ui_index} {
303 lappend cmd diff-index
304 lappend cmd --cached
305 if {[git-version >= "1.7.2"]} {
306 lappend cmd --ignore-submodules=dirty
307 }
308 } elseif {$w eq $ui_workdir} {
309 if {[string first {U} $m] >= 0} {
310 lappend cmd diff
311 } else {
312 lappend cmd diff-files
313 }
314 }
315 if {![is_config_false gui.textconv] && [git-version >= 1.6.1]} {
316 lappend cmd --textconv
317 }
318
319 if {[string match {160000 *} [lindex $s 2]]
320 || [string match {160000 *} [lindex $s 3]]} {
321 set is_submodule_diff 1
322
323 if {[git-version >= "1.6.6"]} {
324 lappend cmd --submodule
325 }
326 }
327
328 lappend cmd -p
329 lappend cmd --color
330 set cmd [concat $cmd $repo_config(gui.diffopts)]
331 if {$repo_config(gui.diffcontext) >= 1} {
332 lappend cmd "-U$repo_config(gui.diffcontext)"
333 }
334 if {$w eq $ui_index} {
335 lappend cmd [PARENT]
336 }
337 if {$add_opts ne {}} {
338 eval lappend cmd $add_opts
339 } else {
340 lappend cmd --
341 lappend cmd $path
342 }
343
344 if {$is_submodule_diff && [git-version < "1.6.6"]} {
345 if {$w eq $ui_index} {
346 set cmd [list submodule summary --cached -- $path]
347 } else {
348 set cmd [list submodule summary --files -- $path]
349 }
350 }
351
352 if {[catch {set fd [eval git_read --nice $cmd]} err]} {
353 set diff_active 0
354 unlock_index
355 ui_status [mc "Unable to display %s" [escape_path $path]]
356 error_popup [strcat [mc "Error loading diff:"] "\n\n$err"]
357 return
358 }
359
360 set ::current_diff_inheader 1
361 fconfigure $fd \
362 -blocking 0 \
363 -encoding [get_path_encoding $path] \
364 -translation lf
365 fileevent $fd readable [list read_diff $fd $conflict_size $cont_info]
366 }
367
368 proc parse_color_line {line} {
369 set start 0
370 set result ""
371 set markup [list]
372 set regexp {\033\[((?:\d+;)*\d+)?m}
373 set need_reset 0
374 while {[regexp -indices -start $start $regexp $line match code]} {
375 foreach {begin end} $match break
376 append result [string range $line $start [expr {$begin - 1}]]
377 set pos [string length $result]
378 set col [eval [linsert $code 0 string range $line]]
379 set start [incr end]
380 if {$col eq "0" || $col eq ""} {
381 if {!$need_reset} continue
382 set need_reset 0
383 } else {
384 set need_reset 1
385 }
386 lappend markup $pos $col
387 }
388 append result [string range $line $start end]
389 if {[llength $markup] < 4} {set markup {}}
390 return [list $result $markup]
391 }
392
393 proc read_diff {fd conflict_size cont_info} {
394 global ui_diff diff_active is_submodule_diff
395 global is_3way_diff is_conflict_diff current_diff_header
396 global current_diff_queue
397 global diff_empty_count
398
399 $ui_diff conf -state normal
400 while {[gets $fd line] >= 0} {
401 foreach {line markup} [parse_color_line $line] break
402 set line [string map {\033 ^} $line]
403
404 set tags {}
405
406 # -- Check for start of diff header.
407 if { [string match {diff --git *} $line]
408 || [string match {diff --cc *} $line]
409 || [string match {diff --combined *} $line]} {
410 set ::current_diff_inheader 1
411 }
412
413 # -- Check for end of diff header (any hunk line will do this).
414 #
415 if {[regexp {^@@+ } $line]} {set ::current_diff_inheader 0}
416
417 # -- Automatically detect if this is a 3 way diff.
418 #
419 if {[string match {@@@ *} $line]} {
420 set is_3way_diff 1
421 apply_tab_size 1
422 }
423
424 if {$::current_diff_inheader} {
425
426 # -- These two lines stop a diff header and shouldn't be in there
427 if { [string match {Binary files * and * differ} $line]
428 || [regexp {^\* Unmerged path } $line]} {
429 set ::current_diff_inheader 0
430 } else {
431 append current_diff_header $line "\n"
432 }
433
434 # -- Cleanup uninteresting diff header lines.
435 #
436 if { [string match {diff --git *} $line]
437 || [string match {diff --cc *} $line]
438 || [string match {diff --combined *} $line]
439 || [string match {--- *} $line]
440 || [string match {+++ *} $line]
441 || [string match {index *} $line]} {
442 continue
443 }
444
445 # -- Name it symlink, not 120000
446 # Note, that the original line is in $current_diff_header
447 regsub {^(deleted|new) file mode 120000} $line {\1 symlink} line
448
449 } elseif { $line eq {\ No newline at end of file}} {
450 # -- Handle some special lines
451 } elseif {$is_3way_diff} {
452 set op [string range $line 0 1]
453 switch -- $op {
454 { } {set tags {}}
455 {@@} {set tags d_@}
456 { +} {set tags d_s+}
457 { -} {set tags d_s-}
458 {+ } {set tags d_+s}
459 {- } {set tags d_-s}
460 {--} {set tags d_--}
461 {++} {
462 set regexp [string map [list %conflict_size $conflict_size]\
463 {^\+\+([<>=]){%conflict_size}(?: |$)}]
464 if {[regexp $regexp $line _g op]} {
465 set is_conflict_diff 1
466 set line [string replace $line 0 1 { }]
467 set tags d$op
468 } else {
469 set tags d_++
470 }
471 }
472 default {
473 puts "error: Unhandled 3 way diff marker: {$op}"
474 set tags {}
475 }
476 }
477 } elseif {$is_submodule_diff} {
478 if {$line == ""} continue
479 if {[regexp {^Submodule } $line]} {
480 set tags d_info
481 } elseif {[regexp {^\* } $line]} {
482 set line [string replace $line 0 1 {Submodule }]
483 set tags d_info
484 } else {
485 set op [string range $line 0 2]
486 switch -- $op {
487 { <} {set tags d_-}
488 { >} {set tags d_+}
489 { W} {set tags {}}
490 default {
491 puts "error: Unhandled submodule diff marker: {$op}"
492 set tags {}
493 }
494 }
495 }
496 } else {
497 set op [string index $line 0]
498 switch -- $op {
499 { } {set tags {}}
500 {@} {set tags d_@}
501 {-} {set tags d_-}
502 {+} {
503 set regexp [string map [list %conflict_size $conflict_size]\
504 {^\+([<>=]){%conflict_size}(?: |$)}]
505 if {[regexp $regexp $line _g op]} {
506 set is_conflict_diff 1
507 set tags d$op
508 } else {
509 set tags d_+
510 }
511 }
512 default {
513 puts "error: Unhandled 2 way diff marker: {$op}"
514 set tags {}
515 }
516 }
517 }
518 set mark [$ui_diff index "end - 1 line linestart"]
519 $ui_diff insert end $line $tags
520 if {[string index $line end] eq "\r"} {
521 $ui_diff tag add d_cr {end - 2c}
522 }
523 $ui_diff insert end "\n" $tags
524
525 foreach {posbegin colbegin posend colend} $markup {
526 set prefix clr
527 foreach style [lsort -integer [split $colbegin ";"]] {
528 if {$style eq "7"} {append prefix i; continue}
529 if {$style != 4 && ($style < 30 || $style > 47)} {continue}
530 set a "$mark linestart + $posbegin chars"
531 set b "$mark linestart + $posend chars"
532 catch {$ui_diff tag add $prefix$style $a $b}
533 }
534 }
535 }
536 $ui_diff conf -state disabled
537
538 if {[eof $fd]} {
539 close $fd
540
541 if {$current_diff_queue ne {}} {
542 advance_diff_queue $cont_info
543 return
544 }
545
546 set diff_active 0
547 unlock_index
548 set scroll_pos [lindex $cont_info 0]
549 if {$scroll_pos ne {}} {
550 update
551 $ui_diff yview moveto $scroll_pos
552 }
553 ui_ready
554
555 if {[$ui_diff index end] eq {2.0}} {
556 handle_empty_diff
557 } else {
558 set diff_empty_count 0
559 }
560
561 set callback [lindex $cont_info 1]
562 if {$callback ne {}} {
563 eval $callback
564 }
565 }
566 }
567
568 proc apply_hunk {x y} {
569 global current_diff_path current_diff_header current_diff_side
570 global ui_diff ui_index file_states
571
572 if {$current_diff_path eq {} || $current_diff_header eq {}} return
573 if {![lock_index apply_hunk]} return
574
575 set apply_cmd {apply --cached --whitespace=nowarn}
576 set mi [lindex $file_states($current_diff_path) 0]
577 if {$current_diff_side eq $ui_index} {
578 set failed_msg [mc "Failed to unstage selected hunk."]
579 lappend apply_cmd --reverse
580 if {[string index $mi 0] ne {M}} {
581 unlock_index
582 return
583 }
584 } else {
585 set failed_msg [mc "Failed to stage selected hunk."]
586 if {[string index $mi 1] ne {M}} {
587 unlock_index
588 return
589 }
590 }
591
592 set s_lno [lindex [split [$ui_diff index @$x,$y] .] 0]
593 set s_lno [$ui_diff search -backwards -regexp ^@@ $s_lno.0 0.0]
594 if {$s_lno eq {}} {
595 unlock_index
596 return
597 }
598
599 set e_lno [$ui_diff search -forwards -regexp ^@@ "$s_lno + 1 lines" end]
600 if {$e_lno eq {}} {
601 set e_lno end
602 }
603
604 if {[catch {
605 set enc [get_path_encoding $current_diff_path]
606 set p [eval git_write $apply_cmd]
607 fconfigure $p -translation binary -encoding $enc
608 puts -nonewline $p $current_diff_header
609 puts -nonewline $p [$ui_diff get $s_lno $e_lno]
610 close $p} err]} {
611 error_popup [append $failed_msg "\n\n$err"]
612 unlock_index
613 return
614 }
615
616 $ui_diff conf -state normal
617 $ui_diff delete $s_lno $e_lno
618 $ui_diff conf -state disabled
619
620 if {[$ui_diff get 1.0 end] eq "\n"} {
621 set o _
622 } else {
623 set o ?
624 }
625
626 if {$current_diff_side eq $ui_index} {
627 set mi ${o}M
628 } elseif {[string index $mi 0] eq {_}} {
629 set mi M$o
630 } else {
631 set mi ?$o
632 }
633 unlock_index
634 display_file $current_diff_path $mi
635 # This should trigger shift to the next changed file
636 if {$o eq {_}} {
637 reshow_diff
638 }
639 }
640
641 proc apply_range_or_line {x y} {
642 global current_diff_path current_diff_header current_diff_side
643 global ui_diff ui_index file_states
644
645 set selected [$ui_diff tag nextrange sel 0.0]
646
647 if {$selected == {}} {
648 set first [$ui_diff index "@$x,$y"]
649 set last $first
650 } else {
651 set first [lindex $selected 0]
652 set last [lindex $selected 1]
653 }
654
655 set first_l [$ui_diff index "$first linestart"]
656 set last_l [$ui_diff index "$last lineend"]
657
658 if {$current_diff_path eq {} || $current_diff_header eq {}} return
659 if {![lock_index apply_hunk]} return
660
661 set apply_cmd {apply --cached --whitespace=nowarn}
662 set mi [lindex $file_states($current_diff_path) 0]
663 if {$current_diff_side eq $ui_index} {
664 set failed_msg [mc "Failed to unstage selected line."]
665 set to_context {+}
666 lappend apply_cmd --reverse
667 if {[string index $mi 0] ne {M}} {
668 unlock_index
669 return
670 }
671 } else {
672 set failed_msg [mc "Failed to stage selected line."]
673 set to_context {-}
674 if {[string index $mi 1] ne {M}} {
675 unlock_index
676 return
677 }
678 }
679
680 set wholepatch {}
681
682 while {$first_l < $last_l} {
683 set i_l [$ui_diff search -backwards -regexp ^@@ $first_l 0.0]
684 if {$i_l eq {}} {
685 # If there's not a @@ above, then the selected range
686 # must have come before the first_l @@
687 set i_l [$ui_diff search -regexp ^@@ $first_l $last_l]
688 }
689 if {$i_l eq {}} {
690 unlock_index
691 return
692 }
693 # $i_l is now at the beginning of a line
694
695 # pick start line number from hunk header
696 set hh [$ui_diff get $i_l "$i_l + 1 lines"]
697 set hh [lindex [split $hh ,] 0]
698 set hln [lindex [split $hh -] 1]
699
700 # There is a special situation to take care of. Consider this
701 # hunk:
702 #
703 # @@ -10,4 +10,4 @@
704 # context before
705 # -old 1
706 # -old 2
707 # +new 1
708 # +new 2
709 # context after
710 #
711 # We used to keep the context lines in the order they appear in
712 # the hunk. But then it is not possible to correctly stage only
713 # "-old 1" and "+new 1" - it would result in this staged text:
714 #
715 # context before
716 # old 2
717 # new 1
718 # context after
719 #
720 # (By symmetry it is not possible to *un*stage "old 2" and "new
721 # 2".)
722 #
723 # We resolve the problem by introducing an asymmetry, namely,
724 # when a "+" line is *staged*, it is moved in front of the
725 # context lines that are generated from the "-" lines that are
726 # immediately before the "+" block. That is, we construct this
727 # patch:
728 #
729 # @@ -10,4 +10,5 @@
730 # context before
731 # +new 1
732 # old 1
733 # old 2
734 # context after
735 #
736 # But we do *not* treat "-" lines that are *un*staged in a
737 # special way.
738 #
739 # With this asymmetry it is possible to stage the change "old
740 # 1" -> "new 1" directly, and to stage the change "old 2" ->
741 # "new 2" by first staging the entire hunk and then unstaging
742 # the change "old 1" -> "new 1".
743 #
744 # Applying multiple lines adds complexity to the special
745 # situation. The pre_context must be moved after the entire
746 # first block of consecutive staged "+" lines, so that
747 # staging both additions gives the following patch:
748 #
749 # @@ -10,4 +10,6 @@
750 # context before
751 # +new 1
752 # +new 2
753 # old 1
754 # old 2
755 # context after
756
757 # This is non-empty if and only if we are _staging_ changes;
758 # then it accumulates the consecutive "-" lines (after
759 # converting them to context lines) in order to be moved after
760 # "+" change lines.
761 set pre_context {}
762
763 set n 0
764 set m 0
765 set i_l [$ui_diff index "$i_l + 1 lines"]
766 set patch {}
767 while {[$ui_diff compare $i_l < "end - 1 chars"] &&
768 [$ui_diff get $i_l "$i_l + 2 chars"] ne {@@}} {
769 set next_l [$ui_diff index "$i_l + 1 lines"]
770 set c1 [$ui_diff get $i_l]
771 if {[$ui_diff compare $first_l <= $i_l] &&
772 [$ui_diff compare $i_l < $last_l] &&
773 ($c1 eq {-} || $c1 eq {+})} {
774 # a line to stage/unstage
775 set ln [$ui_diff get $i_l $next_l]
776 if {$c1 eq {-}} {
777 set n [expr $n+1]
778 set patch "$patch$pre_context$ln"
779 set pre_context {}
780 } else {
781 set m [expr $m+1]
782 set patch "$patch$ln"
783 }
784 } elseif {$c1 ne {-} && $c1 ne {+}} {
785 # context line
786 set ln [$ui_diff get $i_l $next_l]
787 set patch "$patch$pre_context$ln"
788 # Skip the "\ No newline at end of
789 # file". Depending on the locale setting
790 # we don't know what this line looks
791 # like exactly. The only thing we do
792 # know is that it starts with "\ "
793 if {![string match {\\ *} $ln]} {
794 set n [expr $n+1]
795 set m [expr $m+1]
796 }
797 set pre_context {}
798 } elseif {$c1 eq $to_context} {
799 # turn change line into context line
800 set ln [$ui_diff get "$i_l + 1 chars" $next_l]
801 if {$c1 eq {-}} {
802 set pre_context "$pre_context $ln"
803 } else {
804 set patch "$patch $ln"
805 }
806 set n [expr $n+1]
807 set m [expr $m+1]
808 } else {
809 # a change in the opposite direction of
810 # to_context which is outside the range of
811 # lines to apply.
812 set patch "$patch$pre_context"
813 set pre_context {}
814 }
815 set i_l $next_l
816 }
817 set patch "$patch$pre_context"
818 set wholepatch "$wholepatch@@ -$hln,$n +$hln,$m @@\n$patch"
819 set first_l [$ui_diff index "$next_l + 1 lines"]
820 }
821
822 if {[catch {
823 set enc [get_path_encoding $current_diff_path]
824 set p [eval git_write $apply_cmd]
825 fconfigure $p -translation binary -encoding $enc
826 puts -nonewline $p $current_diff_header
827 puts -nonewline $p $wholepatch
828 close $p} err]} {
829 error_popup [append $failed_msg "\n\n$err"]
830 }
831
832 unlock_index
833 }
Alternate source for your git.git needs