?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add heuristic to take shortcut when too slow.
[wiggle/upstream.git] / vpatch.c
blob1e267119e2b311b73f3bb5569e3de3ff5f6323e1
1 /*
2 * wiggle - apply rejected patches
3 *
4 * Copyright (C) 2005 Neil Brown <neilb@cse.unsw.edu.au>
5 * Copyright (C) 2010-2013 Neil Brown <neilb@suse.de>
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program.
20 *
21 * Author: Neil Brown
22 * Email: <neilb@suse.de>
23 */
24
25 /*
26 * vpatch - visual front end for wiggle - aka Browse mode.
27 *
28 * "files" display, lists all files with statistics
29 * - can hide various lines including subdirectories
30 * and files without wiggles or conflicts
31 * "merge" display shows various views of merged file with different
32 * parts in different colours.
33 *
34 * The window can be split horizontally to show the original and result
35 * beside the diff, and each different branch can be shown alone.
36 *
37 */
38
39 #include "wiggle.h"
40 #include <curses.h>
41 #include <unistd.h>
42 #include <stdlib.h>
43 #include <signal.h>
44 #include <fcntl.h>
45 #include <ctype.h>
46 #include <sys/wait.h>
47
48 static void term_init(int raw);
49
50 static int intr_kills = 0;
51
52 /* global attributes */
53 unsigned int a_delete, a_added, a_common, a_sep, a_void,
54 a_unmatched, a_extra, a_already;
55 unsigned int a_has_conflicts, a_has_wiggles, a_no_wiggles, a_saved;
56
57 /******************************************************************
58 * Help window
59 * We display help in an insert, leaving 5 columns left and right,
60 * and 2 rows top and bottom, but at most 58x15 plus border
61 * In help mode:
62 * SPC or RTN moves down or to next page
63 * BKSPC goes backwards
64 * 'q' returns to origin screen
65 * '?' show help on help
66 * left and right scroll help view
67 *
68 * A help text is an array of lines of text
69 */
70
71 char *help_help[] = {
72 " You are viewing the help page for the help viewer.",
73 "You normally get here by typing '?'",
74 "",
75 "The following keystrokes work in the help viewer:",
76 " ? display this help message",
77 " q return to previous view",
78 " SPC move forward through help document",
79 " RTN same as SPC",
80 " BKSP move backward through help document",
81 " RIGHT scroll help window so text on the right appears",
82 " LEFT scroll help window so text on the left appears",
83 NULL
84 };
85
86 char *help_missing[] = {
87 "The file that this patch applies to appears",
88 "to be missing.",
89 "Please type 'q' to continue",
90 NULL
91 };
92
93 char *help_corrupt[] = {
94 "This patch appears to be corrupt",
95 "Please type 'q' to continue",
96 NULL
97 };
98
99 /* We can give one or two pages to display in the help window.
100 * The first is specific to the current context. The second
101 * is optional and may provide help in a more broad context.
102 */
103 static int help_window(char *page1[], char *page2[], int query)
104 {
105 int rows, cols;
106 int top, left;
107 int r, c;
108 int ch;
109 char **page = page1;
110 int line = 0;
111 int shift = 0;
112
113 getmaxyx(stdscr, rows, cols);
114
115 if (cols < 70) {
116 left = 6;
117 cols = cols-12;
118 } else {
119 left = (cols-58)/2 - 1;
120 cols = 58;
121 }
122
123 if (rows < 21) {
124 top = 3;
125 rows = rows - 6;
126 } else {
127 top = (rows-15)/2 - 1;
128 rows = 15;
129 }
130
131 /* Draw a border around the 'help' area */
132 (void)attrset(A_STANDOUT);
133 for (c = left; c < left+cols; c++) {
134 mvaddch(top-1, c, '-');
135 mvaddch(top+rows, c, '-');
136 }
137 for (r = top; r < top + rows ; r++) {
138 mvaddch(r, left-1, '|');
139 mvaddch(r, left+cols, '|');
140 }
141 mvaddch(top-1, left-1, '/');
142 mvaddch(top-1, left+cols, '\\');
143 mvaddch(top+rows, left-1, '\\');
144 mvaddch(top+rows, left+cols, '/');
145 if (query) {
146 mvaddstr(top-1, left + cols/2 - 4, "Question");
147 mvaddstr(top+rows, left + cols/2 - 9,
148 "Answer Y, N, or Q.");
149 } else {
150 mvaddstr(top-1, left + cols/2 - 9,
151 "HELP - 'q' to exit");
152 mvaddstr(top+rows, left+cols/2 - 17,
153 "Press SPACE for more, '?' for help");
154 }
155 (void)attrset(A_NORMAL);
156
157 while (1) {
158 char **lnp = page + line;
159
160 /* Draw as much of the page at the current offset
161 * as fits.
162 */
163 for (r = 0; r < rows; r++) {
164 char *ln = *lnp;
165 int sh = shift;
166 if (ln)
167 lnp++;
168 else
169 ln = "";
170
171 while (*ln && sh > 0) {
172 ln++;
173 sh--;
174 }
175 for (c = 0; c < cols; c++) {
176 int chr = *ln;
177 if (chr)
178 ln++;
179 else
180 chr = ' ';
181 mvaddch(top+r, left+c, chr);
182 }
183 }
184 move(top+rows-1, left);
185 ch = getch();
186
187 switch (ch) {
188 case 'C' - 64:
189 case 'Q':
190 case 'q':
191 return -1;
192 break;
193 case 'Y':
194 case 'y':
195 if (query)
196 return 1;
197 break;
198 case 'N':
199 case 'n':
200 if (query)
201 return 0;
202 break;
203
204 case '?':
205 if (page1 != help_help)
206 help_window(help_help, NULL, 0);
207 break;
208 case ' ':
209 case '\r': /* page-down */
210 for (r = 0; r < rows-2; r++)
211 if (page[line])
212 line++;
213 if (!page[line] && !query) {
214 line = 0;
215 if (page == page1)
216 page = page2;
217 else
218 page = NULL;
219 if (page == NULL)
220 return -1;
221 }
222 break;
223
224 case '\b': /* page up */
225 if (line > 0) {
226 line -= (rows-2);
227 if (line < 0)
228 line = 0;
229 } else {
230 if (page == page2)
231 page = page1;
232 else
233 page = page2;
234 if (page == NULL)
235 page = page1;
236 line = 0;
237 }
238 break;
239
240 case KEY_LEFT:
241 if (shift > 0)
242 shift--;
243 break;
244 case KEY_RIGHT:
245 shift++;
246 break;
247
248 case KEY_UP:
249 if (line > 0)
250 line--;
251 break;
252 case KEY_DOWN:
253 if (page[line])
254 line++;
255 break;
256 }
257 }
258 }
259
260 static char *typenames[] = {
261 [End] = "End",
262 [Unmatched] = "Unmatched",
263 [Unchanged] = "Unchanged",
264 [Extraneous] = "Extraneous",
265 [Changed] = "Changed",
266 [Conflict] = "Conflict",
267 [AlreadyApplied] = "AlreadyApplied",
268 };
269
270 /* When we merge the original and the diff together we need
271 * to keep track of where everything came from.
272 * When we display the different views, we need to be able to
273 * select certain portions of the whole document.
274 * These flags are used to identify what is present, and to
275 * request different parts be extracted. They also help
276 * guide choice of colour.
277 */
278 #define BEFORE 1
279 #define AFTER 2
280 #define ORIG 4
281 #define RESULT 8
282 #define CHANGES 16 /* A change is visible here,
283 * so 2 streams need to be shown */
284 #define WIGGLED 32 /* a conflict that was successfully resolved */
285 #define CONFLICTED 64 /* a conflict that was not successfully resolved */
286
287 /* Displaying a Merge.
288 * The first step is to linearise the merge. The merge in inherently
289 * parallel with before/after streams. However much of the whole document
290 * is linear as normally much of the original in unchanged.
291 * All parallelism comes from the patch. This normally produces two
292 * parallel stream, but in the case of a conflict can produce three.
293 * For browsing the merge we only ever show two alternates in-line.
294 * When there are three we use two panes with 1 or 2 alternates in each.
295 * So to linearise the two streams we find lines that are completely
296 * unchanged (same for all 3 streams, or missing in 2nd and 3rd) which bound
297 * a region where there are changes. We include everything between
298 * these twice, in two separate passes. The exact interpretation of the
299 * passes is handled at a higher level but will be one of:
300 * original and result
301 * before and after
302 * original and after (for a conflict)
303 * This is all encoded in the 'struct merge'. An array of these describes
304 * the whole document.
305 *
306 * At any position in the merge we can be in one of 3 states:
307 * 0: unchanged section
308 * 1: first pass
309 * 2: second pass
310 *
311 * So to walk a merge in display order we need a position in the merge,
312 * a current state, and when in a changed section, we need to know the
313 * bounds of that changed section.
314 * This is all encoded in 'struct mpos'.
315 *
316 * Each location may or may not be visible depending on certain
317 * display options.
318 *
319 * Also, some locations might be 'invalid' in that they don't need to be displayed.
320 * For example when the patch leaves a section of the original unchanged,
321 * we only need to see the original - the before/after sections are treated
322 * as invalid and are not displayed.
323 * The visibility of newlines is crucial and guides the display. One line
324 * of displayed text is all the visible sections between two visible newlines.
325 *
326 * Counting lines is a bit tricky. We only worry about line numbers in the
327 * original (stream 0) as these could compare with line numbers mentioned in
328 * patch chunks.
329 * We count 2 for every line: 1 for everything before the newline and 1 for the newline.
330 * That way we don't get a full counted line until we see the first char after the
331 * newline, so '+' lines are counted with the previous line.
332 *
333 */
334 struct mp {
335 int m; /* merger index */
336 int s; /* stream 0,1,2 for a,b,c */
337 int o; /* offset in that stream */
338 int lineno; /* Counts newlines in stream 0
339 * set lsb when see newline.
340 * add one when not newline and lsb set
341 */
342 };
343 struct mpos {
344 struct mp p, /* the current point (end of a line) */
345 lo, /* eol for start of the current group */
346 hi; /* eol for end of the current group */
347 int state; /*
348 * 0 if on an unchanged (lo/hi not meaningful)
349 * 1 if on the '-' of a diff,
350 * 2 if on the '+' of a diff
351 */
352 };
353
354 struct cursor {
355 struct mp pos; /* where in the document we are (an element) */
356 int offset; /* which char in that element */
357 int target; /* display column - or -1 if we are looking for 'pos' */
358 int col; /* where we found pos or target */
359 int width; /* Size of char, for moving to the right */
360 int alt; /* Cursor is in alternate window */
361 };
362
363 /* used for checking location during search */
364 static int same_mp(struct mp a, struct mp b)
365 {
366 return a.m == b.m &&
367 a.s == b.s &&
368 a.o == b.o;
369 }
370 static int same_mpos(struct mpos a, struct mpos b)
371 {
372 return same_mp(a.p, b.p) &&
373 (a.state == b.state || a.state == 0 || b.state == 0);
374 }
375
376 /* Check if a particular stream is meaningful in a particular merge
377 * section. e.g. in an Unchanged section, only stream 0, the
378 * original, is meaningful. This is used to avoid walking down
379 * pointless paths.
380 */
381 static int stream_valid(int s, enum mergetype type)
382 {
383 switch (type) {
384 case End:
385 return 1;
386 case Unmatched:
387 return s == 0;
388 case Unchanged:
389 return s == 0;
390 case Extraneous:
391 return s == 2;
392 case Changed:
393 return s != 1;
394 case Conflict:
395 return 1;
396 case AlreadyApplied:
397 return 1;
398 }
399 return 0;
400 }
401
402 /*
403 * Advance the 'pos' in the current mergepos returning the next
404 * element (word).
405 * This walks the merges in sequence, and the streams within
406 * each merge.
407 */
408 static struct elmnt next_melmnt(struct mp *pos,
409 struct file fm, struct file fb, struct file fa,
410 struct merge *m)
411 {
412 pos->o++;
413 while (pos->m < 0 || m[pos->m].type != End) {
414 int l = 0; /* Length remaining in current merge section */
415 if (pos->m >= 0)
416 switch (pos->s) {
417 case 0:
418 l = m[pos->m].al;
419 break;
420 case 1:
421 l = m[pos->m].bl;
422 break;
423 case 2:
424 l = m[pos->m].cl;
425 break;
426 }
427 if (pos->o >= l) {
428 /* Offset has reached length, choose new stream or
429 * new merge */
430 pos->o = 0;
431 do {
432 pos->s++;
433 if (pos->s > 2) {
434 pos->s = 0;
435 pos->m++;
436 }
437 } while (!stream_valid(pos->s, m[pos->m].oldtype));
438 } else
439 break;
440 }
441 if (pos->m == -1 || m[pos->m].type == End) {
442 struct elmnt e;
443 e.start = NULL; e.hash = 0; e.len = 0;
444 return e;
445 }
446 switch (pos->s) {
447 default: /* keep compiler happy */
448 case 0:
449 if (pos->lineno & 1)
450 pos->lineno++;
451 if (ends_line(fm.list[m[pos->m].a + pos->o]))
452 pos->lineno++;
453 return fm.list[m[pos->m].a + pos->o];
454 case 1: return fb.list[m[pos->m].b + pos->o];
455 case 2: return fa.list[m[pos->m].c + pos->o];
456 }
457 }
458
459 /* step current position.p backwards */
460 static struct elmnt prev_melmnt(struct mp *pos,
461 struct file fm, struct file fb, struct file fa,
462 struct merge *m)
463 {
464 if (pos->s == 0) {
465 if (m[pos->m].a + pos->o < fm.elcnt &&
466 ends_line(fm.list[m[pos->m].a + pos->o]))
467 pos->lineno--;
468 if (pos->lineno & 1)
469 pos->lineno--;
470 }
471
472 pos->o--;
473 while (pos->m >= 0 && pos->o < 0) {
474 do {
475 pos->s--;
476 if (pos->s < 0) {
477 pos->s = 2;
478 pos->m--;
479 }
480 } while (pos->m >= 0 &&
481 !stream_valid(pos->s, m[pos->m].oldtype));
482 if (pos->m >= 0) {
483 switch (pos->s) {
484 case 0:
485 pos->o = m[pos->m].al-1;
486 break;
487 case 1:
488 pos->o = m[pos->m].bl-1;
489 break;
490 case 2:
491 pos->o = m[pos->m].cl-1;
492 break;
493 }
494 }
495 }
496 if (pos->m < 0 || m[pos->m].type == End) {
497 struct elmnt e;
498 e.start = NULL; e.hash = 0; e.len = 0;
499 return e;
500 }
501 switch (pos->s) {
502 default: /* keep compiler happy */
503 case 0: return fm.list[m[pos->m].a + pos->o];
504 case 1: return fb.list[m[pos->m].b + pos->o];
505 case 2: return fa.list[m[pos->m].c + pos->o];
506 }
507 }
508
509 /* 'visible' not only checks if this stream in this merge should be
510 * visible in this mode, but also chooses which colour/highlight to use
511 * to display it.
512 */
513 static int visible(int mode, struct merge *m, struct mpos *pos)
514 {
515 enum mergetype type;
516 int stream = pos->p.s;
517
518 if (mode == 0)
519 return -1;
520 if (pos->p.m < 0)
521 type = End;
522 else if (mode & RESULT)
523 type = m[pos->p.m].type;
524 else
525 type = m[pos->p.m].oldtype;
526 /* mode can be any combination of ORIG RESULT BEFORE AFTER */
527 switch (type) {
528 case End: /* The END is always visible */
529 return A_NORMAL;
530 case Unmatched: /* Visible in ORIG and RESULT */
531 if (mode & (ORIG|RESULT))
532 return a_unmatched;
533 break;
534 case Unchanged: /* visible everywhere, but only show stream 0 */
535 if (stream == 0)
536 return a_common;
537 break;
538 case Extraneous: /* stream 2 is visible in BEFORE and AFTER */
539 if ((mode & (BEFORE|AFTER))
540 && stream == 2)
541 return a_extra;
542 break;
543 case Changed: /* stream zero visible ORIG and BEFORE, stream 2 elsewhere */
544 if (stream == 0 &&
545 (mode & (ORIG|BEFORE)))
546 return a_delete;
547 if (stream == 2 &&
548 (mode & (RESULT|AFTER)))
549 return a_added;
550 break;
551 case Conflict:
552 switch (stream) {
553 case 0:
554 if (mode & ORIG)
555 return a_unmatched | A_REVERSE;
556 break;
557 case 1:
558 if (mode & BEFORE)
559 return a_extra | A_UNDERLINE;
560 break;
561 case 2:
562 if (mode & (AFTER|RESULT))
563 return a_added | A_UNDERLINE;
564 break;
565 }
566 break;
567 case AlreadyApplied:
568 switch (stream) {
569 case 0:
570 if (mode & (ORIG|RESULT))
571 return a_already;
572 break;
573 case 1:
574 if (mode & BEFORE)
575 return a_delete | A_UNDERLINE;
576 break;
577 case 2:
578 if (mode & AFTER)
579 return a_added | A_UNDERLINE;
580 break;
581 }
582 break;
583 }
584 return -1;
585 }
586
587 /* checkline creates a summary of the sort of changes that
588 * are in a line, returning an "or" of
589 * CHANGES
590 * WIGGLED
591 * CONFLICTED
592 */
593 static int check_line(struct mpos pos, struct file fm, struct file fb,
594 struct file fa,
595 struct merge *m, int mode)
596 {
597 int rv = 0;
598 struct elmnt e;
599 int unmatched = 0;
600
601 if (pos.p.m < 0)
602 return 0;
603 do {
604 int type = m[pos.p.m].oldtype;
605 if (mode & RESULT)
606 type = m[pos.p.m].type;
607 if (type == Changed)
608 rv |= CHANGES;
609 else if (type == Conflict) {
610 rv |= CONFLICTED | CHANGES;
611 } else if (type == AlreadyApplied) {
612 rv |= CONFLICTED;
613 if (mode & (BEFORE|AFTER))
614 rv |= CHANGES;
615 } else if (type == Extraneous) {
616 if (fb.list[m[pos.p.m].b].start[0] == '\0') {
617 /* hunk headers don't count as wiggles
618 * and nothing before a hunk header
619 * can possibly be part of this 'line' */
620 e.start = NULL;
621 break;
622 } else
623 rv |= WIGGLED;
624 } else if (type == Unmatched)
625 unmatched = 1;
626
627 if (m[pos.p.m].in_conflict > 1)
628 rv |= CONFLICTED | CHANGES;
629 if (m[pos.p.m].in_conflict == 1 &&
630 (pos.p.o < m[pos.p.m].lo ||
631 pos.p.o > m[pos.p.m].hi))
632 rv |= CONFLICTED | CHANGES;
633 e = prev_melmnt(&pos.p, fm, fb, fa, m);
634 } while (e.start != NULL &&
635 (!ends_line(e)
636 || visible(mode, m, &pos) == -1));
637 /* This is a bit of a hack... If the end-of-line just
638 * before this line was changed, then quite possibly this
639 * line is part of a change too. This is particularly important
640 * when --ignore-blanks is in effect as newlines are not separate
641 * from other words. It could be that this test needs to be
642 * strengthened when I have examined more cases.
643 */
644 if (e.start && m[pos.p.m].oldtype == Changed)
645 rv |= CHANGES;
646
647 if (unmatched && (rv & CHANGES))
648 rv |= WIGGLED;
649 return rv;
650 }
651
652 /* Find the next line in the merge which is visible.
653 * If we hit the end of a conflicted set during pass-1
654 * we rewind for pass-2.
655 * 'mode' tells which bits we want to see, possible one of
656 * the 4 parts (before/after/orig/result) or one of the pairs
657 * before+after or orig+result.
658 */
659 static void next_mline(struct mpos *pos, struct file fm, struct file fb,
660 struct file fa,
661 struct merge *m, int mode)
662 {
663 int mask;
664 do {
665 struct mp prv;
666 int mode2;
667
668 prv = pos->p;
669 while (1) {
670 struct elmnt e = next_melmnt(&pos->p, fm, fb, fa, m);
671 if (e.start == NULL)
672 break;
673 if (ends_line(e) &&
674 visible(mode, m, pos) >= 0)
675 break;
676 }
677 mode2 = check_line(*pos, fm, fb, fa, m, mode);
678
679 if ((mode2 & CHANGES) && pos->state == 0) {
680 /* Just entered a diff-set */
681 pos->lo = pos->p;
682 pos->state = 1;
683 } else if (!(mode2 & CHANGES) && pos->state) {
684 /* Come to the end of a diff-set */
685 switch (pos->state) {
686 case 1:
687 /* Need to record the end */
688 pos->hi = prv;
689 /* time for another pass */
690 pos->p = pos->lo;
691 pos->state++;
692 break;
693 case 2:
694 /* finished final pass */
695 pos->state = 0;
696 break;
697 }
698 }
699 mask = ORIG|RESULT|BEFORE|AFTER;
700 switch (pos->state) {
701 case 1:
702 mask &= ~(RESULT|AFTER);
703 break;
704 case 2:
705 mask &= ~(ORIG|BEFORE);
706 break;
707 }
708 } while (visible(mode&mask, m, pos) < 0);
709
710 }
711
712 /* Move to previous line - simply the reverse of next_mline */
713 static void prev_mline(struct mpos *pos, struct file fm, struct file fb,
714 struct file fa,
715 struct merge *m, int mode)
716 {
717 int mask;
718 do {
719 struct mp prv;
720 int mode2;
721
722 prv = pos->p;
723 if (pos->p.m < 0)
724 return;
725 while (1) {
726 struct elmnt e = prev_melmnt(&pos->p, fm, fb, fa, m);
727 if (e.start == NULL)
728 break;
729 if (ends_line(e) &&
730 visible(mode, m, pos) >= 0)
731 break;
732 }
733 mode2 = check_line(*pos, fm, fb, fa, m, mode);
734
735 if ((mode2 & CHANGES) && pos->state == 0) {
736 /* Just entered a diff-set */
737 pos->hi = pos->p;
738 pos->state = 2;
739 } else if (!(mode2 & CHANGES) && pos->state) {
740 /* Come to the end (start) of a diff-set */
741 switch (pos->state) {
742 case 1:
743 /* finished final pass */
744 pos->state = 0;
745 break;
746 case 2:
747 /* Need to record the start */
748 pos->lo = prv;
749 /* time for another pass */
750 pos->p = pos->hi;
751 pos->state--;
752 break;
753 }
754 }
755 mask = ORIG|RESULT|BEFORE|AFTER;
756 switch (pos->state) {
757 case 1:
758 mask &= ~(RESULT|AFTER);
759 break;
760 case 2:
761 mask &= ~(ORIG|BEFORE);
762 break;
763 }
764 } while (visible(mode&mask, m, pos) < 0);
765 }
766
767 /* blank a whole row of display */
768 static void blank(int row, int start, int cols, unsigned int attr)
769 {
770 (void)attrset(attr);
771 move(row, start);
772 while (cols-- > 0)
773 addch(' ');
774 }
775
776 /* search of a string on one display line. If found, update the
777 * cursor.
778 */
779
780 static int mcontains(struct mpos pos,
781 struct file fm, struct file fb, struct file fa,
782 struct merge *m,
783 int mode, char *search, struct cursor *curs,
784 int dir, int ignore_case)
785 {
786 /* See if any of the files, between start of this line and here,
787 * contain the search string.
788 * However this is modified by dir:
789 * -2: find last match *before* curs
790 * -1: find last match at-or-before curs
791 * 1: find first match at-or-after curs
792 * 2: find first match *after* curs
793 *
794 * We only test for equality with curs, so if it is on a different
795 * line it will not be found and everything is before/after.
796 * As we search from end-of-line to start we find the last
797 * match first.
798 * For a forward search, we stop when we find curs.
799 * For a backward search, we forget anything found when we find curs.
800 */
801 struct elmnt e;
802 int found = 0;
803 struct mp mp;
804 int o = 0;
805 int len = strlen(search);
806
807 do {
808 e = prev_melmnt(&pos.p, fm, fb, fa, m);
809 if (e.start && e.start[0]) {
810 int i;
811 int curs_i;
812 if (same_mp(pos.p, curs->pos))
813 curs_i = curs->offset;
814 else
815 curs_i = -1;
816 for (i = e.len-1; i >= 0; i--) {
817 if (i == curs_i && dir == -1)
818 /* next match is the one we want */
819 found = 0;
820 if (i == curs_i && dir == 2)
821 /* future matches not accepted */
822 goto break_while;
823 if ((!found || dir > 0) &&
824 (ignore_case ? strncasecmp : strncmp)
825 (e.start+i, search, len) == 0) {
826 mp = pos.p;
827 o = i;
828 found = 1;
829 }
830 if (i == curs_i && dir == -2)
831 /* next match is the one we want */
832 found = 0;
833 if (i == curs_i && dir == 1)
834 /* future matches not accepted */
835 goto break_while;
836 }
837 }
838 } while (e.start != NULL &&
839 (!ends_line(e)
840 || visible(mode, m, &pos) == -1));
841 break_while:
842 if (found) {
843 curs->pos = mp;
844 curs->offset = o;
845 }
846 return found;
847 }
848
849 /* Drawing the display window.
850 * There are 7 different ways we can display the data, each
851 * of which can be configured by a keystroke:
852 * o original - just show the original file with no changes, but still
853 * with highlights of what is changed or unmatched
854 * r result - show just the result of the merge. Conflicts just show
855 * the original, not the before/after options
856 * b before - show the 'before' stream of the patch
857 * a after - show the 'after' stream of the patch
858 * d diff - show just the patch, both before and after
859 * m merge - show the full merge with -+ sections for changes.
860 * If point is in a wiggled or conflicted section the
861 * window is split horizontally and the diff is shown
862 * in the bottom window
863 * | sidebyside - two panes, left and right. Left holds the merge,
864 * right holds the diff. In the case of a conflict,
865 * left holds orig/after, right holds before/after
866 *
867 * The horizontal split for 'merge' mode is managed as follows.
868 * - The window is split when we first visit a line that contains
869 * a wiggle or a conflict, and the second pane is removed when
870 * we next visit a line that contains no changes (is fully Unchanged).
871 * - to display the second pane, we find a visible end-of-line in the
872 * (BEFORE|AFTER) mode at-or-before the current end-of-line and
873 * the we centre that line.
874 * - We need to rewind to an unchanged section, and wind forward again
875 * to make sure that 'lo' and 'hi' are set properly.
876 * - every time we move, we redraw the second pane (see how that goes).
877 */
878
879 /* draw_mside draws one text line or, in the case of sidebyside, one side
880 * of a textline.
881 * The 'mode' tells us what to draw via the 'visible()' function.
882 * It is one of ORIG RESULT BEFORE AFTER or ORIG|RESULT or BEFORE|AFTER
883 * It may also have WIGGLED or CONFLICTED ored in to trigger extra highlights.
884 * The desired cursor position is given in 'target' the actual end
885 * cursor position (allowing e.g. for tabs) is returned in *colp.
886 */
887 static void draw_mside(int mode, int row, int offset, int start, int cols,
888 struct file fm, struct file fb, struct file fa,
889 struct merge *m,
890 struct mpos pos,
891 struct cursor *curs)
892 {
893 struct elmnt e;
894 int col = 0;
895 char tag;
896 unsigned int tag_attr;
897 int changed = 0;
898
899 switch (pos.state) {
900 default: /* keep compiler happy */
901 case 0: /* unchanged line */
902 tag = ' ';
903 tag_attr = A_NORMAL;
904 break;
905 case 1: /* 'before' text */
906 tag = '-';
907 tag_attr = a_delete;
908 if ((mode & ORIG) && (mode & CONFLICTED)) {
909 tag = '|';
910 tag_attr = a_delete | A_REVERSE;
911 }
912 mode &= (ORIG|BEFORE);
913 break;
914 case 2: /* the 'after' part */
915 tag = '+';
916 tag_attr = a_added;
917 mode &= (AFTER|RESULT);
918 break;
919 }
920
921 if (visible(mode, m, &pos) < 0) {
922 /* Not visible, just draw a blank */
923 blank(row, offset, cols, a_void);
924 if (curs) {
925 curs->width = -1;
926 curs->col = 0;
927 curs->pos = pos.p;
928 curs->offset = 0;
929 }
930 return;
931 }
932
933 (void)attrset(tag_attr);
934 mvaddch(row, offset, tag);
935 offset++;
936 cols--;
937 (void)attrset(A_NORMAL);
938
939 if (check_line(pos, fm, fb, fa, m, mode))
940 changed = 1;
941
942 /* find previous visible newline, or start of file */
943 do
944 e = prev_melmnt(&pos.p, fm, fb, fa, m);
945 while (e.start != NULL &&
946 (!ends_line(e) ||
947 visible(mode, m, &pos) == -1));
948
949 while (1) {
950 unsigned char *c;
951 unsigned int attr;
952 int highlight_space;
953 int l;
954 e = next_melmnt(&pos.p, fm, fb, fa, m);
955 if (!e.start)
956 break;
957
958 if (visible(mode, m, &pos) == -1)
959 continue;
960 if (e.start[0] == 0)
961 break;
962 c = (unsigned char *)e.start - e.prefix;
963 highlight_space = 0;
964 attr = visible(mode, m, &pos);
965 if ((attr == a_unmatched || attr == a_extra) &&
966 changed)
967 /* Only highlight spaces if there is a tab nearby */
968 for (l = 0; l < e.plen + e.prefix; l++)
969 if (c[l] == '\t')
970 highlight_space = 1;
971 if (!highlight_space && (c[0] == ' ' || c[0] == '\t')) {
972 /* always highlight space/tab at end-of-line */
973 struct mp nxt = pos.p;
974 struct elmnt nxte = next_melmnt(&nxt, fm, fb, fa, m);
975 if (nxte.start[0] == '\n')
976 highlight_space = 1;
977 }
978 for (l = 0; l < e.plen + e.prefix; l++) {
979 int scol = col;
980 if (*c == '\n')
981 break;
982 (void)attrset(attr);
983 if (*c >= ' ' && *c != 0x7f) {
984 if (highlight_space)
985 (void)attrset(attr|A_REVERSE);
986 if (col >= start && col < start+cols)
987 mvaddch(row, col-start+offset, *c);
988 col++;
989 } else if (*c == '\t') {
990 if (highlight_space)
991 (void)attrset(attr|A_UNDERLINE);
992 do {
993 if (col >= start && col < start+cols) {
994 mvaddch(row, col-start+offset, ' ');
995 } col++;
996 } while ((col&7) != 0);
997 } else {
998 if (col >= start && col < start+cols)
999 mvaddch(row, col-start+offset, '?');
1000 col++;
1001 }
1002 if (curs) {
1003 if (curs->target >= 0) {
1004 if (curs->target < col) {
1005 /* Found target column */
1006 curs->pos = pos.p;
1007 curs->offset = l;
1008 curs->col = scol;
1009 if (scol >= start + cols)
1010 /* Didn't appear on screen */
1011 curs->width = 0;
1012 else
1013 curs->width = col - scol;
1014 curs = NULL;
1015 }
1016 } else if (l == curs->offset &&
1017 same_mp(pos.p, curs->pos)) {
1018 /* Found the pos */
1019 curs->target = scol;
1020 curs->col = scol;
1021 if (scol >= start + cols)
1022 /* Didn't appear on screen */
1023 curs->width = 0;
1024 else
1025 curs->width = col - scol;
1026 curs = NULL;
1027 }
1028 }
1029 c++;
1030 }
1031 if ((ends_line(e)
1032 && visible(mode, m, &pos) != -1))
1033 break;
1034 }
1035
1036 /* We have reached the end of visible line, or end of file */
1037 if (curs) {
1038 curs->col = col;
1039 if (col >= start + cols)
1040 curs->width = 0;
1041 else
1042 curs->width = -1; /* end of line */
1043 if (curs->target >= 0) {
1044 curs->pos = pos.p;
1045 curs->offset = 0;
1046 } else if (same_mp(pos.p, curs->pos))
1047 curs->target = col;
1048 }
1049 if (col < start)
1050 col = start;
1051 if (e.start && e.start[0] == 0) {
1052 char b[100];
1053 struct elmnt e1;
1054 int A, B, C, D, E, F;
1055 e1 = fb.list[m[pos.p.m].b + pos.p.o];
1056 sscanf(e1.start+1, "%d %d %d", &A, &B, &C);
1057 sscanf(e.start+1, "%d %d %d", &D, &E, &F);
1058 snprintf(b, sizeof(b), "@@ -%d,%d +%d,%d @@%s", B, C, E, F, e1.start+18);
1059 (void)attrset(a_sep);
1060
1061 mvaddstr(row, col-start+offset, b);
1062 col += strlen(b);
1063 }
1064 blank(row, col-start+offset, start+cols-col,
1065 e.start
1066 ? (unsigned)visible(mode, m, &pos)
1067 : A_NORMAL);
1068 }
1069
1070 /* Draw either 1 or 2 sides depending on the mode. */
1071
1072 static void draw_mline(int mode, int row, int start, int cols,
1073 struct file fm, struct file fb, struct file fa,
1074 struct merge *m,
1075 struct mpos pos,
1076 struct cursor *curs)
1077 {
1078 /*
1079 * Draw the left and right images of this line
1080 * One side might be a_blank depending on the
1081 * visibility of this newline
1082 */
1083 int lcols, rcols;
1084
1085 mode |= check_line(pos, fm, fb, fa, m, mode);
1086
1087 if ((mode & (BEFORE|AFTER)) &&
1088 (mode & (ORIG|RESULT))) {
1089
1090 lcols = (cols-1)/2;
1091 rcols = cols - lcols - 1;
1092
1093 (void)attrset(A_STANDOUT);
1094 mvaddch(row, lcols, '|');
1095
1096 draw_mside(mode&~(BEFORE|AFTER), row, 0, start, lcols,
1097 fm, fb, fa, m, pos, curs && !curs->alt ? curs : NULL);
1098
1099 draw_mside(mode&~(ORIG|RESULT), row, lcols+1, start, rcols,
1100 fm, fb, fa, m, pos, curs && curs->alt ? curs : NULL);
1101 } else
1102 draw_mside(mode, row, 0, start, cols,
1103 fm, fb, fa, m, pos, curs);
1104 }
1105
1106 static char *merge_help[] = {
1107 "This view shows the merge of the patch with the",
1108 "original file. It is like a full-context diff showing",
1109 "removed lines with a '-' prefix and added lines with a",
1110 "'+' prefix.",
1111 "In cases where a patch chunk could not be successfully",
1112 "applied, the original text is prefixed with a '|', and",
1113 "the text that the patch wanted to add is prefixed with",
1114 "a '+'.",
1115 "When the cursor is over such a conflict, or over a chunk",
1116 "which required wiggling to apply (i.e. there was unmatched",
1117 "text in the original, or extraneous unchanged text in",
1118 "the patch), the terminal is split and the bottom pane is",
1119 "use to display the part of the patch that applied to",
1120 "this section of the original. This allows you to confirm",
1121 "that a wiggled patch applied correctly, and to see",
1122 "why there was a conflict",
1123 NULL
1124 };
1125 static char *diff_help[] = {
1126 "This is the 'diff' or 'patch' view. It shows",
1127 "only the patch that is being applied without the",
1128 "original to which it is being applied.",
1129 "Underlined text indicates parts of the patch which",
1130 "resulted in a conflict when applied to the",
1131 "original.",
1132 NULL
1133 };
1134 static char *orig_help[] = {
1135 "This is the 'original' view which simply shows",
1136 "the original file before applying the patch.",
1137 "Sections of code that would be changed by the patch",
1138 "are highlighted in red.",
1139 NULL
1140 };
1141 static char *result_help[] = {
1142 "This is the 'result' view which shows just the",
1143 "result of applying the patch. When a conflict",
1144 "occurred this view does not show the full conflict",
1145 "but only the 'after' part of the patch. To see",
1146 "the full conflict, use the 'merge' or 'sidebyside'",
1147 "views.",
1148 NULL
1149 };
1150 static char *before_help[] = {
1151 "This view shows the 'before' section of a patch.",
1152 "It allows the expected match text to be seen uncluttered",
1153 "by text that is meant to replaced it.",
1154 "Red text is text that will be removed by the patch",
1155 NULL
1156 };
1157 static char *after_help[] = {
1158 "This view shows the 'after' section of a patch.",
1159 "It allows the intended result to be seen uncluttered",
1160 "by text that was meant to be matched and replaced.",
1161 "Green text is text that was added by the patch - it",
1162 "was not present in the 'before' part of the patch",
1163 NULL
1164 };
1165 static char *sidebyside_help[] = {
1166 "This is the Side By Side view of a patched file.",
1167 "The left side shows the original and the result.",
1168 "The right side shows the patch which was applied",
1169 "and lines up with the original/result as much as",
1170 "possible.",
1171 "",
1172 "Where one side has no line which matches the",
1173 "other side it is displayed as a solid colour in the",
1174 "yellow family (depending on your terminal window).",
1175 NULL
1176 };
1177 static char *merge_window_help[] = {
1178 " Highlight Colours and Keystroke commands",
1179 "",
1180 "In all different views of a merge, highlight colours",
1181 "are used to show which parts of lines were added,",
1182 "removed, already changed, unchanged or in conflict.",
1183 "Colours and their use are:",
1184 " normal unchanged text",
1185 " red text that was removed or changed",
1186 " green text that was added or the result",
1187 " of a change",
1188 " yellow background used in side-by-side for a line",
1189 " which has no match on the other",
1190 " side",
1191 " blue text in the original which did not",
1192 " match anything in the patch",
1193 " cyan text in the patch which did not",
1194 " match anything in the original",
1195 " cyan background already changed text: the result",
1196 " of the patch matches the original",
1197 " underline remove or added text can also be",
1198 " underlined indicating that it",
1199 " was involved in a conflict",
1200 "",
1201 "While viewing a merge various keystroke commands can",
1202 "be used to move around and change the view. Basic",
1203 "movement commands from both 'vi' and 'emacs' are",
1204 "available:",
1205 "",
1206 " p control-p k UP Move to previous line",
1207 " n control-n j DOWN Move to next line",
1208 " l LEFT Move one char to right",
1209 " h RIGHT Move one char to left",
1210 " / control-s Enter incremental search mode",
1211 " control-r Enter reverse-search mode",
1212 " control-g Search again",
1213 " ? Display help message",
1214 " ESC-< 0-G Go to start of file",
1215 " ESC-> G Go to end of file",
1216 " q Return to list of files or exit",
1217 " S Arrange for merge to be saved on exit",
1218 " control-C Disable auto-save-on-exit",
1219 " control-L recenter current line",
1220 " control-V SPACE page down",
1221 " ESC-v BACKSPC page up",
1222 " N go to next patch chunk",
1223 " P go to previous patch chunk",
1224 " C go to next conflicted chunk",
1225 " C-X-o O move cursor to alternate pane",
1226 " ^ control-A go to start of line",
1227 " $ control-E go to end of line",
1228 "",
1229 " a display 'after' view",
1230 " b display 'before' view",
1231 " o display 'original' view",
1232 " r display 'result' view",
1233 " d display 'diff' or 'patch' view",
1234 " m display 'merge' view",
1235 " | display side-by-side view",
1236 "",
1237 " I toggle whether spaces are ignored",
1238 " when matching text.",
1239 " x toggle ignoring of current Changed,",
1240 " Conflict, or Unmatched item",
1241 " c toggle accepting of result of conflict",
1242 " X Revert 'c' and 'x' changes on this line",
1243 " v Save the current merge and run the",
1244 " default editor on the file.",
1245 NULL
1246 };
1247 static char *save_query[] = {
1248 "",
1249 "You have modified the merge.",
1250 "Would you like to save it?",
1251 " Y = save the modified merge",
1252 " N = discard modifications, don't save",
1253 " Q = return to viewing modified merge",
1254 NULL
1255 };
1256
1257 static char *toggle_ignore[] = {
1258 "",
1259 "You have modified the merge.",
1260 "Toggling ignoring of spaces will discard changes.",
1261 "Do you want to proceed?",
1262 " Y = discard changes and toggle ignoring of spaces",
1263 " N = keep changes, don't toggle",
1264 NULL
1265 };
1266
1267 static void do_edit(char *file, int line)
1268 {
1269 char *ed = getenv("VISUAL");
1270 char linebuf[20];
1271 if (!ed)
1272 ed = getenv("EDITOR");
1273 if (!ed)
1274 ed = "/usr/bin/edit";
1275 snprintf(linebuf, sizeof(linebuf), "+%d", line);
1276 switch(fork()) {
1277 case 0:
1278 execlp(ed, ed, linebuf, file, NULL);
1279 exit(2);
1280 case -1:
1281 break;
1282 default:
1283 wait(NULL);
1284 }
1285 }
1286
1287 static void *memdup(void *a, int len)
1288 {
1289 char *r = malloc(len);
1290 memcpy(r, a, len);
1291 return r;
1292 }
1293
1294 static int merge_window(struct plist *p, FILE *f, int reverse, int replace,
1295 int selftest, int ignore_blanks, int just_diff, int backup)
1296 {
1297 /* Display the merge window in one of the selectable modes,
1298 * starting with the 'merge' mode.
1299 *
1300 * Newlines are the key to display.
1301 * 'pos' is always a visible newline (or eof).
1302 * In sidebyside mode it might only be visible on one side,
1303 * in which case the other side will be blank.
1304 * Where the newline is visible, we rewind the previous visible
1305 * newline visible and display the stuff in between
1306 *
1307 * A 'position' is a struct mpos
1308 */
1309
1310 struct stream sm, sb, sa, sp; /* main, before, after, patch */
1311 struct file fm, fb, fa;
1312 struct csl *csl1, *csl2;
1313 struct ci ci;
1314 int ch; /* count of chunks */
1315 /* Always refresh the current line.
1316 * If refresh == 1, refresh all lines. If == 2, clear first
1317 */
1318 int refresh = 2;
1319 int rows = 0, cols = 0;
1320 int splitrow = -1; /* screen row for split - diff appears below */
1321 int lastrow = 0; /* end of screen, or just above 'splitrow' */
1322 int i, c, cswitch;
1323 MEVENT mevent;
1324 int mode = just_diff ? (BEFORE|AFTER) : (ORIG|RESULT);
1325 int mmode = mode; /* Mode for moving - used when in 'other' pane */
1326 char *modename = just_diff ? "diff" : "merge";
1327 char **modehelp = just_diff ? diff_help : merge_help;
1328 char *mesg = NULL;
1329
1330 int row, start = 0;
1331 int trow; /* screen-row while searching. If we cannot find,
1332 * we forget this number */
1333 struct cursor curs;
1334 struct mpos pos; /* current point */
1335 struct mpos tpos, /* temp point while drawing lines above and below pos */
1336 toppos, /* pos at top of screen - for page-up */
1337 botpos; /* pos at bottom of screen - for page-down */
1338 struct mpos vispos;
1339 int botrow = 0;
1340 int meta = 0, /* mode for multi-key commands- SEARCH or META */
1341 tmeta;
1342 int num = -1, /* numeric arg being typed. */
1343 tnum;
1344 int lineno;
1345 int changes = 0; /* If any edits have been made to the merge */
1346 int answer; /* answer to 'save changes?' question */
1347 char *tempname;
1348 struct elmnt e;
1349 char search[80]; /* string we are searching for */
1350 unsigned int searchlen = 0;
1351 int search_notfound = 0;
1352 int searchdir = 0;
1353 /* ignore_case:
1354 * 0 == no
1355 * 1 == no because there are upper-case chars
1356 * 2 == yes as there are no upper-case chars
1357 * 3 == yes
1358 */
1359 int ignore_case = 2;
1360 /* We record all the places we find so 'backspace'
1361 * can easily return to the previous one
1362 */
1363 struct search_anchor {
1364 struct search_anchor *next;
1365 struct mpos pos;
1366 struct cursor curs;
1367 int notfound;
1368 int row, start;
1369 unsigned int searchlen;
1370 } *anchor = NULL;
1371
1372 #define free_stuff(none) \
1373 do { \
1374 free(fm.list); \
1375 free(fb.list); \
1376 free(fa.list); \
1377 free(csl1); \
1378 free(csl2); \
1379 free(ci.merger); \
1380 } while(0)
1381
1382 #define find_line(ln) \
1383 do { \
1384 pos.p.m = 0; /* merge node */ \
1385 pos.p.s = 0; /* stream number */ \
1386 pos.p.o = -1; /* offset */ \
1387 pos.p.lineno = 1; \
1388 pos.state = 0; \
1389 memset(&curs, 0, sizeof(curs)); \
1390 do \
1391 next_mline(&pos, fm, fb, fa, ci.merger, mode); \
1392 while (pos.p.lineno < ln && ci.merger[pos.p.m].type != End); \
1393 } while(0)
1394
1395 #define prepare_merge(ch) \
1396 do { \
1397 /* FIXME check for errors in the stream */ \
1398 fm = split_stream(sm, ByWord | ignore_blanks); \
1399 fb = split_stream(sb, ByWord | ignore_blanks); \
1400 fa = split_stream(sa, ByWord | ignore_blanks); \
1401 \
1402 if (ch && !just_diff) \
1403 csl1 = pdiff(fm, fb, ch); \
1404 else \
1405 csl1 = diff(fm, fb, 1); \
1406 csl2 = diff_patch(fb, fa, 1); \
1407 \
1408 ci = make_merger(fm, fb, fa, csl1, csl2, 0, 1, 0); \
1409 for (i = 0; ci.merger[i].type != End; i++) \
1410 ci.merger[i].oldtype = ci.merger[i].type; \
1411 } while(0)
1412
1413 if (selftest) {
1414 intr_kills = 1;
1415 selftest = 1;
1416 }
1417
1418 if (f == NULL) {
1419 if (!p->is_merge) {
1420 /* three separate files */
1421 sb = load_file(p->before);
1422 sa = load_file(p->after);
1423 if (just_diff)
1424 sm = sb;
1425 else
1426 sm = load_file(p->file);
1427 } else {
1428 /* One merge file */
1429 sp = load_file(p->file);
1430 if (reverse)
1431 split_merge(sp, &sm, &sa, &sb);
1432 else
1433 split_merge(sp, &sm, &sb, &sa);
1434 free(sp.body);
1435 }
1436 ch = 0;
1437 } else {
1438 sp = load_segment(f, p->start, p->end);
1439 if (p->is_merge) {
1440 if (reverse)
1441 split_merge(sp, &sm, &sa, &sb);
1442 else
1443 split_merge(sp, &sm, &sb, &sa);
1444 ch = 0;
1445 } else {
1446 if (reverse)
1447 ch = split_patch(sp, &sa, &sb);
1448 else
1449 ch = split_patch(sp, &sb, &sa);
1450 if (just_diff)
1451 sm = sb;
1452 else
1453 sm = load_file(p->file);
1454 }
1455 free(sp.body);
1456 }
1457 if (!sm.body || !sb.body || !sa.body) {
1458 if (!just_diff)
1459 free(sm.body);
1460 free(sb.body);
1461 free(sa.body);
1462 term_init(1);
1463 if (!sm.body)
1464 help_window(help_missing, NULL, 0);
1465 else
1466 help_window(help_corrupt, NULL, 0);
1467 endwin();
1468 return 0;
1469 }
1470 prepare_merge(ch);
1471 term_init(!selftest);
1472
1473 row = 1;
1474 find_line(1);
1475
1476 while (1) {
1477 unsigned int next;
1478 if (refresh >= 2) {
1479 clear();
1480 refresh = 1;
1481 }
1482 if (row < 1 || row >= lastrow)
1483 refresh = 1;
1484 if (curs.alt)
1485 refresh = 1;
1486
1487 if (mode == (ORIG|RESULT)) {
1488 int cmode = check_line(pos, fm, fb, fa, ci.merger, mode);
1489 if (cmode & (WIGGLED | CONFLICTED)) {
1490 if (splitrow < 0) {
1491 splitrow = (rows+1)/2;
1492 lastrow = splitrow - 1;
1493 refresh = 1;
1494 }
1495 } else if (!curs.alt && splitrow >= 0) {
1496 splitrow = -1;
1497 lastrow = rows-1;
1498 refresh = 1;
1499 }
1500 } else if (splitrow >= 0) {
1501 splitrow = -1;
1502 lastrow = rows-1;
1503 refresh = 1;
1504 }
1505
1506 if (refresh) {
1507 getmaxyx(stdscr, rows, cols);
1508 rows--; /* keep last row clear */
1509 if (splitrow >= 0) {
1510 splitrow = (rows+1)/2;
1511 lastrow = splitrow - 1;
1512 } else
1513 lastrow = rows - 1;
1514
1515 if (row < -3)
1516 row = lastrow/2+1;
1517 if (row < 1)
1518 row = 1;
1519 if (row > lastrow+3)
1520 row = lastrow/2+1;
1521 if (row >= lastrow)
1522 row = lastrow-1;
1523 }
1524
1525 /* Always refresh the line */
1526 while (start > curs.target) {
1527 start -= 8;
1528 refresh = 1;
1529 }
1530 if (start < 0)
1531 start = 0;
1532 vispos = pos; /* visible position - if cursor is in
1533 * alternate pane, pos might not be visible
1534 * in main pane. */
1535 if (check_line(vispos, fm, fb, fa, ci.merger, mode)
1536 & CHANGES) {
1537 if (vispos.state == 0) {
1538 vispos.state = 1;
1539 vispos.lo = vispos.p;
1540 vispos.hi = vispos.p;
1541 }
1542 } else {
1543 vispos.state = 0;
1544 }
1545
1546 if (visible(mode, ci.merger, &vispos) < 0)
1547 prev_mline(&vispos, fm, fb, fa, ci.merger, mode);
1548 if (!curs.alt)
1549 pos= vispos;
1550 retry:
1551 draw_mline(mode, row, start, cols, fm, fb, fa, ci.merger,
1552 vispos, (splitrow >= 0 && curs.alt) ? NULL : &curs);
1553 if (curs.width == 0 && start < curs.col) {
1554 /* width == 0 implies it appear after end-of-screen */
1555 start += 8;
1556 refresh = 1;
1557 goto retry;
1558 }
1559 if (curs.col < start) {
1560 start -= 8;
1561 refresh = 1;
1562 if (start < 0)
1563 start = 0;
1564 goto retry;
1565 }
1566 if (refresh) {
1567 refresh = 0;
1568
1569 tpos = vispos;
1570
1571 for (i = row-1; i >= 1 && tpos.p.m >= 0; ) {
1572 prev_mline(&tpos, fm, fb, fa, ci.merger, mode);
1573 draw_mline(mode, i--, start, cols,
1574 fm, fb, fa, ci.merger,
1575 tpos, NULL);
1576
1577 }
1578 if (i > 0) {
1579 row -= (i+1);
1580 refresh = 1;
1581 goto retry;
1582 }
1583 toppos = tpos;
1584 while (i >= 1)
1585 blank(i--, 0, cols, a_void);
1586 tpos = vispos;
1587 for (i = row; i <= lastrow && ci.merger[tpos.p.m].type != End; ) {
1588 draw_mline(mode, i++, start, cols,
1589 fm, fb, fa, ci.merger,
1590 tpos, NULL);
1591 next_mline(&tpos, fm, fb, fa, ci.merger, mode);
1592 }
1593 botpos = tpos; botrow = i;
1594 while (i <= lastrow)
1595 blank(i++, 0, cols, a_void);
1596 }
1597
1598 if (splitrow >= 0) {
1599 struct mpos spos = pos;
1600 int smode = BEFORE|AFTER;
1601 int srow = (rows + splitrow)/2;
1602 if (check_line(spos, fm, fb, fa, ci.merger, smode)
1603 & CHANGES) {
1604 if (spos.state == 0)
1605 spos.state = 1;
1606 } else {
1607 spos.state = 0;
1608 }
1609 if (visible(smode, ci.merger, &spos) < 0)
1610 prev_mline(&spos, fm, fb, fa, ci.merger, smode);
1611 /* Now hi/lo might be wrong, so lets fix it. */
1612 tpos = spos;
1613 if (spos.state)
1614 /* 'hi' might be wrong so we mustn't depend
1615 * on it while walking back. So set state
1616 * to 1 to avoid ever testing it.
1617 */
1618 spos.state = 1;
1619 while (spos.p.m >= 0 && spos.state != 0)
1620 prev_mline(&spos, fm, fb, fa, ci.merger, smode);
1621 while (!same_mpos(spos, tpos) &&
1622 spos.p.m >= 0 &&
1623 ci.merger[spos.p.m].type != End)
1624 next_mline(&spos, fm, fb, fa, ci.merger, smode);
1625
1626 (void)attrset(a_sep);
1627 for (i = 0; i < cols; i++)
1628 mvaddstr(splitrow, i, "-");
1629
1630 tpos = spos;
1631 for (i = srow-1; i > splitrow; i--) {
1632 prev_mline(&tpos, fm, fb, fa, ci.merger, smode);
1633 draw_mline(smode, i, start, cols, fm, fb, fa, ci.merger,
1634 tpos, NULL);
1635 }
1636 while (i > splitrow)
1637 blank(i--, 0, cols, a_void);
1638 tpos = spos;
1639 for (i = srow;
1640 i < rows && tpos.p.m >= 0 &&
1641 ci.merger[tpos.p.m].type != End;
1642 i++) {
1643 draw_mline(smode, i, start, cols, fm, fb, fa, ci.merger,
1644 tpos,
1645 (i == srow && curs.alt) ? &curs : NULL);
1646 next_mline(&tpos, fm, fb, fa, ci.merger, smode);
1647 }
1648 while (i < rows)
1649 blank(i++, 0, cols, a_void);
1650 }
1651 /* Now that curs is accurate, report the type */
1652 {
1653 int l = 0;
1654 char buf[100];
1655 if (p->file)
1656 l = snprintf(buf, 100, "File: %s%s ",
1657 p->file, reverse ? " - reversed" : "");
1658 snprintf(buf+l, 100-l, "Mode: %s", modename);
1659 (void)attrset(A_BOLD);
1660 mvaddstr(0, 0, buf);
1661 (void)attrset(A_NORMAL);
1662 if (ignore_blanks)
1663 addstr(" (ignoring blanks)");
1664 clrtoeol();
1665 (void)attrset(A_BOLD);
1666 if (ci.merger[curs.pos.m].type != ci.merger[curs.pos.m].oldtype)
1667 l = snprintf(buf, sizeof(buf), "%s->", typenames[ci.merger[curs.pos.m].oldtype]);
1668 snprintf(buf+l, sizeof(buf)-l, "%s ln:%d",
1669 typenames[ci.merger[curs.pos.m].type],
1670 (pos.p.lineno-1)/2);
1671 mvaddstr(0, cols - strlen(buf) - 1, buf);
1672 }
1673 #define META(c) ((c)|0x1000)
1674 #define SEARCH(c) ((c)|0x2000)
1675 #define CTRLX(c) ((c)|0x4000)
1676 move(rows, 0);
1677 (void)attrset(A_NORMAL);
1678 if (mesg) {
1679 attrset(A_REVERSE);
1680 addstr(mesg);
1681 mesg = NULL;
1682 attrset(A_NORMAL);
1683 }
1684 if (num >= 0) {
1685 char buf[12+1];
1686 snprintf(buf, sizeof(buf), "%d ", num);
1687 addstr(buf);
1688 }
1689 if (meta & META(0))
1690 addstr("ESC...");
1691 if (meta & CTRLX(0))
1692 addstr("C-x ");
1693 if (meta & SEARCH(0)) {
1694 if (searchdir < 0)
1695 addstr("Backwards ");
1696 addstr("Search: ");
1697 addstr(search);
1698 if (search_notfound)
1699 addstr(" - Not Found.");
1700 search_notfound = 0;
1701 }
1702 clrtoeol();
1703 /* '+1' to skip over the leading +/-/| char */
1704 if (curs.alt && splitrow > 0)
1705 move((rows + splitrow)/2, curs.col - start + 1);
1706 else if (curs.alt && ((mode & (BEFORE|AFTER)) &&
1707 (mode & (ORIG|RESULT))))
1708 move(row, curs.col-start + (cols-1)/2+2);
1709 else
1710 move(row, curs.col-start+1);
1711 switch (selftest) {
1712 case 0:
1713 c = getch(); break;
1714 case 1:
1715 c = 'n'; break;
1716 case 2:
1717 c = 'q'; break;
1718 }
1719 tmeta = meta; meta = 0;
1720 tnum = num; num = -1;
1721 cswitch = c | tmeta;
1722 /* Handle some ranges */
1723 /* case '0' ... '9': */
1724 if (cswitch >= '0' && cswitch <= '9')
1725 cswitch = '0';
1726 /* case SEARCH(' ') ... SEARCH('~'): */
1727 if (cswitch >= SEARCH(' ') && cswitch <= SEARCH('~'))
1728 cswitch = SEARCH(' ');
1729
1730 switch (cswitch) {
1731 case 27: /* escape */
1732 case META(27):
1733 meta = META(0);
1734 break;
1735
1736 case 'X'-64:
1737 case META('X'-64):
1738 meta = CTRLX(0);
1739 break;
1740
1741 case META('<'): /* start of file */
1742 start:
1743 tpos = pos; row++;
1744 do {
1745 pos = tpos; row--;
1746 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
1747 } while (tpos.p.m >= 0);
1748 if (row <= 0)
1749 row = 0;
1750 break;
1751 case META('>'): /* end of file */
1752 case 'G':
1753 if (tnum >= 0)
1754 goto start;
1755 tpos = pos; row--;
1756 do {
1757 pos = tpos; row++;
1758 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
1759 } while (ci.merger[tpos.p.m].type != End);
1760 if (row >= lastrow)
1761 row = lastrow;
1762 break;
1763 case '0': /* actually '0'...'9' */
1764 if (tnum < 0)
1765 tnum = 0;
1766 num = tnum*10 + (c-'0');
1767 break;
1768 case 'C'-64:
1769 if (replace)
1770 mesg = "Autosave disabled";
1771 else
1772 mesg = "Use 'q' to quit";
1773 replace = 0;
1774 break;
1775 case 'S':
1776 mesg = "Will auto-save on exit, using Ctrl-C to cancel";
1777 replace = 1;
1778 break;
1779 case 'q':
1780 refresh = 2;
1781 answer = 0;
1782 if (replace)
1783 answer = 1;
1784 else if (changes)
1785 answer = help_window(save_query, NULL, 1);
1786 if (answer < 0)
1787 break;
1788 if (answer) {
1789 p->wiggles = 0;
1790 p->conflicts = isolate_conflicts(
1791 fm, fb, fa, csl1, csl2, 0,
1792 ci.merger, 0, &p->wiggles);
1793 p->chunks = p->conflicts;
1794 save_merge(fm, fb, fa, ci.merger,
1795 p->outfile ? p->outfile : p->file,
1796 backup && (p->outfile ? 0 : !p->is_merge));
1797 }
1798 if (!just_diff)
1799 free(sm.body);
1800 free(sb.body);
1801 free(sa.body);
1802 free_stuff();
1803 endwin();
1804 return answer;
1805
1806 case 'I': /* Toggle ignoring of spaces */
1807 if (changes) {
1808 refresh = 2;
1809 answer = help_window(toggle_ignore, NULL, 1);
1810 if (answer <= 0)
1811 break;
1812 changes = 0;
1813 }
1814 free_stuff();
1815 ignore_blanks = ignore_blanks ? 0 : IgnoreBlanks;
1816 prepare_merge(ch);
1817 find_line(pos.p.lineno);
1818
1819 refresh = 2;
1820 break;
1821
1822 case 'v':
1823 if (!p->file || just_diff) {
1824 mesg = "Cannot run editor when diffing";
1825 break;
1826 }
1827 tempname = p->file;
1828 lineno = save_tmp_merge(fm, fb, fa, ci.merger,
1829 &tempname,
1830 ci.merger + pos.p.m,
1831 pos.p.s,
1832 pos.p.o);
1833 endwin();
1834 free_stuff();
1835 do_edit(tempname, lineno);
1836 sp = load_file(tempname);
1837 unlink(tempname);
1838 split_merge(sp, &sm, &sb, &sa);
1839 if (sp.len == sm.len &&
1840 memcmp(sp.body, sm.body, sm.len) == 0 &&
1841 !p->is_merge) {
1842 /* no conflicts left, so display diff */
1843 free(sm.body);
1844 sm = load_file(p->file);
1845 free(sb.body);
1846 sb = sm;
1847 sb.body = memdup(sm.body, sm.len);
1848 }
1849 free(sp.body);
1850 ignore_blanks = 0;
1851 prepare_merge(0);
1852 refresh = 2;
1853 changes = 1;
1854
1855 find_line(pos.p.lineno);
1856
1857 doupdate();
1858 break;
1859
1860 case '/':
1861 case 'S'-64:
1862 /* incr search forward */
1863 meta = SEARCH(0);
1864 searchlen = 0;
1865 search[searchlen] = 0;
1866 searchdir = 1;
1867 break;
1868 case '\\':
1869 case 'R'-64:
1870 /* incr search backwards */
1871 meta = SEARCH(0);
1872 searchlen = 0;
1873 search[searchlen] = 0;
1874 searchdir = -1;
1875 break;
1876 case SEARCH('G'-64):
1877 case SEARCH('S'-64):
1878 case SEARCH('R'-64):
1879 /* search again */
1880 if ((c|tmeta) == SEARCH('R'-64))
1881 searchdir = -2;
1882 else
1883 searchdir = 2;
1884 meta = SEARCH(0);
1885 tpos = pos; trow = row;
1886 goto search_again;
1887
1888 case SEARCH('H'-64):
1889 case SEARCH(KEY_BACKSPACE):
1890 meta = SEARCH(0);
1891 if (anchor) {
1892 struct search_anchor *a;
1893 a = anchor;
1894 anchor = a->next;
1895 free(a);
1896 }
1897 if (anchor) {
1898 struct search_anchor *a;
1899 a = anchor;
1900 anchor = a->next;
1901 pos = a->pos;
1902 row = a->row;
1903 start = a->start;
1904 curs = a->curs;
1905 curs.target = -1;
1906 search_notfound = a->notfound;
1907 searchlen = a->searchlen;
1908 search[searchlen] = 0;
1909 free(a);
1910 refresh = 1;
1911 }
1912 break;
1913 case SEARCH(' '): /* actually ' '...'~' */
1914 case SEARCH('\t'):
1915 meta = SEARCH(0);
1916 if (searchlen < sizeof(search)-1)
1917 search[searchlen++] = c & (0x7f);
1918 search[searchlen] = 0;
1919 tpos = pos; trow = row;
1920 search_again:
1921 search_notfound = 1;
1922 if (ignore_case == 1 || ignore_case == 2) {
1923 unsigned int i;
1924 ignore_case = 2;
1925 for (i=0; i < searchlen; i++)
1926 if (isupper(search[i])) {
1927 ignore_case = 1;
1928 break;
1929 }
1930 }
1931 do {
1932 if (mcontains(tpos, fm, fb, fa, ci.merger,
1933 mmode, search, &curs, searchdir,
1934 ignore_case >= 2)) {
1935 curs.target = -1;
1936 pos = tpos;
1937 row = trow;
1938 search_notfound = 0;
1939 break;
1940 }
1941 if (searchdir < 0) {
1942 trow--;
1943 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
1944 } else {
1945 trow++;
1946 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
1947 }
1948 } while (tpos.p.m >= 0 && ci.merger[tpos.p.m].type != End);
1949 searchdir /= abs(searchdir);
1950
1951 break;
1952 case 'L'-64:
1953 refresh = 2;
1954 row = lastrow / 2;
1955 break;
1956
1957 case KEY_NPAGE:
1958 case ' ':
1959 case 'V'-64: /* page down */
1960 pos = botpos;
1961 if (botrow <= lastrow) {
1962 row = botrow;
1963 if (selftest == 1)
1964 selftest = 2;
1965 } else
1966 row = 2;
1967 refresh = 1;
1968 break;
1969 case KEY_PPAGE:
1970 case KEY_BACKSPACE:
1971 case META('v'): /* page up */
1972 pos = toppos;
1973 row = lastrow-1;
1974 refresh = 1;
1975 break;
1976
1977 case KEY_MOUSE:
1978 if (getmouse(&mevent) != OK)
1979 break;
1980 /* First see if this is on the 'other' pane */
1981 if (splitrow > 0) {
1982 /* merge mode, top and bottom */
1983 if ((curs.alt && mevent.y < splitrow) ||
1984 (!curs.alt && mevent.y > splitrow)) {
1985 goto other_pane;
1986 }
1987 } else if (mode == (ORIG|RESULT|BEFORE|AFTER)) {
1988 /* side-by-side mode */
1989 if ((curs.alt && mevent.x < cols/2) ||
1990 (!curs.alt && mevent.x > cols/2)) {
1991 goto other_pane;
1992 }
1993 }
1994 /* Now try to find the right line */
1995 if (splitrow < 0 || !curs.alt)
1996 trow = row;
1997 else
1998 trow = (rows + splitrow)/2;
1999 while (trow > mevent.y) {
2000 tpos = pos;
2001 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2002 if (tpos.p.m >= 0) {
2003 pos = tpos;
2004 trow--;
2005 } else
2006 break;
2007 }
2008 while (trow < mevent.y) {
2009 tpos = pos;
2010 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2011 if (ci.merger[tpos.p.m].type != End) {
2012 pos = tpos;
2013 trow++;
2014 } else
2015 break;
2016 }
2017 if (splitrow < 0 || !curs.alt)
2018 /* it is OK to change the row */
2019 row = trow;
2020
2021 /* Now set the target column */
2022 if (mode == (ORIG|RESULT|BEFORE|AFTER) &&
2023 curs.alt)
2024 curs.target = start + mevent.x - cols / 2 - 1;
2025 else
2026 curs.target = start + mevent.x - 1;
2027 break;
2028 case 'j':
2029 case 'n':
2030 case 'N'-64:
2031 case KEY_DOWN:
2032 if (tnum < 0)
2033 tnum = 1;
2034 for (; tnum > 0 ; tnum--) {
2035 tpos = pos;
2036 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2037 if (ci.merger[tpos.p.m].type != End) {
2038 pos = tpos;
2039 row++;
2040 } else {
2041 if (selftest == 1)
2042 selftest = 2;
2043 break;
2044 }
2045 }
2046 break;
2047 case 'N':
2048 /* Next diff */
2049 tpos = pos; row--;
2050 do {
2051 pos = tpos; row++;
2052 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2053 } while (!(pos.state == 0
2054 && (check_line(pos, fm, fb, fa, ci.merger, mmode)
2055 & (CONFLICTED|WIGGLED)) == 0)
2056 && ci.merger[tpos.p.m].type != End);
2057 tpos = pos; row--;
2058 do {
2059 pos = tpos; row++;
2060 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2061 } while (pos.state == 0
2062 && (check_line(pos, fm, fb, fa, ci.merger, mmode)
2063 & (CONFLICTED|WIGGLED)) == 0
2064 && ci.merger[tpos.p.m].type != End);
2065
2066 break;
2067 case 'C':
2068 /* Next conflict */
2069 tpos = pos; row--;
2070 do {
2071 pos = tpos; row++;
2072 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2073 } while ((check_line(pos, fm, fb, fa, ci.merger, mmode)
2074 & CONFLICTED) != 0
2075 && ci.merger[tpos.p.m].type != End);
2076 tpos = pos; row--;
2077 do {
2078 pos = tpos; row++;
2079 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2080 } while ((check_line(pos, fm, fb, fa, ci.merger, mmode)
2081 & CONFLICTED) == 0
2082 && ci.merger[tpos.p.m].type != End);
2083
2084 break;
2085
2086 case 'P':
2087 /* Previous diff */
2088 tpos = pos; row++;
2089 do {
2090 pos = tpos; row--;
2091 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2092 } while (tpos.state == 0
2093 && (check_line(tpos, fm, fb, fa, ci.merger, mmode)
2094 & (CONFLICTED|WIGGLED)) == 0
2095 && tpos.p.m >= 0);
2096 tpos = pos; row++;
2097 do {
2098 pos = tpos; row--;
2099 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2100 } while (!(tpos.state == 0
2101 && (check_line(tpos, fm, fb, fa, ci.merger, mmode)
2102 & (CONFLICTED|WIGGLED)) == 0)
2103 && tpos.p.m >= 0);
2104 break;
2105
2106 case 'k':
2107 case 'p':
2108 case 'P'-64:
2109 case KEY_UP:
2110 if (tnum < 0)
2111 tnum = 1;
2112 for (; tnum > 0 ; tnum--) {
2113 tpos = pos;
2114 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2115 if (tpos.p.m >= 0) {
2116 pos = tpos;
2117 row--;
2118 } else
2119 break;
2120 }
2121 break;
2122
2123 case KEY_LEFT:
2124 case 'h':
2125 /* left */
2126 curs.target = curs.col - 1;
2127 if (curs.target < 0) {
2128 /* Try to go to end of previous line */
2129 tpos = pos;
2130 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2131 if (tpos.p.m >= 0) {
2132 pos = tpos;
2133 row--;
2134 curs.pos = pos.p;
2135 curs.target = -1;
2136 } else
2137 curs.target = 0;
2138 }
2139 break;
2140 case KEY_RIGHT:
2141 case 'l':
2142 /* right */
2143 if (curs.width >= 0)
2144 curs.target = curs.col + curs.width;
2145 else {
2146 /* end of line, go to next */
2147 tpos = pos;
2148 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2149 if (ci.merger[tpos.p.m].type != End) {
2150 pos = tpos;
2151 curs.pos = pos.p;
2152 row++;
2153 curs.target = 0;
2154 }
2155 }
2156 break;
2157
2158 case '^':
2159 case 'A'-64:
2160 /* Start of line */
2161 curs.target = 0;
2162 break;
2163 case '$':
2164 case 'E'-64:
2165 /* End of line */
2166 curs.target = 1000;
2167 break;
2168
2169 case CTRLX('o'):
2170 case 'O':
2171 other_pane:
2172 curs.alt = !curs.alt;
2173 if (curs.alt && mode == (ORIG|RESULT))
2174 mmode = (BEFORE|AFTER);
2175 else
2176 mmode = mode;
2177 break;
2178
2179 case 'a': /* 'after' view in patch window */
2180 if (mode == AFTER)
2181 goto set_merge;
2182 mode = AFTER; modename = "after"; modehelp = after_help;
2183 mmode = mode; curs.alt = 0;
2184 refresh = 3;
2185 break;
2186 case 'b': /* 'before' view in patch window */
2187 if (mode == BEFORE)
2188 goto set_merge;
2189 mode = BEFORE; modename = "before"; modehelp = before_help;
2190 mmode = mode; curs.alt = 0;
2191 refresh = 3;
2192 break;
2193 case 'o': /* 'original' view in the merge window */
2194 if (mode == ORIG)
2195 goto set_merge;
2196 mode = ORIG; modename = "original"; modehelp = orig_help;
2197 mmode = mode; curs.alt = 0;
2198 refresh = 3;
2199 break;
2200 case 'r': /* the 'result' view in the merge window */
2201 if (mode == RESULT)
2202 goto set_merge;
2203 mode = RESULT; modename = "result"; modehelp = result_help;
2204 mmode = mode; curs.alt = 0;
2205 refresh = 3;
2206 break;
2207 case 'd':
2208 if (mode == (BEFORE|AFTER))
2209 goto set_merge;
2210 mode = BEFORE|AFTER; modename = "diff"; modehelp = diff_help;
2211 mmode = mode; curs.alt = 0;
2212 refresh = 3;
2213 break;
2214 case 'm':
2215 set_merge:
2216 mode = ORIG|RESULT; modename = "merge"; modehelp = merge_help;
2217 mmode = mode; curs.alt = 0;
2218 refresh = 3;
2219 break;
2220
2221 case '|':
2222 if (mode == (ORIG|RESULT|BEFORE|AFTER))
2223 goto set_merge;
2224 mode = ORIG|RESULT|BEFORE|AFTER; modename = "sidebyside"; modehelp = sidebyside_help;
2225 mmode = mode; curs.alt = 0;
2226 refresh = 3;
2227 break;
2228
2229 case 'H': /* scroll window to the right */
2230 if (start > 0)
2231 start--;
2232 curs.target = start + 1;
2233 refresh = 1;
2234 break;
2235 case 'L': /* scroll window to the left */
2236 if (start < cols)
2237 start++;
2238 curs.target = start + 1;
2239 refresh = 1;
2240 break;
2241
2242 case 'x': /* Toggle rejecting of conflict.
2243 * A 'Conflict' or 'Changed' becomes 'Unchanged'
2244 * 'Unmatched' becomes 'Changed'
2245 */
2246 if (ci.merger[curs.pos.m].oldtype == Conflict ||
2247 ci.merger[curs.pos.m].oldtype == Changed)
2248 next = Unchanged;
2249 else if (ci.merger[curs.pos.m].oldtype == Unmatched)
2250 next = Changed;
2251 else
2252 break;
2253
2254 if (ci.merger[curs.pos.m].type == next)
2255 ci.merger[curs.pos.m].type = ci.merger[curs.pos.m].oldtype;
2256 else
2257 ci.merger[curs.pos.m].type = next;
2258 p->conflicts = isolate_conflicts(
2259 fm, fb, fa, csl1, csl2, 0,
2260 ci.merger, 0, &p->wiggles);
2261 refresh = 1;
2262 changes = 1;
2263 break;
2264
2265 case 'c': /* Toggle accepting of conflict.
2266 * A 'Conflict' or 'Extraneous' becomes 'Changed'
2267 */
2268 if (ci.merger[curs.pos.m].oldtype != Conflict &&
2269 ci.merger[curs.pos.m].oldtype != Extraneous)
2270 break;
2271
2272 if (ci.merger[curs.pos.m].type == Changed)
2273 ci.merger[curs.pos.m].type = ci.merger[curs.pos.m].oldtype;
2274 else
2275 ci.merger[curs.pos.m].type = Changed;
2276 p->conflicts = isolate_conflicts(
2277 fm, fb, fa, csl1, csl2, 0,
2278 ci.merger, 0, &p->wiggles);
2279 refresh = 1;
2280 changes = 1;
2281 break;
2282
2283 case 'X': /* Reset all changes on the current line */
2284 tpos = pos;
2285 do {
2286 ci.merger[tpos.p.m].type =
2287 ci.merger[tpos.p.m].oldtype;
2288 e = prev_melmnt(&tpos.p, fm, fb, fa, ci.merger);
2289 if (tpos.p.m < 0)
2290 break;
2291 } while (!ends_line(e) ||
2292 visible(mode & (RESULT|AFTER), ci.merger, &tpos) < 0);
2293 p->conflicts = isolate_conflicts(
2294 fm, fb, fa, csl1, csl2, 0,
2295 ci.merger, 0, &p->wiggles);
2296 refresh = 1;
2297 changes = 1;
2298 break;
2299
2300 case '?':
2301 help_window(modehelp, merge_window_help, 0);
2302 refresh = 2;
2303 break;
2304
2305 case KEY_RESIZE:
2306 refresh = 2;
2307 break;
2308 }
2309
2310 if (meta == SEARCH(0)) {
2311 if (anchor == NULL ||
2312 !same_mpos(anchor->pos, pos) ||
2313 anchor->searchlen != searchlen ||
2314 !same_mp(anchor->curs.pos, curs.pos)) {
2315 struct search_anchor *a = xmalloc(sizeof(*a));
2316 a->pos = pos;
2317 a->row = row;
2318 a->start = start;
2319 a->curs = curs;
2320 a->searchlen = searchlen;
2321 a->notfound = search_notfound;
2322 a->next = anchor;
2323 anchor = a;
2324 }
2325 } else {
2326 while (anchor) {
2327 struct search_anchor *a = anchor;
2328 anchor = a->next;
2329 free(a);
2330 }
2331 }
2332 if (refresh == 3) {
2333 /* move backward and forward to make sure we
2334 * are on a visible line
2335 */
2336 tpos = pos;
2337 prev_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2338 if (tpos.p.m >= 0)
2339 pos = tpos;
2340 tpos = pos;
2341 next_mline(&tpos, fm, fb, fa, ci.merger, mmode);
2342 if (ci.merger[tpos.p.m].type != End)
2343 pos = tpos;
2344 }
2345 }
2346 }
2347
2348 static int show_merge(char *origname, FILE *patch, int reverse,
2349 int is_merge, char *before, char *after,
2350 int replace, char *outfile,
2351 int selftest, int ignore_blanks,
2352 int just_diff, int backup)
2353 {
2354 struct plist p = {0};
2355
2356 p.file = origname;
2357 p.outfile = replace ? outfile : NULL;
2358 if (patch) {
2359 p.start = 0;
2360 fseek(patch, 0, SEEK_END);
2361 p.end = ftell(patch);
2362 fseek(patch, 0, SEEK_SET);
2363 }
2364 p.calced = 0;
2365 p.is_merge = is_merge;
2366 p.before = before;
2367 p.after = after;
2368
2369 freopen("/dev/null","w",stderr);
2370 return merge_window(&p, patch, reverse, replace, selftest,
2371 ignore_blanks, just_diff, backup);
2372 }
2373
2374 static void calc_one(struct plist *pl, FILE *f, int reverse,
2375 int ignore_blanks, int just_diff)
2376 {
2377 struct stream s1, s2;
2378 struct stream s = load_segment(f, pl->start, pl->end);
2379 struct stream sf;
2380 if (pl->is_merge) {
2381 if (reverse)
2382 split_merge(s, &sf, &s2, &s1);
2383 else
2384 split_merge(s, &sf, &s1, &s2);
2385 pl->chunks = 0;
2386 } else {
2387 if (reverse)
2388 pl->chunks = split_patch(s, &s2, &s1);
2389 else
2390 pl->chunks = split_patch(s, &s1, &s2);
2391 if (just_diff)
2392 sf = s1;
2393 else
2394 sf = load_file(pl->file);
2395 }
2396 if (sf.body == NULL || s1.body == NULL || s1.body == NULL) {
2397 pl->wiggles = pl->conflicts = -1;
2398 } else {
2399 struct file ff, fp1, fp2;
2400 struct csl *csl1, *csl2;
2401 struct ci ci;
2402 ff = split_stream(sf, ByWord | ignore_blanks);
2403 fp1 = split_stream(s1, ByWord | ignore_blanks);
2404 fp2 = split_stream(s2, ByWord | ignore_blanks);
2405 if (pl->chunks && !just_diff)
2406 csl1 = pdiff(ff, fp1, pl->chunks);
2407 else
2408 csl1 = diff(ff, fp1, 1);
2409 csl2 = diff_patch(fp1, fp2, 1);
2410 ci = make_merger(ff, fp1, fp2, csl1, csl2, 0, 1, 0);
2411 pl->wiggles = ci.wiggles;
2412 pl->conflicts = ci.conflicts;
2413 free(ci.merger);
2414 free(csl1);
2415 free(csl2);
2416 free(ff.list);
2417 free(fp1.list);
2418 free(fp2.list);
2419 }
2420
2421 free(s1.body);
2422 free(s2.body);
2423 free(s.body);
2424 if (!just_diff)
2425 free(sf.body);
2426 pl->calced = 1;
2427 }
2428
2429 static int get_prev(int pos, struct plist *pl, int n, int mode)
2430 {
2431 int found = 0;
2432 if (pos == -1 || pl == NULL)
2433 return pos;
2434 do {
2435 if (pl[pos].prev == -1)
2436 return pl[pos].parent;
2437 pos = pl[pos].prev;
2438 while (pl[pos].open &&
2439 pl[pos].last >= 0)
2440 pos = pl[pos].last;
2441 if (pl[pos].last >= 0)
2442 /* always see directories */
2443 found = 1;
2444 else if (mode == 0)
2445 found = 1;
2446 else if (mode <= 1 && pl[pos].wiggles > 0)
2447 found = 1;
2448 else if (mode <= 2 && pl[pos].conflicts > 0)
2449 found = 1;
2450 } while (pos >= 0 && !found);
2451 return pos;
2452 }
2453
2454 static int get_next(int pos, struct plist *pl, int n, int mode,
2455 FILE *f, int reverse, int ignore_blanks, int just_diff)
2456 {
2457 int found = 0;
2458 if (pos == -1)
2459 return pos;
2460 do {
2461 if (pl[pos].open) {
2462 if (pos + 1 < n)
2463 pos = pos+1;
2464 else
2465 return -1;
2466 } else {
2467 while (pos >= 0 && pl[pos].next == -1)
2468 pos = pl[pos].parent;
2469 if (pos >= 0)
2470 pos = pl[pos].next;
2471 }
2472 if (pos < 0)
2473 return -1;
2474 if (pl[pos].calced == 0 && pl[pos].end)
2475 calc_one(pl+pos, f, reverse, ignore_blanks, just_diff);
2476 if (pl[pos].last >= 0)
2477 /* always see directories */
2478 found = 1;
2479 else if (mode == 0)
2480 found = 1;
2481 else if (mode <= 1 && pl[pos].wiggles > 0)
2482 found = 1;
2483 else if (mode <= 2 && pl[pos].conflicts > 0)
2484 found = 1;
2485 } while (pos >= 0 && !found);
2486 return pos;
2487 }
2488
2489 static void draw_one(int row, struct plist *pl, FILE *f, int reverse,
2490 int ignore_blanks, int just_diff)
2491 {
2492 char hdr[2*12];
2493 hdr[0] = 0;
2494
2495 if (pl == NULL) {
2496 move(row, 0);
2497 clrtoeol();
2498 return;
2499 }
2500 if (pl->calced == 0 && pl->end)
2501 /* better load the patch and count the chunks */
2502 calc_one(pl, f, reverse, ignore_blanks, just_diff);
2503 if (pl->end == 0) {
2504 strcpy(hdr, " ");
2505 } else {
2506 if (pl->chunks > 99)
2507 strcpy(hdr, "XX");
2508 else
2509 sprintf(hdr, "%2d", pl->chunks);
2510 if (pl->wiggles > 99)
2511 strcpy(hdr+2, " XX");
2512 else
2513 sprintf(hdr+2, " %2d", pl->wiggles);
2514 if (pl->conflicts > 99)
2515 strcpy(hdr+5, " XX ");
2516 else
2517 sprintf(hdr+5, " %2d ", pl->conflicts);
2518 }
2519 if (pl->end)
2520 strcpy(hdr+9, "= ");
2521 else if (pl->open)
2522 strcpy(hdr+9, "+ ");
2523 else
2524 strcpy(hdr+9, "- ");
2525
2526 if (!pl->end)
2527 attrset(0);
2528 else if (pl->is_merge)
2529 attrset(a_saved);
2530 else if (pl->conflicts)
2531 attrset(a_has_conflicts);
2532 else if (pl->wiggles)
2533 attrset(a_has_wiggles);
2534 else
2535 attrset(a_no_wiggles);
2536
2537 mvaddstr(row, 0, hdr);
2538 mvaddstr(row, 11, pl->file);
2539 clrtoeol();
2540 }
2541
2542 static int save_one(FILE *f, struct plist *pl, int reverse,
2543 int ignore_blanks, int backup)
2544 {
2545 struct stream sp, sa, sb, sm;
2546 struct file fa, fb, fm;
2547 struct csl *csl1, *csl2;
2548 struct ci ci;
2549 int chunks;
2550 sp = load_segment(f, pl->start,
2551 pl->end);
2552 if (reverse)
2553 chunks = split_patch(sp, &sa, &sb);
2554 else
2555 chunks = split_patch(sp, &sb, &sa);
2556 fb = split_stream(sb, ByWord | ignore_blanks);
2557 fa = split_stream(sa, ByWord | ignore_blanks);
2558 sm = load_file(pl->file);
2559 fm = split_stream(sm, ByWord | ignore_blanks);
2560 csl1 = pdiff(fm, fb, chunks);
2561 csl2 = diff_patch(fb, fa, 1);
2562 ci = make_merger(fm, fb, fa, csl1, csl2, 0, 1, 0);
2563 return save_merge(fm, fb, fa, ci.merger,
2564 pl->file, backup);
2565 }
2566
2567 static char *main_help[] = {
2568 " You are using the \"browse\" mode of wiggle.",
2569 "This page shows a list of files in a patch together with",
2570 "the directories that contain them.",
2571 "A directory is indicated by a '+' if the contents are",
2572 "listed or a '-' if the contents are hidden. A file is",
2573 "indicated by an '='. Typing <space> or <return> will",
2574 "expose or hide a directory, and will visit a file.",
2575 "",
2576 "The three columns of numbers are:",
2577 " Ch The number of patch chunks which applied to",
2578 " this file",
2579 " Wi The number of chunks that needed to be wiggled",
2580 " in to place",
2581 " Co The number of chunks that created an unresolvable",
2582 " conflict",
2583 "",
2584 "Keystrokes recognised in this page are:",
2585 " ? Display this help",
2586 " SPC On a directory, toggle hiding of contents",
2587 " On file, visit the file",
2588 " RTN Same as SPC",
2589 " q Quit program",
2590 " control-C Disable auto-save-on-exit",
2591 " n,j,DOWN Go to next line",
2592 " p,k,UP Go to previous line",
2593 "",
2594 " A list All files",
2595 " W only list files with a wiggle or a conflict",
2596 " C only list files with a conflict",
2597 "",
2598 " S Save this file with changes applied. If",
2599 " some but not all files are saved, wiggle will",
2600 " prompt on exit to save the rest.",
2601 " R Revert the current saved file to its original",
2602 " content",
2603 " I toggle whether spaces are ignored",
2604 " when matching text.",
2605 NULL
2606 };
2607 static char *saveall_msg = " %d file%s (of %d) have not been saved.";
2608 static char saveall_buf[200];
2609 static char *saveall_query[] = {
2610 "",
2611 saveall_buf,
2612 " Would you like to save them?",
2613 " Y = yes, save them all",
2614 " N = no, exit without saving anything else",
2615 " Q = Don't quit just yet",
2616 NULL
2617 };
2618 static void main_window(struct plist *pl, int np, FILE *f, int reverse,
2619 int replace, int ignore_blanks, int just_diff, int backup)
2620 {
2621 /* The main window lists all files together with summary information:
2622 * number of chunks, number of wiggles, number of conflicts.
2623 * The list is scrollable
2624 * When a entry is 'selected', we switch to the 'file' window
2625 * The list can be condensed by removing files with no conflict
2626 * or no wiggles, or removing subdirectories
2627 *
2628 * We record which file in the list is 'current', and which
2629 * screen line it is on. We try to keep things stable while
2630 * moving.
2631 *
2632 * Counts are printed before the name using at most 2 digits.
2633 * Numbers greater than 99 are XX
2634 * Ch Wi Co File
2635 * 27 5 1 drivers/md/md.c
2636 *
2637 * A directory show the sum in all children.
2638 *
2639 * Commands:
2640 * select: enter, space, mouseclick
2641 * on file, go to file window
2642 * on directory, toggle open
2643 * up: k, p, control-p uparrow
2644 * Move to previous open object
2645 * down: j, n, control-n, downarrow
2646 * Move to next open object
2647 *
2648 * A W C: select All Wiggles or Conflicts
2649 * mode
2650 *
2651 */
2652 char *mesg = NULL;
2653 char mesg_buf[1024];
2654 int last_mesg_len = 0;
2655 int pos = 0; /* position in file */
2656 int row = 1; /* position on screen */
2657 int rows = 0; /* size of screen in rows */
2658 int cols = 0;
2659 int tpos, i;
2660 int refresh = 2;
2661 int c = 0;
2662 int mode = 0; /* 0=all, 1= only wiggled, 2=only conflicted */
2663 int cnt; /* count of files that need saving */
2664 int any; /* count of files that have been save*/
2665 int ans;
2666 MEVENT mevent;
2667 char *debug = getenv("WIGGLE_DEBUG");
2668
2669 if (debug && !*debug)
2670 debug = NULL;
2671
2672 freopen("/dev/null","w",stderr);
2673 term_init(1);
2674
2675 while (1) {
2676 if (refresh == 2) {
2677 clear(); (void)attrset(0);
2678 attron(A_BOLD);
2679 mvaddstr(0, 0, "Ch Wi Co Patched Files");
2680 attroff(A_BOLD);
2681 if (ignore_blanks)
2682 addstr(" (ignoring blanks)");
2683 move(2, 0);
2684 refresh = 1;
2685 }
2686 if (row < 1 || row >= rows)
2687 refresh = 1;
2688 if (refresh) {
2689 refresh = 0;
2690 getmaxyx(stdscr, rows, cols);
2691
2692 if (row >= rows + 3)
2693 row = (rows+1)/2;
2694 if (row >= rows)
2695 row = rows-1;
2696 tpos = pos;
2697 for (i = row; i > 1; i--) {
2698 tpos = get_prev(tpos, pl, np, mode);
2699 if (tpos == -1) {
2700 row = row - i + 1;
2701 break;
2702 }
2703 }
2704 /* Ok, row and pos could be trustworthy now */
2705 tpos = pos;
2706 for (i = row; i >= 1; i--) {
2707 draw_one(i, &pl[tpos], f, reverse, ignore_blanks, just_diff);
2708 tpos = get_prev(tpos, pl, np, mode);
2709 }
2710 tpos = pos;
2711 for (i = row+1; i < rows; i++) {
2712 tpos = get_next(tpos, pl, np, mode, f, reverse,ignore_blanks, just_diff);
2713 if (tpos >= 0)
2714 draw_one(i, &pl[tpos], f, reverse, ignore_blanks, just_diff);
2715 else
2716 draw_one(i, NULL, f, reverse, ignore_blanks, just_diff);
2717 }
2718 }
2719 attrset(0);
2720 if (last_mesg_len) {
2721 move(0, cols - last_mesg_len);
2722 clrtoeol();
2723 last_mesg_len = 0;
2724 }
2725 if (mesg) {
2726 last_mesg_len = strlen(mesg);
2727 move(0, cols - last_mesg_len);
2728 addstr(mesg);
2729 mesg = NULL;
2730 } else if (debug) {
2731 /* debugging help: report last keystroke */
2732 char bb[30];
2733 sprintf(bb, "last-key = 0%o", c);
2734 attrset(0);
2735 last_mesg_len = strlen(bb);
2736 mvaddstr(0, cols - last_mesg_len, bb);
2737 }
2738 move(row, 9);
2739 c = getch();
2740 switch (c) {
2741 case 'j':
2742 case 'n':
2743 case 'N':
2744 case 'N'-64:
2745 case KEY_DOWN:
2746 tpos = get_next(pos, pl, np, mode, f, reverse, ignore_blanks, just_diff);
2747 if (tpos >= 0) {
2748 pos = tpos;
2749 row++;
2750 }
2751 break;
2752 case 'k':
2753 case 'p':
2754 case 'P':
2755 case 'P'-64:
2756 case KEY_UP:
2757 tpos = get_prev(pos, pl, np, mode);
2758 if (tpos >= 0) {
2759 pos = tpos;
2760 row--;
2761 }
2762 break;
2763
2764 case KEY_MOUSE:
2765 if (getmouse(&mevent) != OK)
2766 break;
2767 while (row < mevent.y &&
2768 (tpos = get_next(pos, pl, np, mode, f, reverse, ignore_blanks, just_diff))
2769 >= 0) {
2770 pos = tpos;
2771 row++;
2772 }
2773 while (row > mevent.y &&
2774 (tpos = get_prev(pos, pl, np, mode)) >= 0) {
2775 pos = tpos;
2776 row--;
2777 }
2778 if (row != mevent.y)
2779 /* couldn't find the line */
2780 break;
2781 /* FALL THROUGH */
2782 case ' ':
2783 case 13:
2784 if (pl[pos].end == 0) {
2785 pl[pos].open = !pl[pos].open;
2786 refresh = 1;
2787 if (pl[pos].open)
2788 mesg = "Opened folder";
2789 else
2790 mesg = "Closed folder";
2791 } else {
2792 int c;
2793 if (pl[pos].is_merge)
2794 c = merge_window(&pl[pos], NULL, reverse, 0, 0,
2795 ignore_blanks, just_diff, backup);
2796 else
2797 c = merge_window(&pl[pos], f, reverse, 0, 0,
2798 ignore_blanks, just_diff, backup);
2799 refresh = 2;
2800 if (c) {
2801 pl[pos].is_merge = 1;
2802 snprintf(mesg_buf, cols,
2803 "Saved file %s.",
2804 pl[pos].file);
2805 mesg = mesg_buf;
2806 }
2807 }
2808 break;
2809 case 27: /* escape */
2810 attrset(0);
2811 mvaddstr(0, cols-10, "ESC..."); clrtoeol();
2812 c = getch();
2813 switch (c) {
2814 }
2815 move(0, cols-10); clrtoeol();
2816 break;
2817 case 'C'-64:
2818 if (replace)
2819 mesg = "Save-on-exit disabled. Use 'q' to quit.";
2820 else
2821 mesg = "Use 'q' to quit.";
2822 replace = 0;
2823 break;
2824
2825 case 'q':
2826 cnt = 0;
2827 any = 0;
2828 for (i = 0; i < np; i++)
2829 if (pl[i].end && !pl[i].is_merge)
2830 cnt++;
2831 else if (pl[i].end)
2832 any++;
2833 if (!cnt) {
2834 endwin();
2835 return;
2836 }
2837 refresh = 2;
2838 if (replace)
2839 ans = 1;
2840 else if (any) {
2841 sprintf(saveall_buf, saveall_msg,
2842 cnt, cnt == 1 ? "" : "s", cnt+any);
2843 ans = help_window(saveall_query, NULL, 1);
2844 } else
2845 ans = 0;
2846 if (ans < 0)
2847 break;
2848 if (ans) {
2849 for (i = 0; i < np; i++) {
2850 if (pl[i].end
2851 && !pl[i].is_merge)
2852 save_one(f, &pl[i],
2853 reverse,
2854 ignore_blanks, backup);
2855 }
2856 } else
2857 cnt = 0;
2858 endwin();
2859 if (cnt)
2860 printf("%d file%s saved\n", cnt,
2861 cnt == 1 ? "" : "s");
2862 return;
2863
2864 case 'A':
2865 mode = 0; refresh = 1;
2866 mesg = "Showing ALL files";
2867 break;
2868 case 'W':
2869 mode = 1; refresh = 1;
2870 mesg = "Showing Wiggled files";
2871 break;
2872 case 'C':
2873 mode = 2; refresh = 1;
2874 mesg = "Showing Conflicted files";
2875 break;
2876
2877 case 'S': /* Save updated file */
2878 if (pl[pos].end == 0) {
2879 /* directory */
2880 mesg = "Cannot save a folder.";
2881 } else if (pl[pos].is_merge) {
2882 /* Already saved */
2883 mesg = "File is already saved.";
2884 } else {
2885 if (save_one(f, &pl[pos], reverse, ignore_blanks, backup) == 0) {
2886 pl[pos].is_merge = 1;
2887 snprintf(mesg_buf, cols,
2888 "Saved file %s.",
2889 pl[pos].file);
2890 pl[pos].chunks = pl[pos].conflicts;
2891 pl[pos].wiggles = 0;
2892 } else
2893 snprintf(mesg_buf, cols,
2894 "Failed to save file %s.",
2895 pl[pos].file);
2896 mesg = mesg_buf;
2897 refresh = 1;
2898 }
2899 break;
2900
2901 case 'R': /* Restore updated file */
2902 if (pl[pos].end == 0)
2903 mesg = "Cannot restore a folder.";
2904 else if (!pl[pos].is_merge)
2905 mesg = "File has not been saved, cannot restore.";
2906 else if (!backup)
2907 mesg = "Backups are disabled, nothing to restore!";
2908 else {
2909 /* rename foo.porig to foo, and clear is_merge */
2910 char *file = pl[pos].file;
2911 char *orignew = xmalloc(strlen(file) + 20);
2912 strcpy(orignew, file);
2913 strcat(orignew, ".porig");
2914 if (rename(orignew, file) == 0) {
2915 mesg = "File has been restored.";
2916 pl[pos].is_merge = 0;
2917 refresh = 1;
2918 calc_one(&pl[pos], f, reverse, ignore_blanks, just_diff);
2919 } else
2920 mesg = "Could not restore file!";
2921 }
2922 break;
2923
2924 case 'I': /* Toggle ignoring blanks */
2925 ignore_blanks = ignore_blanks ? 0 : IgnoreBlanks;
2926 refresh = 2;
2927 for (i = 0; i < np; i++)
2928 pl[i].calced = 0;
2929 break;
2930
2931 case '?':
2932 help_window(main_help, NULL, 0);
2933 refresh = 2;
2934 break;
2935
2936 case KEY_RESIZE:
2937 refresh = 2;
2938 break;
2939 }
2940 }
2941 }
2942
2943 static void catch(int sig)
2944 {
2945 if (sig == SIGINT && !intr_kills) {
2946 signal(sig, catch);
2947 return;
2948 }
2949 noraw();
2950 nl();
2951 endwin();
2952 printf("Died on signal %d\n", sig);
2953 fflush(stdout);
2954 if (sig != SIGBUS && sig != SIGSEGV)
2955 exit(2);
2956 else
2957 /* Otherwise return and die */
2958 signal(sig, NULL);
2959 }
2960
2961 static void term_init(int doraw)
2962 {
2963
2964 static int init_done = 0;
2965
2966 if (init_done)
2967 return;
2968 init_done = 1;
2969
2970 signal(SIGINT, catch);
2971 signal(SIGQUIT, catch);
2972 signal(SIGTERM, catch);
2973 signal(SIGBUS, catch);
2974 signal(SIGSEGV, catch);
2975
2976 initscr();
2977 if (doraw)
2978 raw();
2979 else
2980 cbreak();
2981 noecho();
2982 start_color();
2983 use_default_colors();
2984 if (!has_colors()) {
2985 a_delete = A_UNDERLINE;
2986 a_added = A_BOLD;
2987 a_common = A_NORMAL;
2988 a_sep = A_STANDOUT;
2989 a_already = A_STANDOUT;
2990 a_has_conflicts = A_UNDERLINE;
2991 a_has_wiggles = A_BOLD;
2992 a_no_wiggles = A_NORMAL;
2993 } else {
2994 init_pair(1, COLOR_RED, -1);
2995 a_delete = COLOR_PAIR(1);
2996 init_pair(2, COLOR_GREEN, -1);
2997 a_added = COLOR_PAIR(2);
2998 a_common = A_NORMAL;
2999 init_pair(3, COLOR_WHITE, COLOR_GREEN);
3000 a_sep = COLOR_PAIR(3); a_sep = A_STANDOUT;
3001 init_pair(4, -1, COLOR_YELLOW);
3002 a_void = COLOR_PAIR(4);
3003 init_pair(5, COLOR_BLUE, -1);
3004 a_unmatched = COLOR_PAIR(5);
3005 init_pair(6, COLOR_CYAN, -1);
3006 a_extra = COLOR_PAIR(6);
3007
3008 init_pair(7, COLOR_BLACK, COLOR_CYAN);
3009 a_already = COLOR_PAIR(7);
3010
3011 a_has_conflicts = a_delete;
3012 a_has_wiggles = a_added;
3013 a_no_wiggles = a_unmatched;
3014 a_saved = a_extra;
3015 }
3016 nonl(); intrflush(stdscr, FALSE); keypad(stdscr, TRUE);
3017 mousemask(ALL_MOUSE_EVENTS, NULL);
3018 }
3019
3020 int vpatch(int argc, char *argv[], int patch, int strip,
3021 int reverse, int replace, char *outfilename,
3022 int selftest, int ignore_blanks, int backup)
3023 {
3024 /* NOTE argv[0] is first arg...
3025 * Behaviour depends on number of args and 'patch'.
3026 * If 'patch' is '1', assume a patch. if '2', assume a diff.
3027 * 0: A multi-file patch or diff is read from stdin.
3028 * A 'patch' is applies to relevant files. A 'diff' is just
3029 * displayed.
3030 * 1: if 'patch', parse it as a multi-file patch/diff and allow
3031 * the files to be browsed.
3032 * if filename ends '.rej', then treat it as a patch/diff again
3033 * a file with the same basename
3034 * Else treat the file as a merge (with conflicts) and view it.
3035 *
3036 * 2: First file is original, second is patch unless patch==2,
3037 * then two files need to be diffed.
3038 * 3: Files are: original previous new. The diff between 'previous' and
3039 * 'new' needs to be applied to 'original'.
3040 *
3041 * If a multi-file patch is being read, 'strip' tells how many
3042 * path components to strip. If it is -1, we guess based on
3043 * existing files.
3044 * If 'reverse' is given, when we invert any patch or diff
3045 * If 'replace' then we save the resulting merge.
3046 */
3047 FILE *in;
3048 FILE *f;
3049 struct plist *pl;
3050 int num_patches;
3051 int just_diff = (patch == 2);
3052
3053 switch (argc) {
3054 default:
3055 fprintf(stderr, "%s: too many file names given.\n", Cmd);
3056 exit(1);
3057
3058 case 0: /* stdin is a patch or diff */
3059 if (lseek(fileno(stdin), 0L, 1) == -1) {
3060 /* cannot seek, so need to copy to a temp file */
3061 f = tmpfile();
3062 if (!f) {
3063 fprintf(stderr, "%s: Cannot create temp file\n", Cmd);
3064 exit(1);
3065 }
3066 pl = parse_patch(stdin, f, &num_patches);
3067 in = f;
3068 } else {
3069 pl = parse_patch(stdin, NULL, &num_patches);
3070 in = fdopen(dup(0), "r");
3071 }
3072 /* use stderr for keyboard input */
3073 dup2(2, 0);
3074 if (!just_diff &&
3075 set_prefix(pl, num_patches, strip) == 0) {
3076 fprintf(stderr, "%s: aborting\n", Cmd);
3077 exit(2);
3078 }
3079 pl = sort_patches(pl, &num_patches);
3080 main_window(pl, num_patches, in, reverse, replace, ignore_blanks,
3081 just_diff, backup);
3082 plist_free(pl, num_patches);
3083 fclose(in);
3084 break;
3085
3086 case 1: /* a patch/diff, a .rej, or a merge file */
3087 f = fopen(argv[0], "r");
3088 if (!f) {
3089 fprintf(stderr, "%s: cannot open %s\n", Cmd, argv[0]);
3090 exit(1);
3091 }
3092 check_dir(argv[0], fileno(f));
3093 if (patch) {
3094 pl = parse_patch(f, NULL, &num_patches);
3095 if (!just_diff && set_prefix(pl, num_patches, strip) == 0) {
3096 fprintf(stderr, "%s: aborting\n", Cmd);
3097 exit(2);
3098 }
3099 pl = sort_patches(pl, &num_patches);
3100 main_window(pl, num_patches, f, reverse, replace,
3101 ignore_blanks, just_diff, backup);
3102 plist_free(pl, num_patches);
3103 } else if (strlen(argv[0]) > 4 &&
3104 strcmp(argv[0]+strlen(argv[0])-4, ".rej") == 0) {
3105 char *origname = strdup(argv[0]);
3106 origname[strlen(origname) - 4] = '\0';
3107 show_merge(origname, f, reverse, 0, NULL, NULL,
3108 replace, outfilename,
3109 selftest, ignore_blanks, just_diff, backup);
3110 } else
3111 show_merge(argv[0], f, reverse, 1, NULL, NULL,
3112 replace, outfilename,
3113 selftest, ignore_blanks, just_diff, backup);
3114
3115 break;
3116 case 2: /* an orig and a diff/.rej or two files */
3117 if (just_diff) {
3118 show_merge(NULL, NULL, reverse, 0, argv[0], argv[1],
3119 replace, outfilename,
3120 selftest, ignore_blanks, just_diff, backup);
3121 break;
3122 }
3123 f = fopen(argv[1], "r");
3124 if (!f) {
3125 fprintf(stderr, "%s: cannot open %s\n", Cmd, argv[0]);
3126 exit(1);
3127 }
3128 check_dir(argv[1], fileno(f));
3129 show_merge(argv[0], f, reverse, 0, NULL, NULL,
3130 replace, outfilename,
3131 selftest, ignore_blanks, just_diff, backup);
3132 break;
3133 case 3: /* orig, before, after */
3134 show_merge(argv[0], NULL, reverse, 0, argv[1], argv[2],
3135 replace, outfilename,
3136 selftest, ignore_blanks, just_diff, backup);
3137 break;
3138 }
3139
3140 noraw();
3141 nl();
3142 endwin();
3143 exit(0);
3144 }