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