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