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