src/diffviewer/ydiff.c

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