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