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