src/diffviewer/ydiff.c

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