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