src/diffviewer/ydiff.c

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