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