?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ticket 1551: Update GPL version from 2 to 3
[midnight-commander.git] / src / diffviewer / ydiff.c
blob4b7893b2e0ebf0d8d0d7028740917affae8f8e8a
1 /*
2 Copyright (C) 2007, 2010, 2011
3 The Free Software Foundation, Inc.
4
5 Written by:
6 Daniel Borca <dborca@yahoo.com>, 2007
7 Slava Zanko <slavazanko@gmail.com>, 2010
8 Andrew Borodin <aborodin@vmail.ru>, 2010
9 Ilia Maslakov <il.smind@gmail.com>, 2010
10
11 This file is part of the Midnight Commander.
12
13 The Midnight Commander is free software: you can redistribute it
14 and/or modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation, either version 3 of the License,
16 or (at your option) any later version.
17
18 The Midnight Commander is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 */
26
27
28 #include <config.h>
29 #include <ctype.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <stdlib.h>
33 #include <sys/stat.h>
34 #include <sys/types.h>
35 #include <sys/wait.h>
36
37 #include "lib/global.h"
38 #include "lib/tty/tty.h"
39 #include "lib/tty/color.h"
40 #include "lib/tty/key.h"
41 #include "lib/skin.h" /* EDITOR_NORMAL_COLOR */
42 #include "lib/vfs/vfs.h" /* mc_opendir, mc_readdir, mc_closedir, */
43 #include "lib/util.h"
44 #include "lib/widget.h"
45 #include "lib/charsets.h"
46 #include "lib/event.h" /* mc_event_raise() */
47
48 #include "src/filemanager/cmd.h"
49 #include "src/filemanager/midnight.h" /* Needed for current_panel and other_panel */
50 #include "src/filemanager/layout.h" /* Needed for get_current_index and get_other_panel */
51
52 #include "src/keybind-defaults.h"
53 #include "src/history.h"
54 #include "src/selcodepage.h"
55
56 #include "ydiff.h"
57 #include "internal.h"
58
59 /*** global variables ****************************************************************************/
60
61 /*** file scope macro definitions ****************************************************************/
62
63 #define g_array_foreach(a, TP, cbf) \
64 do { \
65 size_t g_array_foreach_i;\
66 TP *g_array_foreach_var=NULL; \
67 for (g_array_foreach_i=0;g_array_foreach_i < a->len; g_array_foreach_i++) \
68 { \
69 g_array_foreach_var = &g_array_index(a,TP,g_array_foreach_i); \
70 (*cbf) (g_array_foreach_var); \
71 } \
72 } while (0)
73
74 #define FILE_READ_BUF 4096
75 #define FILE_FLAG_TEMP (1 << 0)
76
77 #define OPTX 56
78 #define OPTY 17
79
80 #define ADD_CH '+'
81 #define DEL_CH '-'
82 #define CHG_CH '*'
83 #define EQU_CH ' '
84
85 #define HDIFF_ENABLE 1
86 #define HDIFF_MINCTX 5
87 #define HDIFF_DEPTH 10
88
89 #define FILE_DIRTY(fs) \
90 do \
91 { \
92 (fs)->pos = 0; \
93 (fs)->len = 0; \
94 } \
95 while (0)
96
97 /*** file scope type declarations ****************************************************************/
98
99 /*** file scope variables ************************************************************************/
100
101 /*** file scope functions ************************************************************************/
102 /* --------------------------------------------------------------------------------------------- */
103
104 static inline int
105 TAB_SKIP (int ts, int pos)
106 {
107 if (ts > 0 && ts < 9)
108 return ts - pos % ts;
109 else
110 return 8 - pos % 8;
111 }
112
113 /* --------------------------------------------------------------------------------------------- */
114
115 static void
116 dview_set_codeset (WDiff * dview)
117 {
118 #ifdef HAVE_CHARSET
119 const char *encoding_id = NULL;
120
121 dview->utf8 = TRUE;
122 encoding_id =
123 get_codepage_id (mc_global.source_codepage >=
124 0 ? mc_global.source_codepage : mc_global.display_codepage);
125 if (encoding_id != NULL)
126 {
127 GIConv conv;
128 conv = str_crt_conv_from (encoding_id);
129 if (conv != INVALID_CONV)
130 {
131 if (dview->converter != str_cnv_from_term)
132 str_close_conv (dview->converter);
133 dview->converter = conv;
134 }
135 dview->utf8 = (gboolean) str_isutf8 (encoding_id);
136 }
137 #else
138 (void) dview;
139 #endif
140 }
141
142 /* --------------------------------------------------------------------------------------------- */
143
144 static void
145 dview_select_encoding (WDiff * dview)
146 {
147 #ifdef HAVE_CHARSET
148 if (do_select_codepage ())
149 dview_set_codeset (dview);
150 #else
151 (void) dview;
152 #endif
153 }
154
155
156 static gboolean
157 rewrite_backup_content (const char *from_file_name, const char *to_file_name)
158 {
159 FILE *backup_fd;
160 char *contents;
161 gsize length;
162
163 if (!g_file_get_contents (from_file_name, &contents, &length, NULL))
164 return FALSE;
165
166 backup_fd = fopen (to_file_name, "w");
167 if (backup_fd == NULL)
168 {
169 g_free (contents);
170 return FALSE;
171 }
172
173 length = fwrite ((const void *) contents, length, 1, backup_fd);
174
175 fflush (backup_fd);
176 fclose (backup_fd);
177 g_free (contents);
178 return TRUE;
179 }
180
181 /* buffered I/O ************************************************************* */
182
183 /**
184 * Try to open a temporary file.
185 *
186 * \param[out] name address of a pointer to store the temporary name
187 *
188 * \return file descriptor on success, negative on error
189 *
190 * \note the name is not altered if this function fails
191 */
192
193 static int
194 open_temp (void **name)
195 {
196 int fd;
197 char *diff_file_name = NULL;
198
199 fd = mc_mkstemps (&diff_file_name, "mcdiff", NULL);
200 if (fd == -1)
201 {
202 message (D_ERROR, MSG_ERROR,
203 _("Cannot create temporary diff file\n%s"), unix_error_string (errno));
204 return -1;
205 }
206 *name = diff_file_name;
207 return fd;
208 }
209
210 /* --------------------------------------------------------------------------------------------- */
211
212 /**
213 * Alocate file structure and associate file descriptor to it.
214 *
215 * \param fd file descriptor
216 *
217 * \return file structure
218 */
219 static FBUF *
220 f_dopen (int fd)
221 {
222 FBUF *fs;
223
224 if (fd < 0)
225 return NULL;
226
227 fs = g_try_malloc (sizeof (FBUF));
228 if (fs == NULL)
229 return NULL;
230
231 fs->buf = g_try_malloc (FILE_READ_BUF);
232 if (fs->buf == NULL)
233 {
234 g_free (fs);
235 return NULL;
236 }
237
238 fs->fd = fd;
239 FILE_DIRTY (fs);
240 fs->flags = 0;
241 fs->data = NULL;
242
243 return fs;
244 }
245
246 /* --------------------------------------------------------------------------------------------- */
247
248 /**
249 * Free file structure without closing the file.
250 *
251 * \param fs file structure
252 *
253 * \return 0 on success, non-zero on error
254 */
255 static int
256 f_free (FBUF * fs)
257 {
258 int rv = 0;
259 if (fs->flags & FILE_FLAG_TEMP)
260 {
261 rv = unlink (fs->data);
262 g_free (fs->data);
263 }
264 g_free (fs->buf);
265 g_free (fs);
266 return rv;
267 }
268
269
270 /* --------------------------------------------------------------------------------------------- */
271
272 /**
273 * Open a binary temporary file in R/W mode.
274 *
275 * \return file structure
276 *
277 * \note the file will be deleted when closed
278 */
279 static FBUF *
280 f_temp (void)
281 {
282 int fd;
283 FBUF *fs;
284
285 fs = f_dopen (0);
286 if (fs == NULL)
287 {
288 return NULL;
289 }
290
291 fd = open_temp (&fs->data);
292 if (fd < 0)
293 {
294 f_free (fs);
295 return NULL;
296 }
297
298 fs->fd = fd;
299 fs->flags = FILE_FLAG_TEMP;
300 return fs;
301 }
302
303 /* --------------------------------------------------------------------------------------------- */
304
305 /**
306 * Open a binary file in specified mode.
307 *
308 * \param filename file name
309 * \param flags open mode, a combination of O_RDONLY, O_WRONLY, O_RDWR
310 *
311 * \return file structure
312 */
313 static FBUF *
314 f_open (const char *filename, int flags)
315 {
316 int fd;
317 FBUF *fs;
318
319 fs = f_dopen (0);
320 if (fs == NULL)
321 {
322 return NULL;
323 }
324
325 fd = open (filename, flags);
326 if (fd < 0)
327 {
328 f_free (fs);
329 return NULL;
330 }
331
332 fs->fd = fd;
333 return fs;
334 }
335
336 /* --------------------------------------------------------------------------------------------- */
337
338 /**
339 * Read a line of bytes from file until newline or EOF.
340 *
341 * \param buf destination buffer
342 * \param size size of buffer
343 * \param fs file structure
344 *
345 * \return number of bytes read
346 *
347 * \note does not stop on null-byte
348 * \note buf will not be null-terminated
349 */
350 static size_t
351 f_gets (char *buf, size_t size, FBUF * fs)
352 {
353 size_t j = 0;
354
355 do
356 {
357 int i;
358 int stop = 0;
359
360 for (i = fs->pos; j < size && i < fs->len && !stop; i++, j++)
361 {
362 buf[j] = fs->buf[i];
363 if (buf[j] == '\n')
364 {
365 stop = 1;
366 }
367 }
368 fs->pos = i;
369
370 if (j == size || stop)
371 {
372 break;
373 }
374
375 fs->pos = 0;
376 fs->len = read (fs->fd, fs->buf, FILE_READ_BUF);
377 }
378 while (fs->len > 0);
379
380 return j;
381 }
382
383 /* --------------------------------------------------------------------------------------------- */
384
385 /**
386 * Seek into file.
387 *
388 * \param fs file structure
389 * \param off offset
390 * \param whence seek directive: SEEK_SET, SEEK_CUR or SEEK_END
391 *
392 * \return position in file, starting from begginning
393 *
394 * \note avoids thrashing read cache when possible
395 */
396 static off_t
397 f_seek (FBUF * fs, off_t off, int whence)
398 {
399 off_t rv;
400
401 if (fs->len && whence != SEEK_END)
402 {
403 rv = lseek (fs->fd, 0, SEEK_CUR);
404 if (rv != -1)
405 {
406 if (whence == SEEK_CUR)
407 {
408 whence = SEEK_SET;
409 off += rv - fs->len + fs->pos;
410 }
411 if (off - rv >= -fs->len && off - rv <= 0)
412 {
413 fs->pos = fs->len + off - rv;
414 return off;
415 }
416 }
417 }
418
419 rv = lseek (fs->fd, off, whence);
420 if (rv != -1)
421 {
422 FILE_DIRTY (fs);
423 }
424 return rv;
425 }
426
427 /* --------------------------------------------------------------------------------------------- */
428
429 /**
430 * Seek to the beginning of file, thrashing read cache.
431 *
432 * \param fs file structure
433 *
434 * \return 0 if success, non-zero on error
435 */
436 static off_t
437 f_reset (FBUF * fs)
438 {
439 off_t rv = lseek (fs->fd, 0, SEEK_SET);
440 if (rv != -1)
441 {
442 FILE_DIRTY (fs);
443 }
444 return rv;
445 }
446
447 /* --------------------------------------------------------------------------------------------- */
448
449 /**
450 * Write bytes to file.
451 *
452 * \param fs file structure
453 * \param buf source buffer
454 * \param size size of buffer
455 *
456 * \return number of written bytes, -1 on error
457 *
458 * \note thrashes read cache
459 */
460 static ssize_t
461 f_write (FBUF * fs, const char *buf, size_t size)
462 {
463 ssize_t rv = write (fs->fd, buf, size);
464 if (rv >= 0)
465 {
466 FILE_DIRTY (fs);
467 }
468 return rv;
469 }
470
471 /* --------------------------------------------------------------------------------------------- */
472
473 /**
474 * Truncate file to the current position.
475 *
476 * \param fs file structure
477 *
478 * \return current file size on success, negative on error
479 *
480 * \note thrashes read cache
481 */
482 static off_t
483 f_trunc (FBUF * fs)
484 {
485 off_t off = lseek (fs->fd, 0, SEEK_CUR);
486 if (off != -1)
487 {
488 int rv = ftruncate (fs->fd, off);
489 if (rv != 0)
490 {
491 off = -1;
492 }
493 else
494 {
495 FILE_DIRTY (fs);
496 }
497 }
498 return off;
499 }
500
501 /* --------------------------------------------------------------------------------------------- */
502
503 /**
504 * Close file.
505 *
506 * \param fs file structure
507 *
508 * \return 0 on success, non-zero on error
509 *
510 * \note if this is temporary file, it is deleted
511 */
512 static int
513 f_close (FBUF * fs)
514 {
515 int rv = close (fs->fd);
516 f_free (fs);
517 return rv;
518 }
519
520 /* --------------------------------------------------------------------------------------------- */
521
522 /**
523 * Create pipe stream to process.
524 *
525 * \param cmd shell command line
526 * \param flags open mode, either O_RDONLY or O_WRONLY
527 *
528 * \return file structure
529 */
530 static FBUF *
531 p_open (const char *cmd, int flags)
532 {
533 FILE *f;
534 FBUF *fs;
535 const char *type = NULL;
536
537 if (flags == O_RDONLY)
538 {
539 type = "r";
540 }
541 if (flags == O_WRONLY)
542 {
543 type = "w";
544 }
545
546 if (type == NULL)
547 {
548 return NULL;
549 }
550
551 fs = f_dopen (0);
552 if (fs == NULL)
553 {
554 return NULL;
555 }
556
557 f = popen (cmd, type);
558 if (f == NULL)
559 {
560 f_free (fs);
561 return NULL;
562 }
563
564 fs->fd = fileno (f);
565 fs->data = f;
566 return fs;
567 }
568
569 /* --------------------------------------------------------------------------------------------- */
570
571 /**
572 * Close pipe stream.
573 *
574 * \param fs structure
575 *
576 * \return 0 on success, non-zero on error
577 */
578 static int
579 p_close (FBUF * fs)
580 {
581 int rv = pclose (fs->data);
582 f_free (fs);
583 return rv;
584 }
585
586 /**
587 * Get one char (byte) from string
588 *
589 * \param char * str, gboolean * result
590 *
591 * \return int as character or 0 and result == FALSE if fail
592 */
593
594 static int
595 dview_get_byte (char *str, gboolean * result)
596 {
597 if (str == NULL)
598 {
599 *result = FALSE;
600 return 0;
601 }
602 *result = TRUE;
603 return (unsigned char) *str;
604 }
605
606
607 /**
608 * Get utf multibyte char from string
609 *
610 * \param char * str, int * char_width, gboolean * result
611 *
612 * \return int as utf character or 0 and result == FALSE if fail
613 */
614
615 static int
616 dview_get_utf (char *str, int *char_width, gboolean * result)
617 {
618 int res = -1;
619 gunichar ch;
620 gchar *next_ch = NULL;
621 int width = 0;
622
623 *result = TRUE;
624
625 if (str == NULL)
626 {
627 *result = FALSE;
628 width = 0;
629 return 0;
630 }
631
632 res = g_utf8_get_char_validated (str, -1);
633
634 if (res < 0)
635 {
636 ch = *str;
637 width = 0;
638 }
639 else
640 {
641 ch = res;
642 /* Calculate UTF-8 char width */
643 next_ch = g_utf8_next_char (str);
644 if (next_ch)
645 {
646 width = next_ch - str;
647 }
648 else
649 {
650 ch = 0;
651 width = 0;
652 }
653 }
654 *char_width = width;
655 return ch;
656 }
657
658 static int
659 dview_str_utf8_offset_to_pos (const char *text, size_t length)
660 {
661 ptrdiff_t result;
662 if (text == NULL || text[0] == '\0')
663 return length;
664 if (g_utf8_validate (text, -1, NULL))
665 {
666 result = g_utf8_offset_to_pointer (text, length) - text;
667 }
668 else
669 {
670 gunichar uni;
671 char *tmpbuf, *buffer;
672 buffer = tmpbuf = g_strdup (text);
673 while (tmpbuf[0] != '\0')
674 {
675 uni = g_utf8_get_char_validated (tmpbuf, -1);
676 if ((uni != (gunichar) (-1)) && (uni != (gunichar) (-2)))
677 {
678 tmpbuf = g_utf8_next_char (tmpbuf);
679 }
680 else
681 {
682 tmpbuf[0] = '.';
683 tmpbuf++;
684 }
685
686 }
687 result = g_utf8_offset_to_pointer (tmpbuf, length) - tmpbuf;
688 g_free (buffer);
689 }
690 return max (length, (size_t) result);
691 }
692
693
694 /* --------------------------------------------------------------------------------------------- */
695 /* diff parse *************************************************************** */
696
697 /**
698 * Read decimal number from string.
699 *
700 * \param[in,out] str string to parse
701 * \param[out] n extracted number
702 *
703 * \return 0 if success, otherwise non-zero
704 */
705 static int
706 scan_deci (const char **str, int *n)
707 {
708 const char *p = *str;
709 char *q;
710 errno = 0;
711 *n = strtol (p, &q, 10);
712 if (errno || p == q)
713 {
714 return -1;
715 }
716 *str = q;
717 return 0;
718 }
719
720 /* --------------------------------------------------------------------------------------------- */
721
722 /**
723 * Parse line for diff statement.
724 *
725 * \param p string to parse
726 * \param ops list of diff statements
727 *
728 * \return 0 if success, otherwise non-zero
729 */
730 static int
731 scan_line (const char *p, GArray * ops)
732 {
733 DIFFCMD op;
734
735 int f1, f2;
736 int t1, t2;
737 int cmd;
738
739 int range;
740
741 /* handle the following cases:
742 * NUMaNUM[,NUM]
743 * NUM[,NUM]cNUM[,NUM]
744 * NUM[,NUM]dNUM
745 * where NUM is a positive integer
746 */
747
748 if (scan_deci (&p, &f1) != 0 || f1 < 0)
749 {
750 return -1;
751 }
752 f2 = f1;
753 range = 0;
754 if (*p == ',')
755 {
756 p++;
757 if (scan_deci (&p, &f2) != 0 || f2 < f1)
758 {
759 return -1;
760 }
761 range = 1;
762 }
763
764 cmd = *p++;
765 if (cmd == 'a')
766 {
767 if (range)
768 {
769 return -1;
770 }
771 }
772 else if (cmd != 'c' && cmd != 'd')
773 {
774 return -1;
775 }
776
777 if (scan_deci (&p, &t1) != 0 || t1 < 0)
778 {
779 return -1;
780 }
781 t2 = t1;
782 range = 0;
783 if (*p == ',')
784 {
785 p++;
786 if (scan_deci (&p, &t2) != 0 || t2 < t1)
787 {
788 return -1;
789 }
790 range = 1;
791 }
792
793 if (cmd == 'd')
794 {
795 if (range)
796 {
797 return -1;
798 }
799 }
800
801 op.a[0][0] = f1;
802 op.a[0][1] = f2;
803 op.cmd = cmd;
804 op.a[1][0] = t1;
805 op.a[1][1] = t2;
806 g_array_append_val (ops, op);
807 return 0;
808 }
809
810 /* --------------------------------------------------------------------------------------------- */
811
812 /**
813 * Parse diff output and extract diff statements.
814 *
815 * \param f stream to read from
816 * \param ops list of diff statements to fill
817 *
818 * \return positive number indicating number of hunks, otherwise negative
819 */
820 static int
821 scan_diff (FBUF * f, GArray * ops)
822 {
823 int sz;
824 char buf[BUFSIZ];
825
826 while ((sz = f_gets (buf, sizeof (buf) - 1, f)))
827 {
828 if (isdigit (buf[0]))
829 {
830 if (buf[sz - 1] != '\n')
831 {
832 return -1;
833 }
834 buf[sz] = '\0';
835 if (scan_line (buf, ops) != 0)
836 {
837 return -1;
838 }
839 continue;
840 }
841 while (buf[sz - 1] != '\n' && (sz = f_gets (buf, sizeof (buf), f)) != 0)
842 {
843 }
844 }
845
846 return ops->len;
847 }
848
849 /* --------------------------------------------------------------------------------------------- */
850
851 /**
852 * Invoke diff and extract diff statements.
853 *
854 * \param args extra arguments to be passed to diff
855 * \param extra more arguments to be passed to diff
856 * \param file1 first file to compare
857 * \param file2 second file to compare
858 * \param ops list of diff statements to fill
859 *
860 * \return positive number indicating number of hunks, otherwise negative
861 */
862 static int
863 dff_execute (const char *args, const char *extra, const char *file1, const char *file2,
864 GArray * ops)
865 {
866 static const char *opt =
867 " --old-group-format='%df%(f=l?:,%dl)d%dE\n'"
868 " --new-group-format='%dea%dF%(F=L?:,%dL)\n'"
869 " --changed-group-format='%df%(f=l?:,%dl)c%dF%(F=L?:,%dL)\n'"
870 " --unchanged-group-format=''";
871
872 int rv;
873 FBUF *f;
874 char *cmd;
875 int code;
876
877 cmd = g_strdup_printf ("diff %s %s %s \"%s\" \"%s\"", args, extra, opt, file1, file2);
878 if (cmd == NULL)
879 return -1;
880
881 f = p_open (cmd, O_RDONLY);
882 g_free (cmd);
883
884 if (f == NULL)
885 return -1;
886
887 rv = scan_diff (f, ops);
888 code = p_close (f);
889
890 if (rv < 0 || code == -1 || !WIFEXITED (code) || WEXITSTATUS (code) == 2)
891 return -1;
892
893 return rv;
894 }
895
896 /* --------------------------------------------------------------------------------------------- */
897
898 /**
899 * Reparse and display file according to diff statements.
900 *
901 * \param ord 0 if displaying first file, 1 if displaying 2nd file
902 * \param filename file name to display
903 * \param ops list of diff statements
904 * \param printer printf-like function to be used for displaying
905 * \param ctx printer context
906 *
907 * \return 0 if success, otherwise non-zero
908 */
909 static int
910 dff_reparse (int ord, const char *filename, const GArray * ops, DFUNC printer, void *ctx)
911 {
912 size_t i;
913 FBUF *f;
914 size_t sz;
915 char buf[BUFSIZ];
916 int line = 0;
917 off_t off = 0;
918 const DIFFCMD *op;
919 int eff;
920 int add_cmd;
921 int del_cmd;
922
923 f = f_open (filename, O_RDONLY);
924 if (f == NULL)
925 {
926 return -1;
927 }
928
929 ord &= 1;
930 eff = ord;
931
932 add_cmd = 'a';
933 del_cmd = 'd';
934 if (ord)
935 {
936 add_cmd = 'd';
937 del_cmd = 'a';
938 }
939 #define F1 a[eff][0]
940 #define F2 a[eff][1]
941 #define T1 a[ ord^1 ][0]
942 #define T2 a[ ord^1 ][1]
943 for (i = 0; i < ops->len; i++)
944 {
945 int n;
946 op = &g_array_index (ops, DIFFCMD, i);
947 n = op->F1 - (op->cmd != add_cmd);
948 while (line < n && (sz = f_gets (buf, sizeof (buf), f)) != 0)
949 {
950 line++;
951 printer (ctx, EQU_CH, line, off, sz, buf);
952 off += sz;
953 while (buf[sz - 1] != '\n')
954 {
955 sz = f_gets (buf, sizeof (buf), f);
956 if (sz == 0)
957 {
958 printer (ctx, 0, 0, 0, 1, "\n");
959 break;
960 }
961 printer (ctx, 0, 0, 0, sz, buf);
962 off += sz;
963 }
964 }
965 if (line != n)
966 {
967 goto err;
968 }
969
970 if (op->cmd == add_cmd)
971 {
972 n = op->T2 - op->T1 + 1;
973 while (n)
974 {
975 printer (ctx, DEL_CH, 0, 0, 1, "\n");
976 n--;
977 }
978 }
979 if (op->cmd == del_cmd)
980 {
981 n = op->F2 - op->F1 + 1;
982 while (n != 0 && (sz = f_gets (buf, sizeof (buf), f)) != 0)
983 {
984 line++;
985 printer (ctx, ADD_CH, line, off, sz, buf);
986 off += sz;
987 while (buf[sz - 1] != '\n')
988 {
989 sz = f_gets (buf, sizeof (buf), f);
990 if (sz == 0)
991 {
992 printer (ctx, 0, 0, 0, 1, "\n");
993 break;
994 }
995 printer (ctx, 0, 0, 0, sz, buf);
996 off += sz;
997 }
998 n--;
999 }
1000 if (n)
1001 {
1002 goto err;
1003 }
1004 }
1005 if (op->cmd == 'c')
1006 {
1007 n = op->F2 - op->F1 + 1;
1008 while (n != 0 && (sz = f_gets (buf, sizeof (buf), f)) != 0)
1009 {
1010 line++;
1011 printer (ctx, CHG_CH, line, off, sz, buf);
1012 off += sz;
1013 while (buf[sz - 1] != '\n')
1014 {
1015 sz = f_gets (buf, sizeof (buf), f);
1016 if (sz == 0)
1017 {
1018 printer (ctx, 0, 0, 0, 1, "\n");
1019 break;
1020 }
1021 printer (ctx, 0, 0, 0, sz, buf);
1022 off += sz;
1023 }
1024 n--;
1025 }
1026 if (n)
1027 {
1028 goto err;
1029 }
1030 n = op->T2 - op->T1 - (op->F2 - op->F1);
1031 while (n > 0)
1032 {
1033 printer (ctx, CHG_CH, 0, 0, 1, "\n");
1034 n--;
1035 }
1036 }
1037 }
1038 #undef T2
1039 #undef T1
1040 #undef F2
1041 #undef F1
1042
1043 while ((sz = f_gets (buf, sizeof (buf), f)) != 0)
1044 {
1045 line++;
1046 printer (ctx, EQU_CH, line, off, sz, buf);
1047 off += sz;
1048 while (buf[sz - 1] != '\n')
1049 {
1050 sz = f_gets (buf, sizeof (buf), f);
1051 if (sz == 0)
1052 {
1053 printer (ctx, 0, 0, 0, 1, "\n");
1054 break;
1055 }
1056 printer (ctx, 0, 0, 0, sz, buf);
1057 off += sz;
1058 }
1059 }
1060
1061 f_close (f);
1062 return 0;
1063
1064 err:
1065 f_close (f);
1066 return -1;
1067 }
1068
1069 /* --------------------------------------------------------------------------------------------- */
1070 /* horizontal diff ********************************************************** */
1071
1072 /**
1073 * Longest common substring.
1074 *
1075 * \param s first string
1076 * \param m length of first string
1077 * \param t second string
1078 * \param n length of second string
1079 * \param ret list of offsets for longest common substrings inside each string
1080 * \param min minimum length of common substrings
1081 *
1082 * \return 0 if success, nonzero otherwise
1083 */
1084 static int
1085 lcsubstr (const char *s, int m, const char *t, int n, GArray * ret, int min)
1086 {
1087 int i, j;
1088
1089 int *Lprev, *Lcurr;
1090
1091 int z = 0;
1092
1093 if (m < min || n < min)
1094 {
1095 /* XXX early culling */
1096 return 0;
1097 }
1098
1099 Lprev = g_new0 (int, n + 1);
1100 Lcurr = g_new0 (int, n + 1);
1101
1102 if (Lprev == NULL || Lcurr == NULL)
1103 {
1104 g_free (Lprev);
1105 g_free (Lcurr);
1106 return -1;
1107 }
1108
1109 for (i = 0; i < m; i++)
1110 {
1111 int *L = Lprev;
1112 Lprev = Lcurr;
1113 Lcurr = L;
1114 #ifdef USE_MEMSET_IN_LCS
1115 memset (Lcurr, 0, (n + 1) * sizeof (int));
1116 #endif
1117 for (j = 0; j < n; j++)
1118 {
1119 #ifndef USE_MEMSET_IN_LCS
1120 Lcurr[j + 1] = 0;
1121 #endif
1122 if (s[i] == t[j])
1123 {
1124 int v = Lprev[j] + 1;
1125 Lcurr[j + 1] = v;
1126 if (z < v)
1127 {
1128 z = v;
1129 g_array_set_size (ret, 0);
1130 }
1131 if (z == v && z >= min)
1132 {
1133 int off0 = i - z + 1;
1134 int off1 = j - z + 1;
1135 size_t k;
1136 for (k = 0; k < ret->len; k++)
1137 {
1138 PAIR *p = (PAIR *) g_array_index (ret, PAIR, k);
1139 if ((*p)[0] == off0)
1140 {
1141 break;
1142 }
1143 if ((*p)[1] >= off1)
1144 {
1145 break;
1146 }
1147 }
1148 if (k == ret->len)
1149 {
1150 PAIR p2;
1151 p2[0] = off0;
1152 p2[1] = off1;
1153 g_array_append_val (ret, p2);
1154 }
1155 }
1156 }
1157 }
1158 }
1159
1160 free (Lcurr);
1161 free (Lprev);
1162 return z;
1163
1164 free (Lcurr);
1165 free (Lprev);
1166 return -1;
1167 }
1168
1169 /* --------------------------------------------------------------------------------------------- */
1170
1171 /**
1172 * Scan recursively for common substrings and build ranges.
1173 *
1174 * \param s first string
1175 * \param t second string
1176 * \param bracket current limits for both of the strings
1177 * \param min minimum length of common substrings
1178 * \param hdiff list of horizontal diff ranges to fill
1179 * \param depth recursion depth
1180 *
1181 * \return 0 if success, nonzero otherwise
1182 */
1183 static gboolean
1184 hdiff_multi (const char *s, const char *t, const BRACKET bracket, int min, GArray * hdiff,
1185 unsigned int depth)
1186 {
1187 BRACKET p;
1188
1189 if (depth--)
1190 {
1191 GArray *ret;
1192 BRACKET b;
1193 int len;
1194 ret = g_array_new (FALSE, TRUE, sizeof (PAIR));
1195 if (ret == NULL)
1196 return FALSE;
1197
1198 len = lcsubstr (s + bracket[0].off, bracket[0].len,
1199 t + bracket[1].off, bracket[1].len, ret, min);
1200 if (ret->len != 0)
1201 {
1202 size_t k = 0;
1203 const PAIR *data = (const PAIR *) &g_array_index (ret, PAIR, 0);
1204 const PAIR *data2;
1205
1206 b[0].off = bracket[0].off;
1207 b[0].len = (*data)[0];
1208 b[1].off = bracket[1].off;
1209 b[1].len = (*data)[1];
1210 if (!hdiff_multi (s, t, b, min, hdiff, depth))
1211 return FALSE;
1212
1213 for (k = 0; k < ret->len - 1; k++)
1214 {
1215 data = (const PAIR *) &g_array_index (ret, PAIR, k);
1216 data2 = (const PAIR *) &g_array_index (ret, PAIR, k + 1);
1217 b[0].off = bracket[0].off + (*data)[0] + len;
1218 b[0].len = (*data2)[0] - (*data)[0] - len;
1219 b[1].off = bracket[1].off + (*data)[1] + len;
1220 b[1].len = (*data2)[1] - (*data)[1] - len;
1221 if (!hdiff_multi (s, t, b, min, hdiff, depth))
1222 return FALSE;
1223 }
1224 data = (const PAIR *) &g_array_index (ret, PAIR, k);
1225 b[0].off = bracket[0].off + (*data)[0] + len;
1226 b[0].len = bracket[0].len - (*data)[0] - len;
1227 b[1].off = bracket[1].off + (*data)[1] + len;
1228 b[1].len = bracket[1].len - (*data)[1] - len;
1229 if (!hdiff_multi (s, t, b, min, hdiff, depth))
1230 return FALSE;
1231
1232 g_array_free (ret, TRUE);
1233 return TRUE;
1234 }
1235 }
1236
1237 p[0].off = bracket[0].off;
1238 p[0].len = bracket[0].len;
1239 p[1].off = bracket[1].off;
1240 p[1].len = bracket[1].len;
1241 g_array_append_val (hdiff, p);
1242
1243 return TRUE;
1244 }
1245
1246 /* --------------------------------------------------------------------------------------------- */
1247
1248 /**
1249 * Build list of horizontal diff ranges.
1250 *
1251 * \param s first string
1252 * \param m length of first string
1253 * \param t second string
1254 * \param n length of second string
1255 * \param min minimum length of common substrings
1256 * \param hdiff list of horizontal diff ranges to fill
1257 * \param depth recursion depth
1258 *
1259 * \return 0 if success, nonzero otherwise
1260 */
1261 static gboolean
1262 hdiff_scan (const char *s, int m, const char *t, int n, int min, GArray * hdiff, unsigned int depth)
1263 {
1264 int i;
1265 BRACKET b;
1266
1267 /* dumbscan (single horizontal diff) -- does not compress whitespace */
1268 for (i = 0; i < m && i < n && s[i] == t[i]; i++)
1269 ;
1270 for (; m > i && n > i && s[m - 1] == t[n - 1]; m--, n--)
1271 ;
1272
1273 b[0].off = i;
1274 b[0].len = m - i;
1275 b[1].off = i;
1276 b[1].len = n - i;
1277
1278 /* smartscan (multiple horizontal diff) */
1279 return hdiff_multi (s, t, b, min, hdiff, depth);
1280 }
1281
1282 /* --------------------------------------------------------------------------------------------- */
1283 /* read line **************************************************************** */
1284
1285 /**
1286 * Check if character is inside horizontal diff limits.
1287 *
1288 * \param k rank of character inside line
1289 * \param hdiff horizontal diff structure
1290 * \param ord 0 if reading from first file, 1 if reading from 2nd file
1291 *
1292 * \return TRUE if inside hdiff limits, FALSE otherwise
1293 */
1294 static int
1295 is_inside (int k, GArray * hdiff, int ord)
1296 {
1297 size_t i;
1298 BRACKET *b;
1299 for (i = 0; i < hdiff->len; i++)
1300 {
1301 int start, end;
1302 b = &g_array_index (hdiff, BRACKET, i);
1303
1304 start = (*b)[ord].off;
1305 end = start + (*b)[ord].len;
1306 if (k >= start && k < end)
1307 {
1308 return 1;
1309 }
1310 }
1311 return 0;
1312 }
1313
1314 /* --------------------------------------------------------------------------------------------- */
1315
1316 /**
1317 * Copy `src' to `dst' expanding tabs.
1318 *
1319 * \param dst destination buffer
1320 * \param src source buffer
1321 * \param srcsize size of src buffer
1322 * \param base virtual base of this string, needed to calculate tabs
1323 * \param ts tab size
1324 *
1325 * \return new virtual base
1326 *
1327 * \note The procedure returns when all bytes are consumed from `src'
1328 */
1329 static int
1330 cvt_cpy (char *dst, const char *src, size_t srcsize, int base, int ts)
1331 {
1332 int i;
1333 for (i = 0; srcsize != 0; i++, src++, dst++, srcsize--)
1334 {
1335 *dst = *src;
1336 if (*src == '\t')
1337 {
1338 int j = TAB_SKIP (ts, i + base);
1339 i += j - 1;
1340 while (j-- > 0)
1341 {
1342 *dst++ = ' ';
1343 }
1344 dst--;
1345 }
1346 }
1347 return i + base;
1348 }
1349
1350 /* --------------------------------------------------------------------------------------------- */
1351
1352 /**
1353 * Copy `src' to `dst' expanding tabs.
1354 *
1355 * \param dst destination buffer
1356 * \param dstsize size of dst buffer
1357 * \param[in,out] _src source buffer
1358 * \param srcsize size of src buffer
1359 * \param base virtual base of this string, needed to calculate tabs
1360 * \param ts tab size
1361 *
1362 * \return new virtual base
1363 *
1364 * \note The procedure returns when all bytes are consumed from `src'
1365 * or `dstsize' bytes are written to `dst'
1366 * \note Upon return, `src' points to the first unwritten character in source
1367 */
1368 static int
1369 cvt_ncpy (char *dst, int dstsize, const char **_src, size_t srcsize, int base, int ts)
1370 {
1371 int i;
1372 const char *src = *_src;
1373 for (i = 0; i < dstsize && srcsize != 0; i++, src++, dst++, srcsize--)
1374 {
1375 *dst = *src;
1376 if (*src == '\t')
1377 {
1378 int j = TAB_SKIP (ts, i + base);
1379 if (j > dstsize - i)
1380 {
1381 j = dstsize - i;
1382 }
1383 i += j - 1;
1384 while (j-- > 0)
1385 {
1386 *dst++ = ' ';
1387 }
1388 dst--;
1389 }
1390 }
1391 *_src = src;
1392 return i + base;
1393 }
1394
1395 /* --------------------------------------------------------------------------------------------- */
1396
1397 /**
1398 * Read line from memory, converting tabs to spaces and padding with spaces.
1399 *
1400 * \param src buffer to read from
1401 * \param srcsize size of src buffer
1402 * \param dst buffer to read to
1403 * \param dstsize size of dst buffer, excluding trailing null
1404 * \param skip number of characters to skip
1405 * \param ts tab size
1406 * \param show_cr show trailing carriage return as ^M
1407 *
1408 * \return negative on error, otherwise number of bytes except padding
1409 */
1410 static int
1411 cvt_mget (const char *src, size_t srcsize, char *dst, int dstsize, int skip, int ts, int show_cr)
1412 {
1413 int sz = 0;
1414 if (src != NULL)
1415 {
1416 int i;
1417 char *tmp = dst;
1418 const int base = 0;
1419 for (i = 0; dstsize != 0 && srcsize != 0 && *src != '\n'; i++, src++, srcsize--)
1420 {
1421 if (*src == '\t')
1422 {
1423 int j = TAB_SKIP (ts, i + base);
1424 i += j - 1;
1425 while (j-- > 0)
1426 {
1427 if (skip > 0)
1428 {
1429 skip--;
1430 }
1431 else if (dstsize != 0)
1432 {
1433 dstsize--;
1434 *dst++ = ' ';
1435 }
1436 }
1437 }
1438 else if (src[0] == '\r' && (srcsize == 1 || src[1] == '\n'))
1439 {
1440 if (skip == 0 && show_cr)
1441 {
1442 if (dstsize > 1)
1443 {
1444 dstsize -= 2;
1445 *dst++ = '^';
1446 *dst++ = 'M';
1447 }
1448 else
1449 {
1450 dstsize--;
1451 *dst++ = '.';
1452 }
1453 }
1454 break;
1455 }
1456 else
1457 {
1458 if (skip > 0)
1459 {
1460 int utf_ch = 0;
1461 gboolean res;
1462 int w;
1463
1464 skip--;
1465 utf_ch = dview_get_utf ((char *) src, &w, &res);
1466 if (w > 1)
1467 skip += w - 1;
1468 if (!g_unichar_isprint (utf_ch))
1469 utf_ch = '.';
1470 }
1471 else
1472 {
1473 dstsize--;
1474 *dst++ = *src;
1475 }
1476 }
1477 }
1478 sz = dst - tmp;
1479 }
1480 while (dstsize != 0)
1481 {
1482 dstsize--;
1483 *dst++ = ' ';
1484 }
1485 *dst = '\0';
1486 return sz;
1487 }
1488
1489 /* --------------------------------------------------------------------------------------------- */
1490
1491 /**
1492 * Read line from memory and build attribute array.
1493 *
1494 * \param src buffer to read from
1495 * \param srcsize size of src buffer
1496 * \param dst buffer to read to
1497 * \param dstsize size of dst buffer, excluding trailing null
1498 * \param skip number of characters to skip
1499 * \param ts tab size
1500 * \param show_cr show trailing carriage return as ^M
1501 * \param hdiff horizontal diff structure
1502 * \param ord 0 if reading from first file, 1 if reading from 2nd file
1503 * \param att buffer of attributes
1504 *
1505 * \return negative on error, otherwise number of bytes except padding
1506 */
1507 static int
1508 cvt_mgeta (const char *src, size_t srcsize, char *dst, int dstsize, int skip, int ts, int show_cr,
1509 GArray * hdiff, int ord, char *att)
1510 {
1511 int sz = 0;
1512 if (src != NULL)
1513 {
1514 int i, k;
1515 char *tmp = dst;
1516 const int base = 0;
1517 for (i = 0, k = 0; dstsize != 0 && srcsize != 0 && *src != '\n'; i++, k++, src++, srcsize--)
1518 {
1519 if (*src == '\t')
1520 {
1521 int j = TAB_SKIP (ts, i + base);
1522 i += j - 1;
1523 while (j-- > 0)
1524 {
1525 if (skip != 0)
1526 {
1527 skip--;
1528 }
1529 else if (dstsize != 0)
1530 {
1531 dstsize--;
1532 *att++ = is_inside (k, hdiff, ord);
1533 *dst++ = ' ';
1534 }
1535 }
1536 }
1537 else if (src[0] == '\r' && (srcsize == 1 || src[1] == '\n'))
1538 {
1539 if (skip == 0 && show_cr)
1540 {
1541 if (dstsize > 1)
1542 {
1543 dstsize -= 2;
1544 *att++ = is_inside (k, hdiff, ord);
1545 *dst++ = '^';
1546 *att++ = is_inside (k, hdiff, ord);
1547 *dst++ = 'M';
1548 }
1549 else
1550 {
1551 dstsize--;
1552 *att++ = is_inside (k, hdiff, ord);
1553 *dst++ = '.';
1554 }
1555 }
1556 break;
1557 }
1558 else
1559 {
1560 if (skip != 0)
1561 {
1562 int utf_ch = 0;
1563 gboolean res;
1564 int w;
1565
1566 skip--;
1567 utf_ch = dview_get_utf ((char *) src, &w, &res);
1568 if (w > 1)
1569 skip += w - 1;
1570 if (!g_unichar_isprint (utf_ch))
1571 utf_ch = '.';
1572 }
1573 else
1574 {
1575 dstsize--;
1576 *att++ = is_inside (k, hdiff, ord);
1577 *dst++ = *src;
1578 }
1579 }
1580 }
1581 sz = dst - tmp;
1582 }
1583 while (dstsize != 0)
1584 {
1585 dstsize--;
1586 *att++ = 0;
1587 *dst++ = ' ';
1588 }
1589 *dst = '\0';
1590 return sz;
1591 }
1592
1593 /* --------------------------------------------------------------------------------------------- */
1594
1595 /**
1596 * Read line from file, converting tabs to spaces and padding with spaces.
1597 *
1598 * \param f file stream to read from
1599 * \param off offset of line inside file
1600 * \param dst buffer to read to
1601 * \param dstsize size of dst buffer, excluding trailing null
1602 * \param skip number of characters to skip
1603 * \param ts tab size
1604 * \param show_cr show trailing carriage return as ^M
1605 *
1606 * \return negative on error, otherwise number of bytes except padding
1607 */
1608 static int
1609 cvt_fget (FBUF * f, off_t off, char *dst, size_t dstsize, int skip, int ts, int show_cr)
1610 {
1611 int base = 0;
1612 int old_base = base;
1613 const int amount = dstsize;
1614
1615 size_t useful, offset;
1616
1617 size_t i;
1618 size_t sz;
1619
1620 int lastch = '\0';
1621
1622 const char *q = NULL;
1623 char tmp[BUFSIZ]; /* XXX capacity must be >= max{dstsize + 1, amount} */
1624 char cvt[BUFSIZ]; /* XXX capacity must be >= MAX_TAB_WIDTH * amount */
1625
1626 if ((int) sizeof (tmp) < amount || (int) sizeof (tmp) <= dstsize
1627 || (int) sizeof (cvt) < 8 * amount)
1628 {
1629 /* abnormal, but avoid buffer overflow */
1630 memset (dst, ' ', dstsize);
1631 dst[dstsize] = '\0';
1632 return 0;
1633 }
1634
1635 f_seek (f, off, SEEK_SET);
1636
1637 while (skip > base)
1638 {
1639 old_base = base;
1640 sz = f_gets (tmp, amount, f);
1641 if (sz == 0)
1642 break;
1643
1644 base = cvt_cpy (cvt, tmp, sz, old_base, ts);
1645 if (cvt[base - old_base - 1] == '\n')
1646 {
1647 q = &cvt[base - old_base - 1];
1648 base = old_base + q - cvt + 1;
1649 break;
1650 }
1651 }
1652
1653 if (base < skip)
1654 {
1655 memset (dst, ' ', dstsize);
1656 dst[dstsize] = '\0';
1657 return 0;
1658 }
1659
1660 useful = base - skip;
1661 offset = skip - old_base;
1662
1663 if (useful <= dstsize)
1664 {
1665 if (useful != 0)
1666 memmove (dst, cvt + offset, useful);
1667
1668 if (q == NULL)
1669 {
1670 sz = f_gets (tmp, dstsize - useful + 1, f);
1671 if (sz != 0)
1672 {
1673 const char *ptr = tmp;
1674 useful += cvt_ncpy (dst + useful, dstsize - useful, &ptr, sz, base, ts) - base;
1675 if (ptr < tmp + sz)
1676 lastch = *ptr;
1677 }
1678 }
1679 sz = useful;
1680 }
1681 else
1682 {
1683 memmove (dst, cvt + offset, dstsize);
1684 sz = dstsize;
1685 lastch = cvt[offset + dstsize];
1686 }
1687
1688 dst[sz] = lastch;
1689 for (i = 0; i < sz && dst[i] != '\n'; i++)
1690 {
1691 if (dst[i] == '\r' && dst[i + 1] == '\n')
1692 {
1693 if (show_cr)
1694 {
1695 if (i + 1 < dstsize)
1696 {
1697 dst[i++] = '^';
1698 dst[i++] = 'M';
1699 }
1700 else
1701 {
1702 dst[i++] = '*';
1703 }
1704 }
1705 break;
1706 }
1707 }
1708 for (; i < dstsize; i++)
1709 {
1710 dst[i] = ' ';
1711 }
1712 dst[i] = '\0';
1713 return sz;
1714 }
1715
1716 /* --------------------------------------------------------------------------------------------- */
1717 /* diff printers et al ****************************************************** */
1718
1719 static void
1720 cc_free_elt (void *elt)
1721 {
1722 DIFFLN *p = elt;
1723 if (p != NULL)
1724 {
1725 g_free (p->p);
1726 }
1727 }
1728
1729 /* --------------------------------------------------------------------------------------------- */
1730
1731 static int
1732 printer (void *ctx, int ch, int line, off_t off, size_t sz, const char *str)
1733 {
1734 GArray *a = ((PRINTER_CTX *) ctx)->a;
1735 DSRC dsrc = ((PRINTER_CTX *) ctx)->dsrc;
1736 if (ch)
1737 {
1738 DIFFLN p;
1739 p.p = NULL;
1740 p.ch = ch;
1741 p.line = line;
1742 p.u.off = off;
1743 if (dsrc == DATA_SRC_MEM && line != 0)
1744 {
1745 if (sz != 0 && str[sz - 1] == '\n')
1746 {
1747 sz--;
1748 }
1749 if (sz > 0)
1750 p.p = g_strndup (str, sz);
1751 p.u.len = sz;
1752 }
1753 g_array_append_val (a, p);
1754 }
1755 else if (dsrc == DATA_SRC_MEM)
1756 {
1757 DIFFLN *p;
1758 p = &g_array_index (a, DIFFLN, a->len - 1);
1759 if (sz != 0 && str[sz - 1] == '\n')
1760 {
1761 sz--;
1762 }
1763 if (sz != 0)
1764 {
1765 size_t new_size = p->u.len + sz;
1766 char *q = g_realloc (p->p, new_size);
1767 memcpy (q + p->u.len, str, sz);
1768 p->p = q;
1769 }
1770 p->u.len += sz;
1771 }
1772 if (dsrc == DATA_SRC_TMP && (line != 0 || ch == 0))
1773 {
1774 FBUF *f = ((PRINTER_CTX *) ctx)->f;
1775 f_write (f, str, sz);
1776 }
1777 return 0;
1778 }
1779
1780 /* --------------------------------------------------------------------------------------------- */
1781
1782 static int
1783 redo_diff (WDiff * dview)
1784 {
1785 FBUF *const *f = dview->f;
1786
1787 PRINTER_CTX ctx;
1788 GArray *ops;
1789 int ndiff;
1790 int rv;
1791
1792 char extra[256];
1793
1794 extra[0] = '\0';
1795 if (dview->opt.quality == 2)
1796 {
1797 strcat (extra, " -d");
1798 }
1799 if (dview->opt.quality == 1)
1800 {
1801 strcat (extra, " --speed-large-files");
1802 }
1803 if (dview->opt.strip_trailing_cr)
1804 {
1805 strcat (extra, " --strip-trailing-cr");
1806 }
1807 if (dview->opt.ignore_tab_expansion)
1808 {
1809 strcat (extra, " -E");
1810 }
1811 if (dview->opt.ignore_space_change)
1812 {
1813 strcat (extra, " -b");
1814 }
1815 if (dview->opt.ignore_all_space)
1816 {
1817 strcat (extra, " -w");
1818 }
1819 if (dview->opt.ignore_case)
1820 {
1821 strcat (extra, " -i");
1822 }
1823
1824 if (dview->dsrc != DATA_SRC_MEM)
1825 {
1826 f_reset (f[0]);
1827 f_reset (f[1]);
1828 }
1829
1830 ops = g_array_new (FALSE, FALSE, sizeof (DIFFCMD));
1831 ndiff = dff_execute (dview->args, extra, dview->file[0], dview->file[1], ops);
1832 if (ndiff < 0)
1833 {
1834 if (ops != NULL)
1835 g_array_free (ops, TRUE);
1836 return -1;
1837 }
1838
1839 ctx.dsrc = dview->dsrc;
1840
1841 rv = 0;
1842 ctx.a = dview->a[0];
1843 ctx.f = f[0];
1844 rv |= dff_reparse (0, dview->file[0], ops, printer, &ctx);
1845
1846 ctx.a = dview->a[1];
1847 ctx.f = f[1];
1848 rv |= dff_reparse (1, dview->file[1], ops, printer, &ctx);
1849
1850 if (ops != NULL)
1851 g_array_free (ops, TRUE);
1852
1853 if (rv != 0 || dview->a[0]->len != dview->a[1]->len)
1854 return -1;
1855
1856 if (dview->dsrc == DATA_SRC_TMP)
1857 {
1858 f_trunc (f[0]);
1859 f_trunc (f[1]);
1860 }
1861
1862 if (dview->dsrc == DATA_SRC_MEM && HDIFF_ENABLE)
1863 {
1864 dview->hdiff = g_ptr_array_new ();
1865 if (dview->hdiff != NULL)
1866 {
1867 size_t i;
1868 const DIFFLN *p;
1869 const DIFFLN *q;
1870 for (i = 0; i < dview->a[0]->len; i++)
1871 {
1872 GArray *h = NULL;
1873 p = &g_array_index (dview->a[0], DIFFLN, i);
1874 q = &g_array_index (dview->a[1], DIFFLN, i);
1875 if (p->line && q->line && p->ch == CHG_CH)
1876 {
1877 h = g_array_new (FALSE, FALSE, sizeof (BRACKET));
1878 if (h != NULL)
1879 {
1880 gboolean runresult =
1881 hdiff_scan (p->p, p->u.len, q->p, q->u.len, HDIFF_MINCTX, h,
1882 HDIFF_DEPTH);
1883 if (!runresult)
1884 {
1885 g_array_free (h, TRUE);
1886 h = NULL;
1887 }
1888 }
1889 }
1890 g_ptr_array_add (dview->hdiff, h);
1891 }
1892 }
1893 }
1894 return ndiff;
1895 }
1896
1897 /* --------------------------------------------------------------------------------------------- */
1898
1899 static void
1900 destroy_hdiff (WDiff * dview)
1901 {
1902 if (dview->hdiff != NULL)
1903 {
1904 int i;
1905 int len = dview->a[0]->len;
1906 for (i = 0; i < len; i++)
1907 {
1908 GArray *h = (GArray *) g_ptr_array_index (dview->hdiff, i);
1909 if (h != NULL)
1910 g_array_free (h, TRUE);
1911 }
1912 g_ptr_array_free (dview->hdiff, TRUE);
1913 dview->hdiff = NULL;
1914 }
1915
1916 mc_search_free (dview->search.handle);
1917 dview->search.handle = NULL;
1918 g_free (dview->search.last_string);
1919 dview->search.last_string = NULL;
1920 }
1921
1922 /* --------------------------------------------------------------------------------------------- */
1923 /* stuff ******************************************************************** */
1924
1925 static int
1926 get_digits (unsigned int n)
1927 {
1928 int d = 1;
1929 while (n /= 10)
1930 {
1931 d++;
1932 }
1933 return d;
1934 }
1935
1936 /* --------------------------------------------------------------------------------------------- */
1937
1938 static int
1939 get_line_numbers (const GArray * a, size_t pos, int *linenum, int *lineofs)
1940 {
1941 const DIFFLN *p;
1942
1943 *linenum = 0;
1944 *lineofs = 0;
1945
1946 if (a->len != 0)
1947 {
1948 if (pos >= a->len)
1949 {
1950 pos = a->len - 1;
1951 }
1952
1953 p = &g_array_index (a, DIFFLN, pos);
1954
1955 if (p->line == 0)
1956 {
1957 int n;
1958 for (n = pos; n > 0; n--)
1959 {
1960 p--;
1961 if (p->line != 0)
1962 {
1963 break;
1964 }
1965 }
1966 *lineofs = pos - n + 1;
1967 }
1968
1969 *linenum = p->line;
1970 }
1971 return 0;
1972 }
1973
1974 /* --------------------------------------------------------------------------------------------- */
1975
1976 static int
1977 calc_nwidth (const GArray ** const a)
1978 {
1979 int l1, o1;
1980 int l2, o2;
1981 get_line_numbers (a[0], a[0]->len - 1, &l1, &o1);
1982 get_line_numbers (a[1], a[1]->len - 1, &l2, &o2);
1983 if (l1 < l2)
1984 {
1985 l1 = l2;
1986 }
1987 return get_digits (l1);
1988 }
1989
1990 /* --------------------------------------------------------------------------------------------- */
1991
1992 static int
1993 find_prev_hunk (const GArray * a, int pos)
1994 {
1995 #if 1
1996 while (pos > 0 && ((DIFFLN *) & g_array_index (a, DIFFLN, pos))->ch != EQU_CH)
1997 {
1998 pos--;
1999 }
2000 while (pos > 0 && ((DIFFLN *) & g_array_index (a, DIFFLN, pos))->ch == EQU_CH)
2001 {
2002 pos--;
2003 }
2004 while (pos > 0 && ((DIFFLN *) & g_array_index (a, DIFFLN, pos))->ch != EQU_CH)
2005 {
2006 pos--;
2007 }
2008 if (pos > 0 && (size_t) pos < a->len)
2009 pos++;
2010 #else
2011 while (pos > 0 && ((DIFFLN *) & g_array_index (a, DIFFLN, pos - 1))->ch == EQU_CH)
2012 {
2013 pos--;
2014 }
2015 while (pos > 0 && ((DIFFLN *) & g_array_index (a, DIFFLN, pos - 1))->ch != EQU_CH)
2016 {
2017 pos--;
2018 }
2019 #endif
2020
2021 return pos;
2022 }
2023
2024 /* --------------------------------------------------------------------------------------------- */
2025
2026 static size_t
2027 find_next_hunk (const GArray * a, size_t pos)
2028 {
2029 while (pos < a->len && ((DIFFLN *) & g_array_index (a, DIFFLN, pos))->ch != EQU_CH)
2030 {
2031 pos++;
2032 }
2033 while (pos < a->len && ((DIFFLN *) & g_array_index (a, DIFFLN, pos))->ch == EQU_CH)
2034 {
2035 pos++;
2036 }
2037 return pos;
2038 }
2039
2040 /**
2041 * Find start and end lines of the current hunk.
2042 *
2043 * \param dview - widget WDiff
2044 * \return boolean and
2045 * start_line1 first line of current hunk (file[0])
2046 * end_line1 last line of current hunk (file[0])
2047 * start_line1 first line of current hunk (file[0])
2048 * end_line1 last line of current hunk (file[0])
2049 */
2050 static int
2051 get_current_hunk (WDiff * dview, int *start_line1, int *end_line1, int *start_line2, int *end_line2)
2052 {
2053 const GArray *a0 = dview->a[0];
2054 const GArray *a1 = dview->a[1];
2055 size_t pos;
2056 int ch;
2057 int res = 0;
2058
2059 *start_line1 = 1;
2060 *start_line2 = 1;
2061 *end_line1 = 1;
2062 *end_line2 = 1;
2063
2064 pos = dview->skip_rows;
2065 ch = ((DIFFLN *) & g_array_index (a0, DIFFLN, pos))->ch;
2066 if (ch != EQU_CH)
2067 {
2068 switch (ch)
2069 {
2070 case ADD_CH:
2071 res = DIFF_DEL;
2072 break;
2073 case DEL_CH:
2074 res = DIFF_ADD;
2075 break;
2076 case CHG_CH:
2077 res = DIFF_CHG;
2078 break;
2079 }
2080 while (pos > 0 && ((DIFFLN *) & g_array_index (a0, DIFFLN, pos))->ch != EQU_CH)
2081 {
2082 pos--;
2083 }
2084 if (pos > 0)
2085 {
2086 *start_line1 = ((DIFFLN *) & g_array_index (a0, DIFFLN, pos))->line + 1;
2087 *start_line2 = ((DIFFLN *) & g_array_index (a1, DIFFLN, pos))->line + 1;
2088 }
2089 pos = dview->skip_rows;
2090 while (pos < a0->len && ((DIFFLN *) & g_array_index (a0, DIFFLN, pos))->ch != EQU_CH)
2091 {
2092 int l0, l1;
2093 l0 = ((DIFFLN *) & g_array_index (a0, DIFFLN, pos))->line;
2094 l1 = ((DIFFLN *) & g_array_index (a1, DIFFLN, pos))->line;
2095 if (l0 > 0)
2096 *end_line1 = max (*start_line1, l0);
2097 if (l1 > 0)
2098 *end_line2 = max (*start_line2, l1);
2099 pos++;
2100 }
2101 }
2102 return res;
2103 }
2104
2105 static void
2106 dview_remove_hunk (WDiff * dview, FILE * merge_file, int from1, int to1)
2107 {
2108 int line;
2109 char buf[BUF_10K];
2110 FILE *f0;
2111 f0 = fopen (dview->file[0], "r");
2112 line = 0;
2113 while (fgets (buf, sizeof (buf), f0) != NULL && line < from1 - 1)
2114 {
2115 line++;
2116 fputs (buf, merge_file);
2117 }
2118 while (fgets (buf, sizeof (buf), f0) != NULL)
2119 {
2120 line++;
2121 if (line >= to1)
2122 fputs (buf, merge_file);
2123 }
2124 fclose (f0);
2125 }
2126
2127 static void
2128 dview_add_hunk (WDiff * dview, FILE * merge_file, int from1, int from2, int to2)
2129 {
2130 int line;
2131 char buf[BUF_10K];
2132 FILE *f0;
2133 FILE *f1;
2134 f0 = fopen (dview->file[0], "r");
2135 f1 = fopen (dview->file[1], "r");
2136 line = 0;
2137 while (fgets (buf, sizeof (buf), f0) != NULL && line < from1 - 1)
2138 {
2139 line++;
2140 fputs (buf, merge_file);
2141 }
2142 line = 0;
2143 while (fgets (buf, sizeof (buf), f1) != NULL && line <= to2)
2144 {
2145 line++;
2146 if (line >= from2)
2147 fputs (buf, merge_file);
2148 }
2149 while (fgets (buf, sizeof (buf), f0) != NULL)
2150 {
2151 fputs (buf, merge_file);
2152 }
2153 fclose (f0);
2154 fclose (f1);
2155 }
2156
2157 static void
2158 dview_replace_hunk (WDiff * dview, FILE * merge_file, int from1, int to1, int from2, int to2)
2159 {
2160 int line1, line2;
2161 char buf[BUF_10K];
2162 FILE *f0;
2163 FILE *f1;
2164 f0 = fopen (dview->file[0], "r");
2165 f1 = fopen (dview->file[1], "r");
2166 line1 = 0;
2167 while (fgets (buf, sizeof (buf), f0) != NULL && line1 < from1 - 1)
2168 {
2169 line1++;
2170 fputs (buf, merge_file);
2171 }
2172 line2 = 0;
2173 while (fgets (buf, sizeof (buf), f1) != NULL && line2 <= to2)
2174 {
2175 line2++;
2176 if (line2 >= from2)
2177 fputs (buf, merge_file);
2178 }
2179 while (fgets (buf, sizeof (buf), f0) != NULL)
2180 {
2181 line1++;
2182 if (line1 > to1)
2183 fputs (buf, merge_file);
2184 }
2185 fclose (f0);
2186 fclose (f1);
2187 }
2188
2189 static void
2190 do_merge_hunk (WDiff * dview)
2191 {
2192 int from1, to1, from2, to2;
2193 int res;
2194 int hunk;
2195
2196 hunk = get_current_hunk (dview, &from1, &to1, &from2, &to2);
2197 if (hunk > 0)
2198 {
2199 int merge_file_fd;
2200 FILE *merge_file;
2201 char *merge_file_name = NULL;
2202
2203 if (!dview->merged)
2204 {
2205 dview->merged = mc_util_make_backup_if_possible (dview->file[0], "~~~");
2206 if (!dview->merged)
2207 {
2208 message (D_ERROR, MSG_ERROR,
2209 _("Cannot create backup file\n%s%s\n%s"),
2210 dview->file[0], "~~~", unix_error_string (errno));
2211 return;
2212 }
2213
2214 }
2215
2216 merge_file_fd = mc_mkstemps (&merge_file_name, "mcmerge", NULL);
2217 if (merge_file_fd == -1)
2218 {
2219 message (D_ERROR, MSG_ERROR, _("Cannot create temporary merge file\n%s"),
2220 unix_error_string (errno));
2221 return;
2222 }
2223
2224 merge_file = fdopen (merge_file_fd, "w");
2225
2226 switch (hunk)
2227 {
2228 case DIFF_DEL:
2229 dview_remove_hunk (dview, merge_file, from1, to1);
2230 break;
2231 case DIFF_ADD:
2232 dview_add_hunk (dview, merge_file, from1, from2, to2);
2233 break;
2234 case DIFF_CHG:
2235 dview_replace_hunk (dview, merge_file, from1, to1, from2, to2);
2236 break;
2237 }
2238 fflush (merge_file);
2239 fclose (merge_file);
2240 res = rewrite_backup_content (merge_file_name, dview->file[0]);
2241 unlink (merge_file_name);
2242 g_free (merge_file_name);
2243 }
2244 }
2245
2246 /* --------------------------------------------------------------------------------------------- */
2247 /* view routines and callbacks ********************************************** */
2248
2249 static void
2250 dview_compute_split (WDiff * dview, int i)
2251 {
2252 dview->bias += i;
2253 if (dview->bias < 2 - dview->half1)
2254 {
2255 dview->bias = 2 - dview->half1;
2256 }
2257 if (dview->bias > dview->half2 - 2)
2258 {
2259 dview->bias = dview->half2 - 2;
2260 }
2261 }
2262
2263 /* --------------------------------------------------------------------------------------------- */
2264
2265 static void
2266 dview_compute_areas (WDiff * dview)
2267 {
2268 dview->height = LINES - 2;
2269 dview->half1 = COLS / 2;
2270 dview->half2 = COLS - dview->half1;
2271
2272 dview_compute_split (dview, 0);
2273 }
2274
2275 /* --------------------------------------------------------------------------------------------- */
2276
2277 static int
2278 dview_init (WDiff * dview, const char *args, const char *file1, const char *file2,
2279 const char *label1, const char *label2, DSRC dsrc)
2280 {
2281 int ndiff;
2282 FBUF *f[2];
2283
2284 f[0] = NULL;
2285 f[1] = NULL;
2286
2287 if (dsrc == DATA_SRC_TMP)
2288 {
2289 f[0] = f_temp ();
2290 if (f[0] == NULL)
2291 return -1;
2292
2293 f[1] = f_temp ();
2294 if (f[1] == NULL)
2295 {
2296 f_close (f[0]);
2297 return -1;
2298 }
2299 }
2300 else if (dsrc == DATA_SRC_ORG)
2301 {
2302 f[0] = f_open (file1, O_RDONLY);
2303 if (f[0] == NULL)
2304 return -1;
2305
2306 f[1] = f_open (file2, O_RDONLY);
2307 if (f[1] == NULL)
2308 {
2309 f_close (f[0]);
2310 return -1;
2311 }
2312 }
2313
2314 dview->args = args;
2315 dview->file[0] = file1;
2316 dview->file[1] = file2;
2317 dview->label[0] = g_strdup (label1);
2318 dview->label[1] = g_strdup (label2);
2319 dview->f[0] = f[0];
2320 dview->f[1] = f[1];
2321 dview->hdiff = NULL;
2322 dview->dsrc = dsrc;
2323 dview->converter = str_cnv_from_term;
2324 dview_set_codeset (dview);
2325
2326 dview->a[0] = g_array_new (FALSE, FALSE, sizeof (DIFFLN));
2327 dview->a[1] = g_array_new (FALSE, FALSE, sizeof (DIFFLN));
2328
2329 ndiff = redo_diff (dview);
2330 if (ndiff < 0)
2331 {
2332 /* goto WIDGET_DESTROY stage: dview_fini() */
2333 return -1;
2334 }
2335
2336 dview->ndiff = ndiff;
2337
2338 dview->view_quit = 0;
2339
2340 dview->bias = 0;
2341 dview->new_frame = 1;
2342 dview->skip_rows = 0;
2343 dview->skip_cols = 0;
2344 dview->display_symbols = 0;
2345 dview->display_numbers = 0;
2346 dview->show_cr = 1;
2347 dview->tab_size = 8;
2348 dview->ord = 0;
2349 dview->full = 0;
2350
2351 dview->search.handle = NULL;
2352 dview->search.last_string = NULL;
2353 dview->search.last_found_line = -1;
2354 dview->search.last_accessed_num_line = -1;
2355
2356 dview->opt.quality = 0;
2357 dview->opt.strip_trailing_cr = 0;
2358 dview->opt.ignore_tab_expansion = 0;
2359 dview->opt.ignore_space_change = 0;
2360 dview->opt.ignore_all_space = 0;
2361 dview->opt.ignore_case = 0;
2362
2363 dview_compute_areas (dview);
2364
2365 return 0;
2366 }
2367
2368 /* --------------------------------------------------------------------------------------------- */
2369
2370 static void
2371 dview_reread (WDiff * dview)
2372 {
2373 int ndiff = dview->ndiff;
2374
2375 destroy_hdiff (dview);
2376 if (dview->a[0] != NULL)
2377 {
2378 g_array_foreach (dview->a[0], DIFFLN, cc_free_elt);
2379 g_array_free (dview->a[0], TRUE);
2380 }
2381 if (dview->a[1] != NULL)
2382 {
2383 g_array_foreach (dview->a[1], DIFFLN, cc_free_elt);
2384 g_array_free (dview->a[1], TRUE);
2385 }
2386
2387 dview->a[0] = g_array_new (FALSE, FALSE, sizeof (DIFFLN));
2388 dview->a[1] = g_array_new (FALSE, FALSE, sizeof (DIFFLN));
2389
2390 ndiff = redo_diff (dview);
2391 if (ndiff >= 0)
2392 dview->ndiff = ndiff;
2393 }
2394
2395 /* --------------------------------------------------------------------------------------------- */
2396 static void
2397 dview_diff_options (WDiff * dview)
2398 {
2399 const char *quality_str[] = {
2400 N_("&Normal"),
2401 N_("&Fastest (Assume large files)"),
2402 N_("&Minimal (Find a smaller set of change)")
2403 };
2404
2405 QuickWidget diffopt_widgets[] = {
2406 QUICK_BUTTON (6, 10, 14, OPTY, N_("&Cancel"), B_CANCEL, NULL),
2407 QUICK_BUTTON (2, 10, 14, OPTY, N_("&OK"), B_ENTER, NULL),
2408
2409 QUICK_CHECKBOX (3, OPTX, 12, OPTY,
2410 N_("Strip &trailing carriage return"), &dview->opt.strip_trailing_cr),
2411 QUICK_CHECKBOX (3, OPTX, 11, OPTY,
2412 N_("Ignore all &whitespace"), &dview->opt.ignore_all_space),
2413 QUICK_CHECKBOX (3, OPTX, 10, OPTY,
2414 N_("Ignore &space change"), &dview->opt.ignore_space_change),
2415 QUICK_CHECKBOX (3, OPTX, 9, OPTY,
2416 N_("Ignore tab &expansion"), &dview->opt.ignore_tab_expansion),
2417 QUICK_CHECKBOX (3, OPTX, 8, OPTY,
2418 N_("&Ignore case"), &dview->opt.ignore_case),
2419 QUICK_LABEL (3, OPTX, 7, OPTY, N_("Diff extra options")),
2420 QUICK_RADIO (3, OPTX, 3, OPTY,
2421 3, (const char **) quality_str, (int *) &dview->opt.quality),
2422 QUICK_LABEL (3, OPTX, 2, OPTY, N_("Diff algorithm")),
2423
2424 QUICK_END
2425 };
2426
2427 QuickDialog diffopt = {
2428 OPTX, OPTY, -1, -1,
2429 N_("Diff Options"), "[Diff Options]",
2430 diffopt_widgets, NULL, FALSE
2431 };
2432
2433 if (quick_dialog (&diffopt) != B_CANCEL)
2434 {
2435 dview_reread (dview);
2436 }
2437 }
2438
2439 /* --------------------------------------------------------------------------------------------- */
2440
2441 static void
2442 dview_fini (WDiff * dview)
2443 {
2444 if (dview->dsrc != DATA_SRC_MEM)
2445 {
2446 f_close (dview->f[1]);
2447 f_close (dview->f[0]);
2448 }
2449
2450 if (dview->converter != str_cnv_from_term)
2451 str_close_conv (dview->converter);
2452
2453 destroy_hdiff (dview);
2454 if (dview->a[0] != NULL)
2455 {
2456 g_array_foreach (dview->a[0], DIFFLN, cc_free_elt);
2457 g_array_free (dview->a[0], TRUE);
2458 dview->a[0] = NULL;
2459 }
2460 if (dview->a[1] != NULL)
2461 {
2462 g_array_foreach (dview->a[1], DIFFLN, cc_free_elt);
2463 g_array_free (dview->a[1], TRUE);
2464 dview->a[1] = NULL;
2465 }
2466
2467 g_free (dview->label[0]);
2468 g_free (dview->label[1]);
2469
2470 }
2471
2472 /* --------------------------------------------------------------------------------------------- */
2473
2474 static int
2475 dview_display_file (const WDiff * dview, int ord, int r, int c, int height, int width)
2476 {
2477 size_t i, k;
2478 int j;
2479 char buf[BUFSIZ];
2480 FBUF *f = dview->f[ord];
2481 int skip = dview->skip_cols;
2482 int display_symbols = dview->display_symbols;
2483 int display_numbers = dview->display_numbers;
2484 int show_cr = dview->show_cr;
2485 int tab_size = 8;
2486 const DIFFLN *p;
2487 int nwidth = display_numbers;
2488 int xwidth = display_symbols + display_numbers;
2489 if (dview->tab_size > 0 && dview->tab_size < 9)
2490 tab_size = dview->tab_size;
2491
2492 if (xwidth)
2493 {
2494 if (xwidth > width && display_symbols)
2495 {
2496 xwidth--;
2497 display_symbols = 0;
2498 }
2499 if (xwidth > width && display_numbers)
2500 {
2501 xwidth = width;
2502 display_numbers = width;
2503 }
2504
2505 xwidth++;
2506
2507 c += xwidth;
2508 width -= xwidth;
2509
2510 if (width < 0)
2511 {
2512 width = 0;
2513 }
2514 }
2515
2516 if ((int) sizeof (buf) <= width || (int) sizeof (buf) <= nwidth)
2517 {
2518 /* abnormal, but avoid buffer overflow */
2519 return -1;
2520 }
2521
2522 for (i = dview->skip_rows, j = 0; i < dview->a[ord]->len && j < height; j++, i++)
2523 {
2524 int ch, next_ch, col;
2525 size_t cnt;
2526 p = (DIFFLN *) & g_array_index (dview->a[ord], DIFFLN, i);
2527 ch = p->ch;
2528 tty_setcolor (NORMAL_COLOR);
2529 if (display_symbols)
2530 {
2531 tty_gotoyx (r + j, c - 2);
2532 tty_print_char (ch);
2533 }
2534 if (p->line != 0)
2535 {
2536 if (display_numbers)
2537 {
2538 tty_gotoyx (r + j, c - xwidth);
2539 g_snprintf (buf, display_numbers + 1, "%*d", nwidth, p->line);
2540 tty_print_string (str_fit_to_term (buf, nwidth, J_LEFT_FIT));
2541 }
2542 if (ch == ADD_CH)
2543 {
2544 tty_setcolor (DFF_ADD_COLOR);
2545 }
2546 if (ch == CHG_CH)
2547 {
2548 tty_setcolor (DFF_CHG_COLOR);
2549 }
2550 if (f == NULL)
2551 {
2552 if (i == (size_t) dview->search.last_found_line)
2553 {
2554 tty_setcolor (MARKED_SELECTED_COLOR);
2555 }
2556 else
2557 {
2558 if (dview->hdiff != NULL && g_ptr_array_index (dview->hdiff, i) != NULL)
2559 {
2560 char att[BUFSIZ];
2561 if (dview->utf8)
2562 k = dview_str_utf8_offset_to_pos (p->p, width);
2563 else
2564 k = width;
2565 cvt_mgeta (p->p, p->u.len, buf, k, skip, tab_size, show_cr,
2566 g_ptr_array_index (dview->hdiff, i), ord, att);
2567 tty_gotoyx (r + j, c);
2568 col = 0;
2569 for (cnt = 0; cnt < strlen (buf) && col < width; cnt++)
2570 {
2571 int w;
2572 gboolean ch_res;
2573 if (dview->utf8)
2574 {
2575 next_ch = dview_get_utf (buf + cnt, &w, &ch_res);
2576 if (w > 1)
2577 cnt += w - 1;
2578 if (!g_unichar_isprint (next_ch))
2579 next_ch = '.';
2580 }
2581 else
2582 next_ch = dview_get_byte (buf + cnt, &ch_res);
2583 if (ch_res)
2584 {
2585 tty_setcolor (att[cnt] ? DFF_CHH_COLOR : DFF_CHG_COLOR);
2586 #ifdef HAVE_CHARSET
2587 if (mc_global.utf8_display)
2588 {
2589 if (!dview->utf8)
2590 {
2591 next_ch =
2592 convert_from_8bit_to_utf_c ((unsigned char) next_ch,
2593 dview->converter);
2594 }
2595 }
2596 else if (dview->utf8)
2597 next_ch =
2598 convert_from_utf_to_current_c (next_ch, dview->converter);
2599 else
2600 #endif
2601 next_ch = convert_to_display_c (next_ch);
2602
2603 tty_print_anychar (next_ch);
2604 col++;
2605 }
2606 }
2607 continue;
2608 }
2609 else if (ch == CHG_CH)
2610 {
2611 tty_setcolor (DFF_CHH_COLOR);
2612 }
2613 }
2614 if (dview->utf8)
2615 k = dview_str_utf8_offset_to_pos (p->p, width);
2616 else
2617 k = width;
2618 cvt_mget (p->p, p->u.len, buf, k, skip, tab_size, show_cr);
2619 }
2620 else
2621 {
2622 cvt_fget (f, p->u.off, buf, width, skip, tab_size, show_cr);
2623 }
2624 }
2625 else
2626 {
2627 if (display_numbers)
2628 {
2629 tty_gotoyx (r + j, c - xwidth);
2630 memset (buf, ' ', display_numbers);
2631 buf[display_numbers] = '\0';
2632 tty_print_string (buf);
2633 }
2634 if (ch == DEL_CH)
2635 {
2636 tty_setcolor (DFF_DEL_COLOR);
2637 }
2638 if (ch == CHG_CH)
2639 {
2640 tty_setcolor (DFF_CHD_COLOR);
2641 }
2642 memset (buf, ' ', width);
2643 buf[width] = '\0';
2644 }
2645 tty_gotoyx (r + j, c);
2646 /* tty_print_nstring (buf, width); */
2647 col = 0;
2648 for (cnt = 0; cnt < strlen (buf) && col < width; cnt++)
2649 {
2650 int w;
2651 gboolean ch_res;
2652 if (dview->utf8)
2653 {
2654 next_ch = dview_get_utf (buf + cnt, &w, &ch_res);
2655 if (w > 1)
2656 cnt += w - 1;
2657 if (!g_unichar_isprint (next_ch))
2658 next_ch = '.';
2659 }
2660 else
2661 next_ch = dview_get_byte (buf + cnt, &ch_res);
2662 if (ch_res)
2663 {
2664 #ifdef HAVE_CHARSET
2665 if (mc_global.utf8_display)
2666 {
2667 if (!dview->utf8)
2668 {
2669 next_ch =
2670 convert_from_8bit_to_utf_c ((unsigned char) next_ch, dview->converter);
2671 }
2672 }
2673 else if (dview->utf8)
2674 next_ch = convert_from_utf_to_current_c (next_ch, dview->converter);
2675 else
2676 #endif
2677 next_ch = convert_to_display_c (next_ch);
2678
2679 tty_print_anychar (next_ch);
2680 col++;
2681 }
2682 }
2683 continue;
2684 }
2685 tty_setcolor (NORMAL_COLOR);
2686 k = width;
2687 if (width < xwidth - 1)
2688 {
2689 k = xwidth - 1;
2690 }
2691 memset (buf, ' ', k);
2692 buf[k] = '\0';
2693 for (; j < height; j++)
2694 {
2695 if (xwidth)
2696 {
2697 tty_gotoyx (r + j, c - xwidth);
2698 /* tty_print_nstring (buf, xwidth - 1); */
2699 tty_print_string (str_fit_to_term (buf, xwidth - 1, J_LEFT_FIT));
2700 }
2701 tty_gotoyx (r + j, c);
2702 /* tty_print_nstring (buf, width); */
2703 tty_print_string (str_fit_to_term (buf, width, J_LEFT_FIT));
2704 }
2705
2706 return 0;
2707 }
2708
2709 /* --------------------------------------------------------------------------------------------- */
2710
2711 static void
2712 dview_status (const WDiff * dview, int ord, int width, int c)
2713 {
2714 const char *buf;
2715 int filename_width;
2716 int linenum, lineofs;
2717
2718 tty_setcolor (STATUSBAR_COLOR);
2719
2720 tty_gotoyx (0, c);
2721 get_line_numbers (dview->a[ord], dview->skip_rows, &linenum, &lineofs);
2722
2723 filename_width = width - 22;
2724 if (filename_width < 8)
2725 filename_width = 8;
2726
2727 buf = str_term_trim (strip_home_and_password (dview->label[ord]), filename_width);
2728 if (ord == 0)
2729 tty_printf ("%-*s %6d+%-4d Col %-4d ", filename_width, buf, linenum, lineofs,
2730 dview->skip_cols);
2731 else
2732 tty_printf ("%-*s %6d+%-4d Dif %-4d ", filename_width, buf, linenum, lineofs, dview->ndiff);
2733 }
2734
2735 /* --------------------------------------------------------------------------------------------- */
2736
2737 static void
2738 dview_redo (WDiff * dview)
2739 {
2740 if (dview->display_numbers)
2741 {
2742 int old = dview->display_numbers;
2743 dview->display_numbers = calc_nwidth ((const GArray **) dview->a);
2744 dview->new_frame = (old != dview->display_numbers);
2745 }
2746 dview_reread (dview);
2747 }
2748
2749 /* --------------------------------------------------------------------------------------------- */
2750
2751 static void
2752 dview_edit (WDiff * dview, int ord)
2753 {
2754 Dlg_head *h;
2755 gboolean h_modal;
2756 int linenum, lineofs;
2757
2758 if (dview->dsrc == DATA_SRC_TMP)
2759 {
2760 error_dialog (_("Edit"), _("Edit is disabled"));
2761 return;
2762 }
2763
2764 h = ((Widget *) dview)->owner;
2765 h_modal = h->modal;
2766
2767 get_line_numbers (dview->a[ord], dview->skip_rows, &linenum, &lineofs);
2768 h->modal = TRUE; /* not allow edit file in several editors */
2769 do_edit_at_line (dview->file[ord], use_internal_edit, linenum);
2770 h->modal = h_modal;
2771 dview_redo (dview);
2772 dview_update (dview);
2773 }
2774
2775 /* --------------------------------------------------------------------------------------------- */
2776
2777 static void
2778 dview_goto_cmd (WDiff * dview, int ord)
2779 {
2780 static const char *title[2] = { N_("Goto line (left)"), N_("Goto line (right)") };
2781 static char prev[256];
2782 /* XXX some statics here, to be remembered between runs */
2783
2784 int newline;
2785 char *input;
2786
2787 input = input_dialog (_(title[ord]), _("Enter line:"), MC_HISTORY_YDIFF_GOTO_LINE, prev);
2788 if (input != NULL)
2789 {
2790 const char *s = input;
2791 if (scan_deci (&s, &newline) == 0 && *s == '\0')
2792 {
2793 size_t i = 0;
2794 if (newline > 0)
2795 {
2796 const DIFFLN *p;
2797 for (; i < dview->a[ord]->len; i++)
2798 {
2799 p = &g_array_index (dview->a[ord], DIFFLN, i);
2800 if (p->line == newline)
2801 {
2802 break;
2803 }
2804 }
2805 }
2806 dview->skip_rows = dview->search.last_accessed_num_line = (ssize_t) i;
2807 g_snprintf (prev, sizeof (prev), "%d", newline);
2808 }
2809 g_free (input);
2810 }
2811 }
2812
2813 /* --------------------------------------------------------------------------------------------- */
2814
2815 static void
2816 dview_labels (WDiff * dview)
2817 {
2818 Dlg_head *h = dview->widget.owner;
2819 WButtonBar *b = find_buttonbar (h);
2820
2821 buttonbar_set_label (b, 1, Q_ ("ButtonBar|Help"), diff_map, (Widget *) dview);
2822 buttonbar_set_label (b, 2, Q_ ("ButtonBar|Save"), diff_map, (Widget *) dview);
2823 buttonbar_set_label (b, 4, Q_ ("ButtonBar|Edit"), diff_map, (Widget *) dview);
2824 buttonbar_set_label (b, 5, Q_ ("ButtonBar|Merge"), diff_map, (Widget *) dview);
2825 buttonbar_set_label (b, 7, Q_ ("ButtonBar|Search"), diff_map, (Widget *) dview);
2826 buttonbar_set_label (b, 9, Q_ ("ButtonBar|Options"), diff_map, (Widget *) dview);
2827 buttonbar_set_label (b, 10, Q_ ("ButtonBar|Quit"), diff_map, (Widget *) dview);
2828 }
2829
2830
2831 /* --------------------------------------------------------------------------------------------- */
2832
2833 static int
2834 dview_event (Gpm_Event * event, void *x)
2835 {
2836 WDiff *dview = (WDiff *) x;
2837 int result = MOU_NORMAL;
2838
2839 /* We are not interested in the release events */
2840 if ((event->type & (GPM_DOWN | GPM_DRAG)) == 0)
2841 {
2842 return result;
2843 }
2844
2845 /* Wheel events */
2846 if ((event->buttons & GPM_B_UP) != 0 && (event->type & GPM_DOWN) != 0)
2847 {
2848 dview->skip_rows -= 2;
2849 dview->search.last_accessed_num_line = dview->skip_rows;
2850 dview_update (dview);
2851 }
2852 else if ((event->buttons & GPM_B_DOWN) != 0 && (event->type & GPM_DOWN) != 0)
2853 {
2854 dview->skip_rows += 2;
2855 dview->search.last_accessed_num_line = dview->skip_rows;
2856 dview_update (dview);
2857 }
2858
2859 return result;
2860 }
2861
2862 static gboolean
2863 dview_save (WDiff * dview)
2864 {
2865 gboolean res = TRUE;
2866 if (!dview->merged)
2867 return res;
2868 res = mc_util_unlink_backup_if_possible (dview->file[0], "~~~");
2869 dview->merged = !res;
2870 return res;
2871 }
2872
2873 static void
2874 dview_do_save (WDiff * dview)
2875 {
2876 (void) dview_save (dview);
2877 }
2878
2879 static void
2880 dview_save_options (WDiff * dview)
2881 {
2882 mc_config_set_bool (mc_main_config, "DiffView", "show_symbols",
2883 dview->display_symbols != 0 ? TRUE : FALSE);
2884 mc_config_set_bool (mc_main_config, "DiffView", "show_numbers",
2885 dview->display_numbers != 0 ? TRUE : FALSE);
2886 mc_config_set_int (mc_main_config, "DiffView", "tab_size", dview->tab_size);
2887
2888 mc_config_set_int (mc_main_config, "DiffView", "diff_quality", dview->opt.quality);
2889
2890 mc_config_set_bool (mc_main_config, "DiffView", "diff_ignore_tws",
2891 dview->opt.strip_trailing_cr);
2892 mc_config_set_bool (mc_main_config, "DiffView", "diff_ignore_all_space",
2893 dview->opt.ignore_all_space);
2894 mc_config_set_bool (mc_main_config, "DiffView", "diff_ignore_space_change",
2895 dview->opt.ignore_space_change);
2896 mc_config_set_bool (mc_main_config, "DiffView", "diff_tab_expansion",
2897 dview->opt.ignore_tab_expansion);
2898 mc_config_set_bool (mc_main_config, "DiffView", "diff_ignore_case", dview->opt.ignore_case);
2899 }
2900
2901 static void
2902 dview_load_options (WDiff * dview)
2903 {
2904 gboolean show_numbers, show_symbols;
2905 int tab_size;
2906
2907 show_symbols = mc_config_get_bool (mc_main_config, "DiffView", "show_symbols", FALSE);
2908 if (show_symbols)
2909 dview->display_symbols = 1;
2910 show_numbers = mc_config_get_bool (mc_main_config, "DiffView", "show_numbers", FALSE);
2911 if (show_numbers)
2912 dview->display_numbers = calc_nwidth ((const GArray ** const) dview->a);
2913 tab_size = mc_config_get_int (mc_main_config, "DiffView", "tab_size", 8);
2914 if (tab_size > 0 && tab_size < 9)
2915 dview->tab_size = tab_size;
2916 else
2917 dview->tab_size = 8;
2918
2919 dview->opt.quality = mc_config_get_int (mc_main_config, "DiffView", "diff_quality", 0);
2920
2921 dview->opt.strip_trailing_cr =
2922 mc_config_get_bool (mc_main_config, "DiffView", "diff_ignore_tws", FALSE);
2923 dview->opt.ignore_all_space =
2924 mc_config_get_bool (mc_main_config, "DiffView", "diff_ignore_all_space", FALSE);
2925 dview->opt.ignore_space_change =
2926 mc_config_get_bool (mc_main_config, "DiffView", "diff_ignore_space_change", FALSE);
2927 dview->opt.ignore_tab_expansion =
2928 mc_config_get_bool (mc_main_config, "DiffView", "diff_tab_expansion", FALSE);
2929 dview->opt.ignore_case =
2930 mc_config_get_bool (mc_main_config, "DiffView", "diff_ignore_case", FALSE);
2931
2932 dview->new_frame = 1;
2933 }
2934
2935 /*
2936 * Check if it's OK to close the diff viewer. If there are unsaved changes,
2937 * ask user.
2938 */
2939 static gboolean
2940 dview_ok_to_exit (WDiff * dview)
2941 {
2942 gboolean res = TRUE;
2943 int act;
2944
2945 if (!dview->merged)
2946 return res;
2947
2948 act = query_dialog (_("Quit"), !mc_global.widget.midnight_shutdown ?
2949 _("File was modified. Save with exit?") :
2950 _("Midnight Commander is being shut down.\nSave modified file?"),
2951 D_NORMAL, 2, _("&Yes"), _("&No"));
2952
2953 /* Esc is No */
2954 if (mc_global.widget.midnight_shutdown || (act == -1))
2955 act = 1;
2956
2957 switch (act)
2958 {
2959 case -1: /* Esc */
2960 res = FALSE;
2961 break;
2962 case 0: /* Yes */
2963 (void) dview_save (dview);
2964 res = TRUE;
2965 break;
2966 case 1: /* No */
2967 if (mc_util_restore_from_backup_if_possible (dview->file[0], "~~~"))
2968 res = mc_util_unlink_backup_if_possible (dview->file[0], "~~~");
2969 /* fall through */
2970 default:
2971 res = TRUE;
2972 break;
2973 }
2974 return res;
2975 }
2976
2977 /* --------------------------------------------------------------------------------------------- */
2978
2979 static cb_ret_t
2980 dview_execute_cmd (WDiff * dview, unsigned long command)
2981 {
2982 cb_ret_t res = MSG_HANDLED;
2983 switch (command)
2984 {
2985 case CK_ShowSymbols:
2986 dview->display_symbols ^= 1;
2987 dview->new_frame = 1;
2988 break;
2989 case CK_ShowNumbers:
2990 dview->display_numbers ^= calc_nwidth ((const GArray ** const) dview->a);
2991 dview->new_frame = 1;
2992 break;
2993 case CK_SplitFull:
2994 dview->full ^= 1;
2995 dview->new_frame = 1;
2996 break;
2997 case CK_SplitEqual:
2998 if (!dview->full)
2999 {
3000 dview->bias = 0;
3001 dview->new_frame = 1;
3002 }
3003 break;
3004 case CK_SplitMore:
3005 if (!dview->full)
3006 {
3007 dview_compute_split (dview, 1);
3008 dview->new_frame = 1;
3009 }
3010 break;
3011
3012 case CK_SplitLess:
3013 if (!dview->full)
3014 {
3015 dview_compute_split (dview, -1);
3016 dview->new_frame = 1;
3017 }
3018 break;
3019 case CK_Tab2:
3020 dview->tab_size = 2;
3021 break;
3022 case CK_Tab3:
3023 dview->tab_size = 3;
3024 break;
3025 case CK_Tab4:
3026 dview->tab_size = 4;
3027 break;
3028 case CK_Tab8:
3029 dview->tab_size = 8;
3030 break;
3031 case CK_Swap:
3032 dview->ord ^= 1;
3033 break;
3034 case CK_Redo:
3035 dview_redo (dview);
3036 break;
3037 case CK_HunkNext:
3038 dview->skip_rows = dview->search.last_accessed_num_line =
3039 find_next_hunk (dview->a[0], dview->skip_rows);
3040 break;
3041 case CK_HunkPrev:
3042 dview->skip_rows = dview->search.last_accessed_num_line =
3043 find_prev_hunk (dview->a[0], dview->skip_rows);
3044 break;
3045 case CK_Goto:
3046 dview_goto_cmd (dview, TRUE);
3047 break;
3048 case CK_Edit:
3049 dview_edit (dview, dview->ord);
3050 break;
3051 case CK_Merge:
3052 do_merge_hunk (dview);
3053 dview_redo (dview);
3054 break;
3055 case CK_EditOther:
3056 dview_edit (dview, dview->ord ^ 1);
3057 break;
3058 case CK_Search:
3059 dview_search_cmd (dview);
3060 break;
3061 case CK_SearchContinue:
3062 dview_continue_search_cmd (dview);
3063 break;
3064 case CK_Top:
3065 dview->skip_rows = dview->search.last_accessed_num_line = 0;
3066 break;
3067 case CK_Bottom:
3068 dview->skip_rows = dview->search.last_accessed_num_line = dview->a[0]->len - 1;
3069 break;
3070 case CK_Up:
3071 if (dview->skip_rows > 0)
3072 {
3073 dview->skip_rows--;
3074 dview->search.last_accessed_num_line = dview->skip_rows;
3075 }
3076 break;
3077 case CK_Down:
3078 dview->skip_rows++;
3079 dview->search.last_accessed_num_line = dview->skip_rows;
3080 break;
3081 case CK_PageDown:
3082 if (dview->height > 2)
3083 {
3084 dview->skip_rows += dview->height - 2;
3085 dview->search.last_accessed_num_line = dview->skip_rows;
3086 }
3087 break;
3088 case CK_PageUp:
3089 if (dview->height > 2)
3090 {
3091 dview->skip_rows -= dview->height - 2;
3092 dview->search.last_accessed_num_line = dview->skip_rows;
3093 }
3094 break;
3095 case CK_Left:
3096 dview->skip_cols--;
3097 break;
3098 case CK_Right:
3099 dview->skip_cols++;
3100 break;
3101 case CK_LeftQuick:
3102 dview->skip_cols -= 8;
3103 break;
3104 case CK_RightQuick:
3105 dview->skip_cols += 8;
3106 break;
3107 case CK_Home:
3108 dview->skip_cols = 0;
3109 break;
3110 case CK_Shell:
3111 view_other_cmd ();
3112 break;
3113 case CK_Quit:
3114 dview->view_quit = 1;
3115 break;
3116 case CK_Save:
3117 dview_do_save (dview);
3118 break;
3119 case CK_Options:
3120 dview_diff_options (dview);
3121 break;
3122 #ifdef HAVE_CHARSET
3123 case CK_SelectCodepage:
3124 dview_select_encoding (dview);
3125 dview_reread (dview);
3126 tty_touch_screen ();
3127 repaint_screen ();
3128 break;
3129 #endif
3130 case CK_Cancel:
3131 /* don't close diffviewer due to SIGINT */
3132 break;
3133 default:
3134 res = MSG_NOT_HANDLED;
3135 }
3136 return res;
3137 }
3138
3139 /* --------------------------------------------------------------------------------------------- */
3140
3141 static cb_ret_t
3142 dview_handle_key (WDiff * dview, int key)
3143 {
3144 unsigned long command;
3145
3146 key = convert_from_input_c (key);
3147
3148 command = keybind_lookup_keymap_command (diff_map, key);
3149 if ((command != CK_IgnoreKey) && (dview_execute_cmd (dview, command) == MSG_HANDLED))
3150 return MSG_HANDLED;
3151
3152 /* Key not used */
3153 return MSG_NOT_HANDLED;
3154 }
3155
3156 /* --------------------------------------------------------------------------------------------- */
3157
3158 static cb_ret_t
3159 dview_callback (Widget * w, widget_msg_t msg, int parm)
3160 {
3161 WDiff *dview = (WDiff *) w;
3162 Dlg_head *h = dview->widget.owner;
3163 cb_ret_t i;
3164
3165 switch (msg)
3166 {
3167 case WIDGET_INIT:
3168 dview_labels (dview);
3169 dview_load_options (dview);
3170 dview_update (dview);
3171 return MSG_HANDLED;
3172
3173 case WIDGET_DRAW:
3174 dview->new_frame = 1;
3175 dview_update (dview);
3176 return MSG_HANDLED;
3177
3178 case WIDGET_KEY:
3179 i = dview_handle_key (dview, parm);
3180 if (dview->view_quit)
3181 dlg_stop (h);
3182 else
3183 dview_update (dview);
3184 return i;
3185
3186 case WIDGET_COMMAND:
3187 i = dview_execute_cmd (dview, parm);
3188 if (dview->view_quit)
3189 dlg_stop (h);
3190 else
3191 dview_update (dview);
3192 return i;
3193
3194 case WIDGET_DESTROY:
3195 dview_save_options (dview);
3196 dview_fini (dview);
3197 return MSG_HANDLED;
3198
3199 default:
3200 return default_proc (msg, parm);
3201 }
3202 }
3203
3204 /* --------------------------------------------------------------------------------------------- */
3205
3206 static void
3207 dview_adjust_size (Dlg_head * h)
3208 {
3209 WDiff *dview;
3210 WButtonBar *bar;
3211
3212 /* Look up the viewer and the buttonbar, we assume only two widgets here */
3213 dview = (WDiff *) find_widget_type (h, dview_callback);
3214 bar = find_buttonbar (h);
3215 widget_set_size (&dview->widget, 0, 0, LINES - 1, COLS);
3216 widget_set_size ((Widget *) bar, LINES - 1, 0, 1, COLS);
3217
3218 dview_compute_areas (dview);
3219 }
3220
3221 /* --------------------------------------------------------------------------------------------- */
3222
3223 static cb_ret_t
3224 dview_dialog_callback (Dlg_head * h, Widget * sender, dlg_msg_t msg, int parm, void *data)
3225 {
3226 WDiff *dview = (WDiff *) data;
3227
3228 switch (msg)
3229 {
3230 case DLG_RESIZE:
3231 dview_adjust_size (h);
3232 return MSG_HANDLED;
3233
3234 case DLG_ACTION:
3235 /* shortcut */
3236 if (sender == NULL)
3237 return dview_execute_cmd (NULL, parm);
3238 /* message from buttonbar */
3239 if (sender == (Widget *) find_buttonbar (h))
3240 {
3241 if (data != NULL)
3242 return send_message ((Widget *) data, WIDGET_COMMAND, parm);
3243
3244 dview = (WDiff *) find_widget_type (h, dview_callback);
3245 return dview_execute_cmd (dview, parm);
3246 }
3247 return MSG_NOT_HANDLED;
3248
3249 case DLG_VALIDATE:
3250 dview = (WDiff *) find_widget_type (h, dview_callback);
3251 h->state = DLG_ACTIVE; /* don't stop the dialog before final decision */
3252 if (dview_ok_to_exit (dview))
3253 h->state = DLG_CLOSED;
3254 return MSG_HANDLED;
3255
3256 default:
3257 return default_dlg_callback (h, sender, msg, parm, data);
3258 }
3259 }
3260
3261 /* --------------------------------------------------------------------------------------------- */
3262
3263 static char *
3264 dview_get_title (const Dlg_head * h, size_t len)
3265 {
3266 const WDiff *dview = (const WDiff *) find_widget_type (h, dview_callback);
3267 const char *modified = dview->merged ? " (*) " : " ";
3268 size_t len1;
3269 GString *title;
3270
3271 len1 = (len - str_term_width1 (_("Diff:")) - strlen (modified) - 3) / 2;
3272
3273 title = g_string_sized_new (len);
3274 g_string_append (title, _("Diff:"));
3275 g_string_append (title, modified);
3276 g_string_append (title, str_term_trim (dview->label[0], len1));
3277 g_string_append (title, " | ");
3278 g_string_append (title, str_term_trim (dview->label[1], len1));
3279
3280 return g_string_free (title, FALSE);
3281 }
3282
3283 /*** public functions ****************************************************************************/
3284 /* --------------------------------------------------------------------------------------------- */
3285
3286 int
3287 diff_view (const char *file1, const char *file2, const char *label1, const char *label2)
3288 {
3289 int error;
3290 WDiff *dview;
3291 Dlg_head *dview_dlg;
3292
3293 /* Create dialog and widgets, put them on the dialog */
3294 dview_dlg =
3295 create_dlg (FALSE, 0, 0, LINES, COLS, NULL, dview_dialog_callback,
3296 "[Diff Viewer]", NULL, DLG_WANT_TAB);
3297
3298 dview = g_new0 (WDiff, 1);
3299
3300 init_widget (&dview->widget, 0, 0, LINES - 1, COLS,
3301 (callback_fn) dview_callback, (mouse_h) dview_event);
3302
3303 widget_want_cursor (dview->widget, 0);
3304
3305 add_widget (dview_dlg, dview);
3306 add_widget (dview_dlg, buttonbar_new (TRUE));
3307
3308 dview_dlg->get_title = dview_get_title;
3309
3310 error = dview_init (dview, "-a", file1, file2, label1, label2, DATA_SRC_MEM); /* XXX binary diff? */
3311
3312 /* Please note that if you add another widget,
3313 * you have to modify dview_adjust_size to
3314 * be aware of it
3315 */
3316 if (error == 0)
3317 run_dlg (dview_dlg);
3318
3319 if ((error != 0) || (dview_dlg->state == DLG_CLOSED))
3320 destroy_dlg (dview_dlg);
3321
3322 return error;
3323 }
3324
3325 /* --------------------------------------------------------------------------------------------- */
3326
3327 #define GET_FILE_AND_STAMP(n) \
3328 do \
3329 { \
3330 vfs_path_t *vpath = vfs_path_from_str(file##n); \
3331 use_copy##n = 0; \
3332 real_file##n = file##n; \
3333 if (!vfs_file_is_local (vpath)) \
3334 { \
3335 real_file##n = mc_getlocalcopy (file##n); \
3336 if (real_file##n != NULL) \
3337 { \
3338 use_copy##n = 1; \
3339 if (mc_stat (real_file##n, &st##n) != 0) \
3340 use_copy##n = -1; \
3341 } \
3342 } \
3343 vfs_path_free(vpath); \
3344 } \
3345 while (0)
3346
3347 #define UNGET_FILE(n) \
3348 do \
3349 { \
3350 if (use_copy##n) \
3351 { \
3352 int changed = 0; \
3353 if (use_copy##n > 0) \
3354 { \
3355 time_t mtime; \
3356 mtime = st##n.st_mtime; \
3357 if (mc_stat (real_file##n, &st##n) == 0) \
3358 changed = (mtime != st##n.st_mtime); \
3359 } \
3360 mc_ungetlocalcopy (file##n, real_file##n, changed); \
3361 g_free (real_file##n); \
3362 } \
3363 } \
3364 while (0)
3365
3366 void
3367 dview_diff_cmd (void)
3368 {
3369 int rv = 0;
3370 char *file0 = NULL;
3371 char *file1 = NULL;
3372 int is_dir0 = 0;
3373 int is_dir1 = 0;
3374
3375 if (mc_global.mc_run_mode == MC_RUN_FULL)
3376 {
3377 const WPanel *panel0 = current_panel;
3378 const WPanel *panel1 = other_panel;
3379 if (get_current_index ())
3380 {
3381 panel0 = other_panel;
3382 panel1 = current_panel;
3383 }
3384 file0 = concat_dir_and_file (panel0->cwd, selection (panel0)->fname);
3385 file1 = concat_dir_and_file (panel1->cwd, selection (panel1)->fname);
3386 is_dir0 = S_ISDIR (selection (panel0)->st.st_mode);
3387 is_dir1 = S_ISDIR (selection (panel1)->st.st_mode);
3388 }
3389
3390 if (rv == 0)
3391 {
3392 rv = -1;
3393 if (file0 != NULL && !is_dir0 && file1 != NULL && !is_dir1)
3394 {
3395 int use_copy0;
3396 int use_copy1;
3397 struct stat st0;
3398 struct stat st1;
3399 char *real_file0;
3400 char *real_file1;
3401 GET_FILE_AND_STAMP (0);
3402 GET_FILE_AND_STAMP (1);
3403 if (real_file0 != NULL && real_file1 != NULL)
3404 {
3405 rv = diff_view (real_file0, real_file1, file0, file1);
3406 }
3407 UNGET_FILE (1);
3408 UNGET_FILE (0);
3409 }
3410 }
3411
3412 g_free (file1);
3413 g_free (file0);
3414
3415 if (rv != 0)
3416 message (1, MSG_ERROR, _("Two files are needed to compare"));
3417 }
3418
3419 /* --------------------------------------------------------------------------------------------- */
3420
3421 void
3422 dview_update (WDiff * dview)
3423 {
3424 int height = dview->height;
3425 int width1;
3426 int width2;
3427
3428 int last = dview->a[0]->len - 1;
3429
3430 if (dview->skip_rows > last)
3431 {
3432 dview->skip_rows = dview->search.last_accessed_num_line = last;
3433 }
3434 if (dview->skip_rows < 0)
3435 {
3436 dview->skip_rows = dview->search.last_accessed_num_line = 0;
3437 }
3438 if (dview->skip_cols < 0)
3439 {
3440 dview->skip_cols = 0;
3441 }
3442
3443 if (height < 2)
3444 {
3445 return;
3446 }
3447
3448 width1 = dview->half1 + dview->bias;
3449 width2 = dview->half2 - dview->bias;
3450 if (dview->full)
3451 {
3452 width1 = COLS;
3453 width2 = 0;
3454 }
3455
3456 if (dview->new_frame)
3457 {
3458 int xwidth = dview->display_symbols + dview->display_numbers;
3459
3460 tty_setcolor (NORMAL_COLOR);
3461 if (width1 > 1)
3462 {
3463 tty_draw_box (1, 0, height, width1, FALSE);
3464 }
3465 if (width2 > 1)
3466 {
3467 tty_draw_box (1, width1, height, width2, FALSE);
3468 }
3469
3470 if (xwidth)
3471 {
3472 xwidth++;
3473 if (xwidth < width1 - 1)
3474 {
3475 tty_gotoyx (1, xwidth);
3476 tty_print_alt_char (mc_tty_frm[MC_TTY_FRM_DTOPMIDDLE], FALSE);
3477 tty_gotoyx (height, xwidth);
3478 tty_print_alt_char (mc_tty_frm[MC_TTY_FRM_DBOTTOMMIDDLE], FALSE);
3479 tty_draw_vline (2, xwidth, mc_tty_frm[MC_TTY_FRM_VERT], height - 2);
3480 }
3481 if (xwidth < width2 - 1)
3482 {
3483 tty_gotoyx (1, width1 + xwidth);
3484 tty_print_alt_char (mc_tty_frm[MC_TTY_FRM_DTOPMIDDLE], FALSE);
3485 tty_gotoyx (height, width1 + xwidth);
3486 tty_print_alt_char (mc_tty_frm[MC_TTY_FRM_DBOTTOMMIDDLE], FALSE);
3487 tty_draw_vline (2, width1 + xwidth, mc_tty_frm[MC_TTY_FRM_VERT], height - 2);
3488 }
3489 }
3490 dview->new_frame = 0;
3491 }
3492
3493 if (width1 > 2)
3494 {
3495 dview_status (dview, dview->ord, width1, 0);
3496 dview_display_file (dview, dview->ord, 2, 1, height - 2, width1 - 2);
3497 }
3498 if (width2 > 2)
3499 {
3500 dview_status (dview, dview->ord ^ 1, width2, width1);
3501 dview_display_file (dview, dview->ord ^ 1, 2, width1 + 1, height - 2, width2 - 2);
3502 }
3503 }
3504
3505 /* --------------------------------------------------------------------------------------------- */
Midnight Commander