src/diffviewer/ydiff.c

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