src/diffviewer/ydiff.c

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