| | 1 | /* |
| | 2 | * Copyright (c) 2007 Daniel Borca All rights reserved. |
| | 3 | * |
| | 4 | * This program is free software; you can redistribute it and/or modify |
| | 5 | * it under the terms of the GNU General Public License as published by |
| | 6 | * the Free Software Foundation; either version 2 of the License, or |
| | 7 | * (at your option) any later version. |
| | 8 | * |
| | 9 | * This program is distributed in the hope that it will be useful, |
| | 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| | 12 | * GNU General Public License for more details. |
| | 13 | * |
| | 14 | * You should have received a copy of the GNU General Public License |
| | 15 | * along with this program; if not, write to the Free Software |
| | 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| | 17 | */ |
| | 18 | |
| | 19 | |
| | 20 | #include <config.h> |
| | 21 | #include <ctype.h> |
| | 22 | #include <errno.h> |
| | 23 | #include <fcntl.h> |
| | 24 | #include <stdlib.h> |
| | 25 | #include <sys/stat.h> |
| | 26 | #include "global.h" |
| | 27 | #include "tty.h" |
| | 28 | #include "cmd.h" |
| | 29 | #include "dialog.h" |
| | 30 | #include "widget.h" |
| | 31 | #include "color.h" |
| | 32 | #include "help.h" |
| | 33 | #include "key.h" |
| | 34 | #include "wtools.h" |
| | 35 | #include "charsets.h" |
| | 36 | #include "history.h" |
| | 37 | #include "ydiff.h" |
| | 38 | |
| | 39 | |
| | 40 | #ifdef USE_DIFF_VIEW |
| | 41 | |
| | 42 | typedef struct { |
| | 43 | int len, max; |
| | 44 | void *data; |
| | 45 | int error; |
| | 46 | int eltsize; |
| | 47 | int growth; |
| | 48 | } ARRAY; |
| | 49 | |
| | 50 | #define FILE_READ_BUF 4096 |
| | 51 | #define FILE_FLAG_TEMP (1 << 0) |
| | 52 | |
| | 53 | typedef struct { |
| | 54 | int fd; |
| | 55 | int pos; |
| | 56 | int len; |
| | 57 | char *buf; |
| | 58 | int flags; |
| | 59 | void *data; |
| | 60 | } FBUF; |
| | 61 | |
| | 62 | #define ADD_CH '+' |
| | 63 | #define DEL_CH '-' |
| | 64 | #define CHG_CH '*' |
| | 65 | #define EQU_CH ' ' |
| | 66 | |
| | 67 | typedef struct { |
| | 68 | int a[2][2]; |
| | 69 | int cmd; |
| | 70 | } DIFFCMD; |
| | 71 | |
| | 72 | typedef int (*DFUNC) (void *ctx, int ch, int line, off_t off, size_t sz, const char *str); |
| | 73 | |
| | 74 | #define HDIFF_ENABLE 1 |
| | 75 | #define HDIFF_MINCTX 5 |
| | 76 | #define HDIFF_DEPTH 10 |
| | 77 | |
| | 78 | typedef struct { |
| | 79 | int off; |
| | 80 | int len; |
| | 81 | } BRACKET[2]; |
| | 82 | |
| | 83 | typedef int PAIR[2]; |
| | 84 | |
| | 85 | #define TAB_SKIP(ts, pos) ((ts) - (pos) % (ts)) |
| | 86 | |
| | 87 | typedef enum { |
| | 88 | DATA_SRC_MEM = 0, |
| | 89 | DATA_SRC_TMP = 1, |
| | 90 | DATA_SRC_ORG = 2 |
| | 91 | } DSRC; |
| | 92 | |
| | 93 | typedef struct { |
| | 94 | int ch; |
| | 95 | int line; |
| | 96 | union { |
| | 97 | off_t off; |
| | 98 | size_t len; |
| | 99 | } u; |
| | 100 | void *p; |
| | 101 | } DIFFLN; |
| | 102 | |
| | 103 | typedef struct { |
| | 104 | FBUF *f; |
| | 105 | ARRAY *a; |
| | 106 | DSRC dsrc; |
| | 107 | } PRINTER_CTX; |
| | 108 | |
| | 109 | typedef struct { |
| | 110 | Widget widget; |
| | 111 | |
| | 112 | const char *args; /* Args passed to diff */ |
| | 113 | const char *file[2]; /* filenames */ |
| | 114 | const char *label[2]; |
| | 115 | FBUF *f[2]; |
| | 116 | ARRAY a[2]; |
| | 117 | ARRAY **hdiff; |
| | 118 | int ndiff; /* number of hunks */ |
| | 119 | DSRC dsrc; /* data source: memory or temporary file */ |
| | 120 | |
| | 121 | int view_quit:1; /* Quit flag */ |
| | 122 | |
| | 123 | int height; |
| | 124 | int half1; |
| | 125 | int half2; |
| | 126 | int width1; |
| | 127 | int width2; |
| | 128 | int bias; |
| | 129 | int new_frame; |
| | 130 | int skip_rows; |
| | 131 | int skip_cols; |
| | 132 | int display_symbols; |
| | 133 | int display_numbers; |
| | 134 | int show_cr; |
| | 135 | int show_hdiff; |
| | 136 | int tab_size; |
| | 137 | int ord; |
| | 138 | int full; |
| | 139 | int last_found; |
| | 140 | |
| | 141 | struct { |
| | 142 | int quality; |
| | 143 | int strip_trailing_cr; |
| | 144 | int ignore_tab_expansion; |
| | 145 | int ignore_space_change; |
| | 146 | int ignore_all_space; |
| | 147 | int ignore_case; |
| | 148 | } opt; |
| | 149 | } WDiff; |
| | 150 | |
| | 151 | |
| | 152 | #define OPTX 50 |
| | 153 | #define OPTY 12 |
| | 154 | |
| | 155 | static const char *quality_str[] = { |
| | 156 | N_("&Normal"), |
| | 157 | N_("&Fastest"), |
| | 158 | N_("&Minimal") |
| | 159 | }; |
| | 160 | |
| | 161 | static QuickWidget diffopt_widgets[] = { |
| | 162 | { quick_button, 6, 10, 9, OPTY, N_("&Cancel"), 0, B_CANCEL, NULL, NULL, NULL }, |
| | 163 | { quick_button, 3, 10, 9, OPTY, N_("&OK"), 0, B_ENTER, NULL, NULL, NULL }, |
| | 164 | { quick_radio, 34, OPTX, 4, OPTY, "", 3, 2, NULL, const_cast(char **, quality_str), NULL }, |
| | 165 | { quick_checkbox, 4, OPTX, 7, OPTY, N_("strip trailing &CR"), 0, 0, NULL, NULL, NULL }, |
| | 166 | { quick_checkbox, 4, OPTX, 6, OPTY, N_("ignore all &Whitespace"), 0, 0, NULL, NULL, NULL }, |
| | 167 | { quick_checkbox, 4, OPTX, 5, OPTY, N_("ignore &Space change"), 0, 0, NULL, NULL, NULL }, |
| | 168 | { quick_checkbox, 4, OPTX, 4, OPTY, N_("ignore tab &Expansion"), 0, 0, NULL, NULL, NULL }, |
| | 169 | { quick_checkbox, 4, OPTX, 3, OPTY, N_("&Ignore case"), 0, 0, NULL, NULL, NULL }, |
| | 170 | NULL_QuickWidget |
| | 171 | }; |
| | 172 | |
| | 173 | static QuickDialog diffopt = { |
| | 174 | OPTX, OPTY, -1, -1, |
| | 175 | N_(" Diff Options "), "[Diff Options]", |
| | 176 | diffopt_widgets, 0 |
| | 177 | }; |
| | 178 | |
| | 179 | #define SEARCH_DLG_WIDTH 58 |
| | 180 | #define SEARCH_DLG_HEIGHT 10 |
| | 181 | |
| | 182 | static const char *search_str[] = { |
| | 183 | N_("&Normal") |
| | 184 | }; |
| | 185 | |
| | 186 | static QuickWidget search_widgets[] = { |
| | 187 | { quick_button, 6, 10, 7, SEARCH_DLG_HEIGHT, N_("&Cancel"), 0, B_CANCEL, NULL, NULL, NULL }, |
| | 188 | { quick_button, 2, 10, 7, SEARCH_DLG_HEIGHT, N_("&OK"), 0, B_ENTER, NULL, NULL, NULL }, |
| | 189 | { quick_checkbox, 33, SEARCH_DLG_WIDTH, 6, SEARCH_DLG_HEIGHT, N_("&Whole words only"), 0, 0, NULL, NULL, NULL }, |
| | 190 | { quick_checkbox, 33, SEARCH_DLG_WIDTH, 5, SEARCH_DLG_HEIGHT, N_("&Backwards"), 0, 0, NULL, NULL, NULL }, |
| | 191 | { quick_checkbox, 33, SEARCH_DLG_WIDTH, 4, SEARCH_DLG_HEIGHT, N_("case &Sensitive"), 0, 0, NULL, NULL, NULL }, |
| | 192 | { quick_radio, 4, SEARCH_DLG_WIDTH, 4, SEARCH_DLG_HEIGHT, "", 1, 0, NULL, const_cast(char **, search_str), NULL }, |
| | 193 | { quick_input, 3, SEARCH_DLG_WIDTH, 3, SEARCH_DLG_HEIGHT, "", 52, 0, NULL, NULL, "diff-search" }, |
| | 194 | { quick_label, 2, SEARCH_DLG_WIDTH, 2, SEARCH_DLG_HEIGHT, N_(" Enter search string:"), 0, 0, NULL, NULL, NULL }, |
| | 195 | NULL_QuickWidget |
| | 196 | }; |
| | 197 | |
| | 198 | static QuickDialog search_input = { |
| | 199 | SEARCH_DLG_WIDTH, SEARCH_DLG_HEIGHT, -1, 0, |
| | 200 | N_("Search"), "[Input Line Keys]", |
| | 201 | search_widgets, 0 |
| | 202 | }; |
| | 203 | |
| | 204 | static const char *wholechars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"; |
| | 205 | |
| | 206 | #define error_dialog(h, s) query_dialog(h, s, D_ERROR, 1, _("&Dismiss")) |
| | 207 | |
| | 208 | |
| | 209 | /* array *********************************************************************/ |
| | 210 | |
| | 211 | |
| | 212 | /** |
| | 213 | * Initialize array. |
| | 214 | * |
| | 215 | * \param a array, must be non-NULL |
| | 216 | * \param eltsize element size |
| | 217 | * \param growth growth constant |
| | 218 | */ |
| | 219 | static void |
| | 220 | arr_init (ARRAY *a, int eltsize, int growth) |
| | 221 | { |
| | 222 | a->len = a->max = 0; |
| | 223 | a->data = NULL; |
| | 224 | a->error = 0; |
| | 225 | a->eltsize = eltsize; |
| | 226 | a->growth = growth; |
| | 227 | } |
| | 228 | |
| | 229 | |
| | 230 | /** |
| | 231 | * Reset array length without dealocating storage. |
| | 232 | * |
| | 233 | * \param a array, must be non-NULL |
| | 234 | */ |
| | 235 | static void |
| | 236 | arr_reset (ARRAY *a) |
| | 237 | { |
| | 238 | if (a->error) { |
| | 239 | return; |
| | 240 | } |
| | 241 | a->len = 0; |
| | 242 | } |
| | 243 | |
| | 244 | |
| | 245 | /** |
| | 246 | * Enlarge array. |
| | 247 | * |
| | 248 | * \param a array, must be non-NULL |
| | 249 | * |
| | 250 | * \return new element, or NULL if error |
| | 251 | */ |
| | 252 | static void * |
| | 253 | arr_enlarge (ARRAY *a) |
| | 254 | { |
| | 255 | void *p; |
| | 256 | if (a->error) { |
| | 257 | return NULL; |
| | 258 | } |
| | 259 | if (a->len == a->max) { |
| | 260 | int max = a->max + a->growth; |
| | 261 | p = realloc(a->data, max * a->eltsize); |
| | 262 | if (p == NULL) { |
| | 263 | a->error = 1; |
| | 264 | return NULL; |
| | 265 | } |
| | 266 | a->max = max; |
| | 267 | a->data = p; |
| | 268 | } |
| | 269 | p = (void *)((char *)a->data + a->eltsize * a->len++); |
| | 270 | return p; |
| | 271 | } |
| | 272 | |
| | 273 | |
| | 274 | /** |
| | 275 | * Free array. |
| | 276 | * |
| | 277 | * \param a array, must be non-NULL |
| | 278 | * \param func function to be called on each element |
| | 279 | */ |
| | 280 | static void |
| | 281 | arr_free (ARRAY *a, void (*func) (void *)) |
| | 282 | { |
| | 283 | if (func != NULL) { |
| | 284 | int i; |
| | 285 | for (i = 0; i < a->len; i++) { |
| | 286 | func((void *)((char *)a->data + a->eltsize * i)); |
| | 287 | } |
| | 288 | } |
| | 289 | free(a->data); |
| | 290 | arr_init(a, a->eltsize, a->growth); |
| | 291 | } |
| | 292 | |
| | 293 | |
| | 294 | /* buffered I/O **************************************************************/ |
| | 295 | |
| | 296 | |
| | 297 | #define FILE_DIRTY(fs) \ |
| | 298 | do { \ |
| | 299 | (fs)->pos = 0; \ |
| | 300 | (fs)->len = 0; \ |
| | 301 | } while (0) |
| | 302 | |
| | 303 | |
| | 304 | /** |
| | 305 | * Try to open a temporary file. |
| | 306 | * |
| | 307 | * \param[out] name address of a pointer to store the temporary name |
| | 308 | * |
| | 309 | * \return file descriptor on success, negative on error |
| | 310 | * |
| | 311 | * \note the name is not altered if this function fails |
| | 312 | * \note tries mc_tmpdir() and then current directory |
| | 313 | */ |
| | 314 | static int |
| | 315 | open_temp (void **name) |
| | 316 | { |
| | 317 | int fd; |
| | 318 | int len; |
| | 319 | char *temp; |
| | 320 | const char *pattern = "mcdiffXXXXXX"; |
| | 321 | const char *env = mc_tmpdir(); |
| | 322 | |
| | 323 | if (env == NULL) { |
| | 324 | env = ""; |
| | 325 | } |
| | 326 | |
| | 327 | len = strlen(env); |
| | 328 | temp = malloc(len + 1 + strlen(pattern) + 1); |
| | 329 | if (temp == NULL) { |
| | 330 | return -1; |
| | 331 | } |
| | 332 | |
| | 333 | if (len) { |
| | 334 | strcpy(temp, env); |
| | 335 | if (temp[len - 1] != PATH_SEP) { |
| | 336 | temp[len++] = PATH_SEP; |
| | 337 | } |
| | 338 | } |
| | 339 | strcpy(temp + len, pattern); |
| | 340 | |
| | 341 | fd = mkstemp(temp); |
| | 342 | if (fd < 0) { |
| | 343 | if (len) { |
| | 344 | strcpy(temp, pattern); |
| | 345 | fd = mkstemp(temp); |
| | 346 | } |
| | 347 | if (fd < 0) { |
| | 348 | free(temp); |
| | 349 | return -1; |
| | 350 | } |
| | 351 | } |
| | 352 | |
| | 353 | *name = temp; |
| | 354 | return fd; |
| | 355 | } |
| | 356 | |
| | 357 | |
| | 358 | /** |
| | 359 | * Alocate file structure and associate file descriptor to it. |
| | 360 | * |
| | 361 | * \param fd file descriptor |
| | 362 | * |
| | 363 | * \return file structure |
| | 364 | */ |
| | 365 | static FBUF * |
| | 366 | f_dopen (int fd) |
| | 367 | { |
| | 368 | FBUF *fs; |
| | 369 | |
| | 370 | if (fd < 0) { |
| | 371 | return NULL; |
| | 372 | } |
| | 373 | |
| | 374 | fs = malloc(sizeof(FBUF)); |
| | 375 | if (fs == NULL) { |
| | 376 | return NULL; |
| | 377 | } |
| | 378 | |
| | 379 | fs->buf = malloc(FILE_READ_BUF); |
| | 380 | if (fs->buf == NULL) { |
| | 381 | free(fs); |
| | 382 | return NULL; |
| | 383 | } |
| | 384 | |
| | 385 | fs->fd = fd; |
| | 386 | FILE_DIRTY(fs); |
| | 387 | fs->flags = 0; |
| | 388 | fs->data = NULL; |
| | 389 | |
| | 390 | return fs; |
| | 391 | } |
| | 392 | |
| | 393 | |
| | 394 | /** |
| | 395 | * Free file structure without closing the file. |
| | 396 | * |
| | 397 | * \param fs file structure |
| | 398 | * |
| | 399 | * \return 0 on success, non-zero on error |
| | 400 | */ |
| | 401 | static int |
| | 402 | f_free (FBUF *fs) |
| | 403 | { |
| | 404 | int rv = 0; |
| | 405 | if (fs->flags & FILE_FLAG_TEMP) { |
| | 406 | rv = unlink(fs->data); |
| | 407 | free(fs->data); |
| | 408 | } |
| | 409 | free(fs->buf); |
| | 410 | free(fs); |
| | 411 | return rv; |
| | 412 | } |
| | 413 | |
| | 414 | |
| | 415 | /** |
| | 416 | * Open a binary temporary file in R/W mode. |
| | 417 | * |
| | 418 | * \return file structure |
| | 419 | * |
| | 420 | * \note the file will be deleted when closed |
| | 421 | */ |
| | 422 | static FBUF * |
| | 423 | f_temp (void) |
| | 424 | { |
| | 425 | int fd; |
| | 426 | FBUF *fs; |
| | 427 | |
| | 428 | fs = f_dopen(0); |
| | 429 | if (fs == NULL) { |
| | 430 | return NULL; |
| | 431 | } |
| | 432 | |
| | 433 | fd = open_temp(&fs->data); |
| | 434 | if (fd < 0) { |
| | 435 | f_free(fs); |
| | 436 | return NULL; |
| | 437 | } |
| | 438 | |
| | 439 | fs->fd = fd; |
| | 440 | fs->flags = FILE_FLAG_TEMP; |
| | 441 | return fs; |
| | 442 | } |
| | 443 | |
| | 444 | |
| | 445 | /** |
| | 446 | * Open a binary file in specified mode. |
| | 447 | * |
| | 448 | * \param filename file name |
| | 449 | * \param flags open mode, a combination of O_RDONLY, O_WRONLY, O_RDWR |
| | 450 | * |
| | 451 | * \return file structure |
| | 452 | */ |
| | 453 | static FBUF * |
| | 454 | f_open (const char *filename, int flags) |
| | 455 | { |
| | 456 | int fd; |
| | 457 | FBUF *fs; |
| | 458 | |
| | 459 | fs = f_dopen(0); |
| | 460 | if (fs == NULL) { |
| | 461 | return NULL; |
| | 462 | } |
| | 463 | |
| | 464 | fd = open(filename, flags); |
| | 465 | if (fd < 0) { |
| | 466 | f_free(fs); |
| | 467 | return NULL; |
| | 468 | } |
| | 469 | |
| | 470 | fs->fd = fd; |
| | 471 | return fs; |
| | 472 | } |
| | 473 | |
| | 474 | |
| | 475 | /** |
| | 476 | * Read a line of bytes from file until newline or EOF. |
| | 477 | * |
| | 478 | * \param buf destination buffer |
| | 479 | * \param size size of buffer |
| | 480 | * \param fs file structure |
| | 481 | * |
| | 482 | * \return number of bytes read |
| | 483 | * |
| | 484 | * \note does not stop on null-byte |
| | 485 | * \note buf will not be null-terminated |
| | 486 | */ |
| | 487 | static size_t |
| | 488 | f_gets (char *buf, size_t size, FBUF *fs) |
| | 489 | { |
| | 490 | size_t j = 0; |
| | 491 | |
| | 492 | do { |
| | 493 | int i; |
| | 494 | int stop = 0; |
| | 495 | |
| | 496 | for (i = fs->pos; j < size && i < fs->len && !stop; i++, j++) { |
| | 497 | buf[j] = fs->buf[i]; |
| | 498 | if (buf[j] == '\n') { |
| | 499 | stop = 1; |
| | 500 | } |
| | 501 | } |
| | 502 | fs->pos = i; |
| | 503 | |
| | 504 | if (j == size || stop) { |
| | 505 | break; |
| | 506 | } |
| | 507 | |
| | 508 | fs->pos = 0; |
| | 509 | fs->len = read(fs->fd, fs->buf, FILE_READ_BUF); |
| | 510 | } while (fs->len > 0); |
| | 511 | |
| | 512 | return j; |
| | 513 | } |
| | 514 | |
| | 515 | |
| | 516 | /** |
| | 517 | * Read one character from file. |
| | 518 | * |
| | 519 | * \param fs file structure |
| | 520 | * |
| | 521 | * \return character |
| | 522 | */ |
| | 523 | static int |
| | 524 | f_getc (FBUF *fs) |
| | 525 | { |
| | 526 | do { |
| | 527 | if (fs->pos < fs->len) { |
| | 528 | return (unsigned char)fs->buf[fs->pos++]; |
| | 529 | } |
| | 530 | |
| | 531 | fs->pos = 0; |
| | 532 | fs->len = read(fs->fd, fs->buf, FILE_READ_BUF); |
| | 533 | } while (fs->len > 0); |
| | 534 | |
| | 535 | return -1; |
| | 536 | } |
| | 537 | |
| | 538 | |
| | 539 | /** |
| | 540 | * Seek into file. |
| | 541 | * |
| | 542 | * \param fs file structure |
| | 543 | * \param off offset |
| | 544 | * \param whence seek directive: SEEK_SET, SEEK_CUR or SEEK_END |
| | 545 | * |
| | 546 | * \return position in file, starting from begginning |
| | 547 | * |
| | 548 | * \note avoids thrashing read cache when possible |
| | 549 | */ |
| | 550 | static off_t |
| | 551 | f_seek (FBUF *fs, off_t off, int whence) |
| | 552 | { |
| | 553 | off_t rv; |
| | 554 | |
| | 555 | if (fs->len && whence != SEEK_END) { |
| | 556 | rv = lseek(fs->fd, 0, SEEK_CUR); |
| | 557 | if (rv != -1) { |
| | 558 | if (whence == SEEK_CUR) { |
| | 559 | whence = SEEK_SET; |
| | 560 | off += rv - fs->len + fs->pos; |
| | 561 | } |
| | 562 | if (off - rv >= -fs->len && off - rv <= 0) { |
| | 563 | fs->pos = fs->len + off - rv; |
| | 564 | return off; |
| | 565 | } |
| | 566 | } |
| | 567 | } |
| | 568 | |
| | 569 | rv = lseek(fs->fd, off, whence); |
| | 570 | if (rv != -1) { |
| | 571 | FILE_DIRTY(fs); |
| | 572 | } |
| | 573 | return rv; |
| | 574 | } |
| | 575 | |
| | 576 | |
| | 577 | /** |
| | 578 | * Seek to the beginning of file, thrashing read cache. |
| | 579 | * |
| | 580 | * \param fs file structure |
| | 581 | * |
| | 582 | * \return 0 if success, non-zero on error |
| | 583 | */ |
| | 584 | static off_t |
| | 585 | f_reset (FBUF *fs) |
| | 586 | { |
| | 587 | off_t rv = lseek(fs->fd, 0, SEEK_SET); |
| | 588 | if (rv != -1) { |
| | 589 | FILE_DIRTY(fs); |
| | 590 | } |
| | 591 | return rv; |
| | 592 | } |
| | 593 | |
| | 594 | |
| | 595 | /** |
| | 596 | * Write bytes to file. |
| | 597 | * |
| | 598 | * \param fs file structure |
| | 599 | * \param buf source buffer |
| | 600 | * \param size size of buffer |
| | 601 | * |
| | 602 | * \return number of written bytes, -1 on error |
| | 603 | * |
| | 604 | * \note thrashes read cache |
| | 605 | */ |
| | 606 | static ssize_t |
| | 607 | f_write (FBUF *fs, const char *buf, size_t size) |
| | 608 | { |
| | 609 | ssize_t rv = write(fs->fd, buf, size); |
| | 610 | if (rv >= 0) { |
| | 611 | FILE_DIRTY(fs); |
| | 612 | } |
| | 613 | return rv; |
| | 614 | } |
| | 615 | |
| | 616 | |
| | 617 | /** |
| | 618 | * Truncate file to the current position. |
| | 619 | * |
| | 620 | * \param fs file structure |
| | 621 | * |
| | 622 | * \return current file size on success, negative on error |
| | 623 | * |
| | 624 | * \note thrashes read cache |
| | 625 | */ |
| | 626 | static off_t |
| | 627 | f_trunc (FBUF *fs) |
| | 628 | { |
| | 629 | off_t off = lseek(fs->fd, 0, SEEK_CUR); |
| | 630 | if (off != -1) { |
| | 631 | int rv = ftruncate(fs->fd, off); |
| | 632 | if (rv != 0) { |
| | 633 | off = -1; |
| | 634 | } else { |
| | 635 | FILE_DIRTY(fs); |
| | 636 | } |
| | 637 | } |
| | 638 | return off; |
| | 639 | } |
| | 640 | |
| | 641 | |
| | 642 | /** |
| | 643 | * Close file. |
| | 644 | * |
| | 645 | * \param fs file structure |
| | 646 | * |
| | 647 | * \return 0 on success, non-zero on error |
| | 648 | * |
| | 649 | * \note if this is temporary file, it is deleted |
| | 650 | */ |
| | 651 | static int |
| | 652 | f_close (FBUF *fs) |
| | 653 | { |
| | 654 | int rv = close(fs->fd); |
| | 655 | f_free(fs); |
| | 656 | return rv; |
| | 657 | } |
| | 658 | |
| | 659 | |
| | 660 | /** |
| | 661 | * Create pipe stream to process. |
| | 662 | * |
| | 663 | * \param cmd shell command line |
| | 664 | * \param flags open mode, either O_RDONLY or O_WRONLY |
| | 665 | * |
| | 666 | * \return file structure |
| | 667 | */ |
| | 668 | static FBUF * |
| | 669 | p_open (const char *cmd, int flags) |
| | 670 | { |
| | 671 | FILE *f; |
| | 672 | FBUF *fs; |
| | 673 | const char *type = NULL; |
| | 674 | |
| | 675 | if (flags == O_RDONLY) { |
| | 676 | type = "r"; |
| | 677 | } |
| | 678 | if (flags == O_WRONLY) { |
| | 679 | type = "w"; |
| | 680 | } |
| | 681 | |
| | 682 | if (type == NULL) { |
| | 683 | return NULL; |
| | 684 | } |
| | 685 | |
| | 686 | fs = f_dopen(0); |
| | 687 | if (fs == NULL) { |
| | 688 | return NULL; |
| | 689 | } |
| | 690 | |
| | 691 | f = popen(cmd, type); |
| | 692 | if (f == NULL) { |
| | 693 | f_free(fs); |
| | 694 | return NULL; |
| | 695 | } |
| | 696 | |
| | 697 | fs->fd = fileno(f); |
| | 698 | fs->data = f; |
| | 699 | return fs; |
| | 700 | } |
| | 701 | |
| | 702 | |
| | 703 | /** |
| | 704 | * Close pipe stream. |
| | 705 | * |
| | 706 | * \param fs structure |
| | 707 | * |
| | 708 | * \return 0 on success, non-zero on error |
| | 709 | */ |
| | 710 | static int |
| | 711 | p_close (FBUF *fs) |
| | 712 | { |
| | 713 | int rv = pclose(fs->data); |
| | 714 | f_free(fs); |
| | 715 | return rv; |
| | 716 | } |
| | 717 | |
| | 718 | |
| | 719 | /* diff parse ****************************************************************/ |
| | 720 | |
| | 721 | |
| | 722 | /** |
| | 723 | * Read decimal number from string. |
| | 724 | * |
| | 725 | * \param[in,out] str string to parse |
| | 726 | * \param[out] n extracted number |
| | 727 | * |
| | 728 | * \return 0 if success, otherwise non-zero |
| | 729 | */ |
| | 730 | static int |
| | 731 | scan_deci (const char **str, int *n) |
| | 732 | { |
| | 733 | const char *p = *str; |
| | 734 | char *q; |
| | 735 | errno = 0; |
| | 736 | *n = strtol(p, &q, 10); |
| | 737 | if (errno || p == q) { |
| | 738 | return -1; |
| | 739 | } |
| | 740 | *str = q; |
| | 741 | return 0; |
| | 742 | } |
| | 743 | |
| | 744 | |
| | 745 | /** |
| | 746 | * Parse line for diff statement. |
| | 747 | * |
| | 748 | * \param p string to parse |
| | 749 | * \param ops list of diff statements |
| | 750 | * |
| | 751 | * \return 0 if success, otherwise non-zero |
| | 752 | */ |
| | 753 | static int |
| | 754 | scan_line (const char *p, ARRAY *ops) |
| | 755 | { |
| | 756 | DIFFCMD *op; |
| | 757 | |
| | 758 | int f1, f2; |
| | 759 | int t1, t2; |
| | 760 | int cmd; |
| | 761 | |
| | 762 | int range; |
| | 763 | |
| | 764 | /* handle the following cases: |
| | 765 | * NUMaNUM[,NUM] |
| | 766 | * NUM[,NUM]cNUM[,NUM] |
| | 767 | * NUM[,NUM]dNUM |
| | 768 | * where NUM is a positive integer |
| | 769 | */ |
| | 770 | |
| | 771 | if (scan_deci(&p, &f1) != 0 || f1 < 0) { |
| | 772 | return -1; |
| | 773 | } |
| | 774 | f2 = f1; |
| | 775 | range = 0; |
| | 776 | if (*p == ',') { |
| | 777 | p++; |
| | 778 | if (scan_deci(&p, &f2) != 0 || f2 < f1) { |
| | 779 | return -1; |
| | 780 | } |
| | 781 | range = 1; |
| | 782 | } |
| | 783 | |
| | 784 | cmd = *p++; |
| | 785 | if (cmd == 'a') { |
| | 786 | if (range) { |
| | 787 | return -1; |
| | 788 | } |
| | 789 | } else if (cmd != 'c' && cmd != 'd') { |
| | 790 | return -1; |
| | 791 | } |
| | 792 | |
| | 793 | if (scan_deci(&p, &t1) != 0 || t1 < 0) { |
| | 794 | return -1; |
| | 795 | } |
| | 796 | t2 = t1; |
| | 797 | range = 0; |
| | 798 | if (*p == ',') { |
| | 799 | p++; |
| | 800 | if (scan_deci(&p, &t2) != 0 || t2 < t1) { |
| | 801 | return -1; |
| | 802 | } |
| | 803 | range = 1; |
| | 804 | } |
| | 805 | |
| | 806 | if (cmd == 'd') { |
| | 807 | if (range) { |
| | 808 | return -1; |
| | 809 | } |
| | 810 | } |
| | 811 | |
| | 812 | op = arr_enlarge(ops); |
| | 813 | if (op == NULL) { |
| | 814 | return -1; |
| | 815 | } |
| | 816 | op->a[0][0] = f1; |
| | 817 | op->a[0][1] = f2; |
| | 818 | op->cmd = cmd; |
| | 819 | op->a[1][0] = t1; |
| | 820 | op->a[1][1] = t2; |
| | 821 | return 0; |
| | 822 | } |
| | 823 | |
| | 824 | |
| | 825 | /** |
| | 826 | * Parse diff output and extract diff statements. |
| | 827 | * |
| | 828 | * \param f stream to read from |
| | 829 | * \param ops list of diff statements to fill |
| | 830 | * |
| | 831 | * \return positive number indicating number of hunks, otherwise negative |
| | 832 | */ |
| | 833 | static int |
| | 834 | scan_diff (FBUF *f, ARRAY *ops) |
| | 835 | { |
| | 836 | int sz; |
| | 837 | char buf[BUFSIZ]; |
| | 838 | |
| | 839 | while ((sz = f_gets(buf, sizeof(buf) - 1, f))) { |
| | 840 | if (isdigit(buf[0])) { |
| | 841 | if (buf[sz - 1] != '\n') { |
| | 842 | return -1; |
| | 843 | } |
| | 844 | buf[sz] = '\0'; |
| | 845 | if (scan_line(buf, ops) != 0) { |
| | 846 | return -1; |
| | 847 | } |
| | 848 | continue; |
| | 849 | } |
| | 850 | while (buf[sz - 1] != '\n' && (sz = f_gets(buf, sizeof(buf), f))) { |
| | 851 | } |
| | 852 | } |
| | 853 | |
| | 854 | return ops->len; |
| | 855 | } |
| | 856 | |
| | 857 | |
| | 858 | /** |
| | 859 | * Invoke diff and extract diff statements. |
| | 860 | * |
| | 861 | * \param args extra arguments to be passed to diff |
| | 862 | * \param extra more arguments to be passed to diff |
| | 863 | * \param file1 first file to compare |
| | 864 | * \param file2 second file to compare |
| | 865 | * \param ops list of diff statements to fill |
| | 866 | * |
| | 867 | * \return positive number indicating number of hunks, otherwise negative |
| | 868 | */ |
| | 869 | static int |
| | 870 | dff_execute (const char *args, const char *extra, const char *file1, const char *file2, ARRAY *ops) |
| | 871 | { |
| | 872 | static const char *opt = |
| | 873 | " --old-group-format='%df%(f=l?:,%dl)d%dE\n'" |
| | 874 | " --new-group-format='%dea%dF%(F=L?:,%dL)\n'" |
| | 875 | " --changed-group-format='%df%(f=l?:,%dl)c%dF%(F=L?:,%dL)\n'" |
| | 876 | " --unchanged-group-format=''"; |
| | 877 | |
| | 878 | int rv; |
| | 879 | FBUF *f; |
| | 880 | char *cmd; |
| | 881 | int code; |
| | 882 | |
| | 883 | cmd = malloc(14 + strlen(args) + strlen(extra) + strlen(opt) + strlen(file1) + strlen(file2)); |
| | 884 | if (cmd == NULL) { |
| | 885 | return -1; |
| | 886 | } |
| | 887 | sprintf(cmd, "diff %s %s %s \"%s\" \"%s\"", args, extra, opt, file1, file2); |
| | 888 | |
| | 889 | f = p_open(cmd, O_RDONLY); |
| | 890 | free(cmd); |
| | 891 | if (f == NULL) { |
| | 892 | return -1; |
| | 893 | } |
| | 894 | |
| | 895 | arr_init(ops, sizeof(DIFFCMD), 64); |
| | 896 | rv = scan_diff(f, ops); |
| | 897 | code = p_close(f); |
| | 898 | |
| | 899 | if (rv < 0 || code == -1 || !WIFEXITED(code) || WEXITSTATUS(code) == 2) { |
| | 900 | arr_free(ops, NULL); |
| | 901 | return -1; |
| | 902 | } |
| | 903 | |
| | 904 | return rv; |
| | 905 | } |
| | 906 | |
| | 907 | |
| | 908 | /** |
| | 909 | * Reparse and display file according to diff statements. |
| | 910 | * |
| | 911 | * \param ord 0 if displaying first file, 1 if displaying 2nd file |
| | 912 | * \param filename file name to display |
| | 913 | * \param ops list of diff statements |
| | 914 | * \param printer printf-like function to be used for displaying |
| | 915 | * \param ctx printer context |
| | 916 | * |
| | 917 | * \return 0 if success, otherwise non-zero |
| | 918 | */ |
| | 919 | static int |
| | 920 | dff_reparse (int ord, const char *filename, const ARRAY *ops, DFUNC printer, void *ctx) |
| | 921 | { |
| | 922 | int i; |
| | 923 | FBUF *f; |
| | 924 | size_t sz; |
| | 925 | char buf[BUFSIZ]; |
| | 926 | int line = 0; |
| | 927 | off_t off = 0; |
| | 928 | const DIFFCMD *op; |
| | 929 | int eff, tee; |
| | 930 | int add_cmd; |
| | 931 | int del_cmd; |
| | 932 | |
| | 933 | f = f_open(filename, O_RDONLY); |
| | 934 | if (f == NULL) { |
| | 935 | return -1; |
| | 936 | } |
| | 937 | |
| | 938 | ord &= 1; |
| | 939 | eff = ord; |
| | 940 | tee = ord ^ 1; |
| | 941 | |
| | 942 | add_cmd = 'a'; |
| | 943 | del_cmd = 'd'; |
| | 944 | if (ord) { |
| | 945 | add_cmd = 'd'; |
| | 946 | del_cmd = 'a'; |
| | 947 | } |
| | 948 | |
| | 949 | #define F1 a[eff][0] |
| | 950 | #define F2 a[eff][1] |
| | 951 | #define T1 a[tee][0] |
| | 952 | #define T2 a[tee][1] |
| | 953 | for (op = ops->data, i = 0; i < ops->len; i++, op++) { |
| | 954 | int n = op->F1 - (op->cmd != add_cmd); |
| | 955 | while (line < n && (sz = f_gets(buf, sizeof(buf), f))) { |
| | 956 | line++; |
| | 957 | printer(ctx, EQU_CH, line, off, sz, buf); |
| | 958 | off += sz; |
| | 959 | while (buf[sz - 1] != '\n') { |
| | 960 | if (!(sz = f_gets(buf, sizeof(buf), f))) { |
| | 961 | printer(ctx, 0, 0, 0, 1, "\n"); |
| | 962 | break; |
| | 963 | } |
| | 964 | printer(ctx, 0, 0, 0, sz, buf); |
| | 965 | off += sz; |
| | 966 | } |
| | 967 | } |
| | 968 | if (line != n) { |
| | 969 | goto err; |
| | 970 | } |
| | 971 | |
| | 972 | if (op->cmd == add_cmd) { |
| | 973 | n = op->T2 - op->T1 + 1; |
| | 974 | while (n) { |
| | 975 | printer(ctx, DEL_CH, 0, 0, 1, "\n"); |
| | 976 | n--; |
| | 977 | } |
| | 978 | } |
| | 979 | if (op->cmd == del_cmd) { |
| | 980 | n = op->F2 - op->F1 + 1; |
| | 981 | while (n && (sz = f_gets(buf, sizeof(buf), f))) { |
| | 982 | line++; |
| | 983 | printer(ctx, ADD_CH, line, off, sz, buf); |
| | 984 | off += sz; |
| | 985 | while (buf[sz - 1] != '\n') { |
| | 986 | if (!(sz = f_gets(buf, sizeof(buf), f))) { |
| | 987 | printer(ctx, 0, 0, 0, 1, "\n"); |
| | 988 | break; |
| | 989 | } |
| | 990 | printer(ctx, 0, 0, 0, sz, buf); |
| | 991 | off += sz; |
| | 992 | } |
| | 993 | n--; |
| | 994 | } |
| | 995 | if (n) { |
| | 996 | goto err; |
| | 997 | } |
| | 998 | } |
| | 999 | if (op->cmd == 'c') { |
| | 1000 | n = op->F2 - op->F1 + 1; |
| | 1001 | while (n && (sz = f_gets(buf, sizeof(buf), f))) { |
| | 1002 | line++; |
| | 1003 | printer(ctx, CHG_CH, line, off, sz, buf); |
| | 1004 | off += sz; |
| | 1005 | while (buf[sz - 1] != '\n') { |
| | 1006 | if (!(sz = f_gets(buf, sizeof(buf), f))) { |
| | 1007 | printer(ctx, 0, 0, 0, 1, "\n"); |
| | 1008 | break; |
| | 1009 | } |
| | 1010 | printer(ctx, 0, 0, 0, sz, buf); |
| | 1011 | off += sz; |
| | 1012 | } |
| | 1013 | n--; |
| | 1014 | } |
| | 1015 | if (n) { |
| | 1016 | goto err; |
| | 1017 | } |
| | 1018 | n = op->T2 - op->T1 - (op->F2 - op->F1); |
| | 1019 | while (n > 0) { |
| | 1020 | printer(ctx, CHG_CH, 0, 0, 1, "\n"); |
| | 1021 | n--; |
| | 1022 | } |
| | 1023 | } |
| | 1024 | } |
| | 1025 | #undef T2 |
| | 1026 | #undef T1 |
| | 1027 | #undef F2 |
| | 1028 | #undef F1 |
| | 1029 | |
| | 1030 | while ((sz = f_gets(buf, sizeof(buf), f))) { |
| | 1031 | line++; |
| | 1032 | printer(ctx, EQU_CH, line, off, sz, buf); |
| | 1033 | off += sz; |
| | 1034 | while (buf[sz - 1] != '\n') { |
| | 1035 | if (!(sz = f_gets(buf, sizeof(buf), f))) { |
| | 1036 | printer(ctx, 0, 0, 0, 1, "\n"); |
| | 1037 | break; |
| | 1038 | } |
| | 1039 | printer(ctx, 0, 0, 0, sz, buf); |
| | 1040 | off += sz; |
| | 1041 | } |
| | 1042 | } |
| | 1043 | |
| | 1044 | f_close(f); |
| | 1045 | return 0; |
| | 1046 | |
| | 1047 | err: |
| | 1048 | f_close(f); |
| | 1049 | return -1; |
| | 1050 | } |
| | 1051 | |
| | 1052 | |
| | 1053 | /* horizontal diff ***********************************************************/ |
| | 1054 | |
| | 1055 | |
| | 1056 | /** |
| | 1057 | * Longest common substring. |
| | 1058 | * |
| | 1059 | * \param s first string |
| | 1060 | * \param m length of first string |
| | 1061 | * \param t second string |
| | 1062 | * \param n length of second string |
| | 1063 | * \param ret list of offsets for longest common substrings inside each string |
| | 1064 | * \param min minimum length of common substrings |
| | 1065 | * |
| | 1066 | * \return 0 if success, nonzero otherwise |
| | 1067 | */ |
| | 1068 | static int |
| | 1069 | lcsubstr (const char *s, int m, const char *t, int n, ARRAY *ret, int min) |
| | 1070 | { |
| | 1071 | int i, j; |
| | 1072 | |
| | 1073 | int *Lprev, *Lcurr; |
| | 1074 | |
| | 1075 | int z = 0; |
| | 1076 | |
| | 1077 | arr_init(ret, sizeof(PAIR), 4); |
| | 1078 | |
| | 1079 | if (m < min || n < min) { |
| | 1080 | /* XXX early culling */ |
| | 1081 | return 0; |
| | 1082 | } |
| | 1083 | |
| | 1084 | Lprev = calloc(n + 1, sizeof(int)); |
| | 1085 | if (Lprev == NULL) { |
| | 1086 | goto err_0; |
| | 1087 | } |
| | 1088 | Lcurr = calloc(n + 1, sizeof(int)); |
| | 1089 | if (Lcurr == NULL) { |
| | 1090 | goto err_1; |
| | 1091 | } |
| | 1092 | |
| | 1093 | for (i = 0; i < m; i++) { |
| | 1094 | int *L = Lprev; |
| | 1095 | Lprev = Lcurr; |
| | 1096 | Lcurr = L; |
| | 1097 | #ifdef USE_MEMSET_IN_LCS |
| | 1098 | memset(Lcurr, 0, (n + 1) * sizeof(int)); |
| | 1099 | #endif |
| | 1100 | for (j = 0; j < n; j++) { |
| | 1101 | #ifndef USE_MEMSET_IN_LCS |
| | 1102 | Lcurr[j + 1] = 0; |
| | 1103 | #endif |
| | 1104 | if (s[i] == t[j]) { |
| | 1105 | int v = Lprev[j] + 1; |
| | 1106 | Lcurr[j + 1] = v; |
| | 1107 | if (z < v) { |
| | 1108 | z = v; |
| | 1109 | arr_reset(ret); |
| | 1110 | } |
| | 1111 | if (z == v && z >= min) { |
| | 1112 | int off0 = i - z + 1; |
| | 1113 | int off1 = j - z + 1; |
| | 1114 | int k; |
| | 1115 | PAIR *p; |
| | 1116 | for (p = ret->data, k = 0; k < ret->len; k++, p++) { |
| | 1117 | if ((*p)[0] == off0) { |
| | 1118 | break; |
| | 1119 | } |
| | 1120 | if ((*p)[1] == off1) { |
| | 1121 | break; |
| | 1122 | } |
| | 1123 | } |
| | 1124 | if (k == ret->len) { |
| | 1125 | p = arr_enlarge(ret); |
| | 1126 | if (p == NULL) { |
| | 1127 | goto err_2; |
| | 1128 | } |
| | 1129 | (*p)[0] = off0; |
| | 1130 | (*p)[1] = off1; |
| | 1131 | } |
| | 1132 | } |
| | 1133 | } |
| | 1134 | } |
| | 1135 | } |
| | 1136 | |
| | 1137 | free(Lcurr); |
| | 1138 | free(Lprev); |
| | 1139 | return z; |
| | 1140 | |
| | 1141 | err_2: |
| | 1142 | free(Lcurr); |
| | 1143 | err_1: |
| | 1144 | free(Lprev); |
| | 1145 | err_0: |
| | 1146 | arr_free(ret, NULL); |
| | 1147 | return -1; |
| | 1148 | } |
| | 1149 | |
| | 1150 | |
| | 1151 | /** |
| | 1152 | * Scan recursively for common substrings and build ranges. |
| | 1153 | * |
| | 1154 | * \param s first string |
| | 1155 | * \param t second string |
| | 1156 | * \param bracket current limits for both of the strings |
| | 1157 | * \param min minimum length of common substrings |
| | 1158 | * \param hdiff list of horizontal diff ranges to fill |
| | 1159 | * \param depth recursion depth |
| | 1160 | * |
| | 1161 | * \return 0 if success, nonzero otherwise |
| | 1162 | */ |
| | 1163 | static int |
| | 1164 | hdiff_multi (const char *s, const char *t, const BRACKET bracket, int min, ARRAY *hdiff, unsigned int depth) |
| | 1165 | { |
| | 1166 | BRACKET *p; |
| | 1167 | |
| | 1168 | if (depth--) { |
| | 1169 | ARRAY ret; |
| | 1170 | BRACKET b; |
| | 1171 | int len = lcsubstr(s + bracket[0].off, bracket[0].len, |
| | 1172 | t + bracket[1].off, bracket[1].len, &ret, min); |
| | 1173 | if (ret.len) { |
| | 1174 | int k = 0; |
| | 1175 | const PAIR *data = ret.data; |
| | 1176 | |
| | 1177 | b[0].off = bracket[0].off; |
| | 1178 | b[0].len = data[k][0]; |
| | 1179 | b[1].off = bracket[1].off; |
| | 1180 | b[1].len = data[k][1]; |
| | 1181 | hdiff_multi(s, t, b, min, hdiff, depth); |
| | 1182 | |
| | 1183 | for (k = 0; k < ret.len - 1; k++) { |
| | 1184 | b[0].off = bracket[0].off + data[k][0] + len; |
| | 1185 | b[0].len = data[k + 1][0] - data[k][0] - len; |
| | 1186 | b[1].off = bracket[1].off + data[k][1] + len; |
| | 1187 | b[1].len = data[k + 1][1] - data[k][1] - len; |
| | 1188 | hdiff_multi(s, t, b, min, hdiff, depth); |
| | 1189 | } |
| | 1190 | |
| | 1191 | b[0].off = bracket[0].off + data[k][0] + len; |
| | 1192 | b[0].len = bracket[0].len - data[k][0] - len; |
| | 1193 | b[1].off = bracket[1].off + data[k][1] + len; |
| | 1194 | b[1].len = bracket[1].len - data[k][1] - len; |
| | 1195 | hdiff_multi(s, t, b, min, hdiff, depth); |
| | 1196 | |
| | 1197 | arr_free(&ret, NULL); |
| | 1198 | return 0; |
| | 1199 | } |
| | 1200 | } |
| | 1201 | |
| | 1202 | p = arr_enlarge(hdiff); |
| | 1203 | if (p == NULL) { |
| | 1204 | return -1; |
| | 1205 | } |
| | 1206 | (*p)[0].off = bracket[0].off; |
| | 1207 | (*p)[0].len = bracket[0].len; |
| | 1208 | (*p)[1].off = bracket[1].off; |
| | 1209 | (*p)[1].len = bracket[1].len; |
| | 1210 | |
| | 1211 | return 0; |
| | 1212 | } |
| | 1213 | |
| | 1214 | |
| | 1215 | /** |
| | 1216 | * Build list of horizontal diff ranges. |
| | 1217 | * |
| | 1218 | * \param s first string |
| | 1219 | * \param m length of first string |
| | 1220 | * \param t second string |
| | 1221 | * \param n length of second string |
| | 1222 | * \param min minimum length of common substrings |
| | 1223 | * \param hdiff list of horizontal diff ranges to fill |
| | 1224 | * \param depth recursion depth |
| | 1225 | * |
| | 1226 | * \return 0 if success, nonzero otherwise |
| | 1227 | */ |
| | 1228 | static int |
| | 1229 | hdiff_scan (const char *s, int m, const char *t, int n, int min, ARRAY *hdiff, unsigned int depth) |
| | 1230 | { |
| | 1231 | int i; |
| | 1232 | BRACKET b; |
| | 1233 | |
| | 1234 | /* dumbscan (single horizontal diff) -- does not compress whitespace */ |
| | 1235 | |
| | 1236 | for (i = 0; i < m && i < n && s[i] == t[i]; i++) { |
| | 1237 | } |
| | 1238 | for (; m > i && n > i && s[m - 1] == t[n - 1]; m--, n--) { |
| | 1239 | } |
| | 1240 | b[0].off = i; |
| | 1241 | b[0].len = m - i; |
| | 1242 | b[1].off = i; |
| | 1243 | b[1].len = n - i; |
| | 1244 | |
| | 1245 | /* smartscan (multiple horizontal diff) */ |
| | 1246 | |
| | 1247 | arr_init(hdiff, sizeof(BRACKET), 4); |
| | 1248 | hdiff_multi(s, t, b, min, hdiff, depth); |
| | 1249 | if (hdiff->error) { |
| | 1250 | arr_free(hdiff, NULL); |
| | 1251 | return -1; |
| | 1252 | } |
| | 1253 | |
| | 1254 | return 0; |
| | 1255 | } |
| | 1256 | |
| | 1257 | |
| | 1258 | /* read line *****************************************************************/ |
| | 1259 | |
| | 1260 | |
| | 1261 | /** |
| | 1262 | * Check if character is inside horizontal diff limits. |
| | 1263 | * |
| | 1264 | * \param k rank of character inside line |
| | 1265 | * \param hdiff horizontal diff structure |
| | 1266 | * \param ord 0 if reading from first file, 1 if reading from 2nd file |
| | 1267 | * |
| | 1268 | * \return TRUE if inside hdiff limits, FALSE otherwise |
| | 1269 | */ |
| | 1270 | static int |
| | 1271 | is_inside (int k, ARRAY *hdiff, int ord) |
| | 1272 | { |
| | 1273 | int i; |
| | 1274 | BRACKET *b; |
| | 1275 | for (b = hdiff->data, i = 0; i < hdiff->len; i++, b++) { |
| | 1276 | int start = (*b)[ord].off; |
| | 1277 | int end = start + (*b)[ord].len; |
| | 1278 | if (k >= start && k < end) { |
| | 1279 | return 1; |
| | 1280 | } |
| | 1281 | } |
| | 1282 | return 0; |
| | 1283 | } |
| | 1284 | |
| | 1285 | |
| | 1286 | /** |
| | 1287 | * Copy `src' to `dst' expanding tabs. |
| | 1288 | * |
| | 1289 | * \param dst destination buffer |
| | 1290 | * \param src source buffer |
| | 1291 | * \param srcsize size of src buffer |
| | 1292 | * \param base virtual base of this string, needed to calculate tabs |
| | 1293 | * \param ts tab size |
| | 1294 | * |
| | 1295 | * \return new virtual base |
| | 1296 | * |
| | 1297 | * \note The procedure returns when all bytes are consumed from `src' |
| | 1298 | */ |
| | 1299 | static int |
| | 1300 | cvt_cpy (char *dst, const char *src, size_t srcsize, int base, int ts) |
| | 1301 | { |
| | 1302 | int i; |
| | 1303 | for (i = 0; srcsize; i++, src++, dst++, srcsize--) { |
| | 1304 | *dst = *src; |
| | 1305 | if (*src == '\t') { |
| | 1306 | int j = TAB_SKIP(ts, i + base); |
| | 1307 | i += j - 1; |
| | 1308 | while (j-- > 0) { |
| | 1309 | *dst++ = ' '; |
| | 1310 | } |
| | 1311 | dst--; |
| | 1312 | } |
| | 1313 | } |
| | 1314 | return i + base; |
| | 1315 | } |
| | 1316 | |
| | 1317 | |
| | 1318 | /** |
| | 1319 | * Copy `src' to `dst' expanding tabs. |
| | 1320 | * |
| | 1321 | * \param dst destination buffer |
| | 1322 | * \param dstsize size of dst buffer |
| | 1323 | * \param[in,out] _src source buffer |
| | 1324 | * \param srcsize size of src buffer |
| | 1325 | * \param base virtual base of this string, needed to calculate tabs |
| | 1326 | * \param ts tab size |
| | 1327 | * |
| | 1328 | * \return new virtual base |
| | 1329 | * |
| | 1330 | * \note The procedure returns when all bytes are consumed from `src' |
| | 1331 | * or `dstsize' bytes are written to `dst' |
| | 1332 | * \note Upon return, `src' points to the first unwritten character in source |
| | 1333 | */ |
| | 1334 | static int |
| | 1335 | cvt_ncpy (char *dst, int dstsize, const char **_src, size_t srcsize, int base, int ts) |
| | 1336 | { |
| | 1337 | int i; |
| | 1338 | const char *src = *_src; |
| | 1339 | for (i = 0; i < dstsize && srcsize; i++, src++, dst++, srcsize--) { |
| | 1340 | *dst = *src; |
| | 1341 | if (*src == '\t') { |
| | 1342 | int j = TAB_SKIP(ts, i + base); |
| | 1343 | if (j > dstsize - i) { |
| | 1344 | j = dstsize - i; |
| | 1345 | } |
| | 1346 | i += j - 1; |
| | 1347 | while (j-- > 0) { |
| | 1348 | *dst++ = ' '; |
| | 1349 | } |
| | 1350 | dst--; |
| | 1351 | } |
| | 1352 | } |
| | 1353 | *_src = src; |
| | 1354 | return i + base; |
| | 1355 | } |
| | 1356 | |
| | 1357 | |
| | 1358 | /** |
| | 1359 | * Read line from memory, converting tabs to spaces and padding with spaces. |
| | 1360 | * |
| | 1361 | * \param src buffer to read from |
| | 1362 | * \param srcsize size of src buffer |
| | 1363 | * \param dst buffer to read to |
| | 1364 | * \param dstsize size of dst buffer, excluding trailing null |
| | 1365 | * \param skip number of characters to skip |
| | 1366 | * \param ts tab size |
| | 1367 | * \param show_cr show trailing carriage return as ^M |
| | 1368 | * |
| | 1369 | * \return negative on error, otherwise number of bytes except padding |
| | 1370 | */ |
| | 1371 | static int |
| | 1372 | cvt_mget (const char *src, size_t srcsize, char *dst, int dstsize, int skip, int ts, int show_cr) |
| | 1373 | { |
| | 1374 | int sz = 0; |
| | 1375 | if (src != NULL) { |
| | 1376 | int i; |
| | 1377 | char *tmp = dst; |
| | 1378 | const int base = 0; |
| | 1379 | for (i = 0; dstsize && srcsize && *src != '\n'; i++, src++, srcsize--) { |
| | 1380 | if (*src == '\t') { |
| | 1381 | int j = TAB_SKIP(ts, i + base); |
| | 1382 | i += j - 1; |
| | 1383 | while (j-- > 0) { |
| | 1384 | if (skip) { |
| | 1385 | skip--; |
| | 1386 | } else if (dstsize) { |
| | 1387 | dstsize--; |
| | 1388 | *dst++ = ' '; |
| | 1389 | } |
| | 1390 | } |
| | 1391 | } else if (src[0] == '\r' && (srcsize == 1 || src[1] == '\n')) { |
| | 1392 | if (!skip && show_cr) { |
| | 1393 | if (dstsize > 1) { |
| | 1394 | dstsize -= 2; |
| | 1395 | *dst++ = '^'; |
| | 1396 | *dst++ = 'M'; |
| | 1397 | } else { |
| | 1398 | dstsize--; |
| | 1399 | *dst++ = '.'; |
| | 1400 | } |
| | 1401 | } |
| | 1402 | break; |
| | 1403 | } else { |
| | 1404 | if (skip) { |
| | 1405 | skip--; |
| | 1406 | } else { |
| | 1407 | dstsize--; |
| | 1408 | *dst++ = is_printable(*src) ? *src : '.'; |
| | 1409 | } |
| | 1410 | } |
| | 1411 | } |
| | 1412 | sz = dst - tmp; |
| | 1413 | } |
| | 1414 | while (dstsize) { |
| | 1415 | dstsize--; |
| | 1416 | *dst++ = ' '; |
| | 1417 | } |
| | 1418 | *dst = '\0'; |
| | 1419 | return sz; |
| | 1420 | } |
| | 1421 | |
| | 1422 | |
| | 1423 | /** |
| | 1424 | * Read line from memory and build attribute array. |
| | 1425 | * |
| | 1426 | * \param src buffer to read from |
| | 1427 | * \param srcsize size of src buffer |
| | 1428 | * \param dst buffer to read to |
| | 1429 | * \param dstsize size of dst buffer, excluding trailing null |
| | 1430 | * \param skip number of characters to skip |
| | 1431 | * \param ts tab size |
| | 1432 | * \param show_cr show trailing carriage return as ^M |
| | 1433 | * \param hdiff horizontal diff structure |
| | 1434 | * \param ord 0 if reading from first file, 1 if reading from 2nd file |
| | 1435 | * \param att buffer of attributes |
| | 1436 | * |
| | 1437 | * \return negative on error, otherwise number of bytes except padding |
| | 1438 | */ |
| | 1439 | static int |
| | 1440 | cvt_mgeta (const char *src, size_t srcsize, char *dst, int dstsize, int skip, int ts, int show_cr, ARRAY *hdiff, int ord, char *att) |
| | 1441 | { |
| | 1442 | int sz = 0; |
| | 1443 | if (src != NULL) { |
| | 1444 | int i, k; |
| | 1445 | char *tmp = dst; |
| | 1446 | const int base = 0; |
| | 1447 | for (i = 0, k = 0; dstsize && srcsize && *src != '\n'; i++, k++, src++, srcsize--) { |
| | 1448 | if (*src == '\t') { |
| | 1449 | int j = TAB_SKIP(ts, i + base); |
| | 1450 | i += j - 1; |
| | 1451 | while (j-- > 0) { |
| | 1452 | if (skip) { |
| | 1453 | skip--; |
| | 1454 | } else if (dstsize) { |
| | 1455 | dstsize--; |
| | 1456 | *att++ = is_inside(k, hdiff, ord); |
| | 1457 | *dst++ = ' '; |
| | 1458 | } |
| | 1459 | } |
| | 1460 | } else if (src[0] == '\r' && (srcsize == 1 || src[1] == '\n')) { |
| | 1461 | if (!skip && show_cr) { |
| | 1462 | if (dstsize > 1) { |
| | 1463 | dstsize -= 2; |
| | 1464 | *att++ = is_inside(k, hdiff, ord); |
| | 1465 | *dst++ = '^'; |
| | 1466 | *att++ = is_inside(k, hdiff, ord); |
| | 1467 | *dst++ = 'M'; |
| | 1468 | } else { |
| | 1469 | dstsize--; |
| | 1470 | *att++ = is_inside(k, hdiff, ord); |
| | 1471 | *dst++ = '.'; |
| | 1472 | } |
| | 1473 | } |
| | 1474 | break; |
| | 1475 | } else { |
| | 1476 | if (skip) { |
| | 1477 | skip--; |
| | 1478 | } else { |
| | 1479 | dstsize--; |
| | 1480 | *att++ = is_inside(k, hdiff, ord); |
| | 1481 | *dst++ = is_printable(*src) ? *src : '.'; |
| | 1482 | } |
| | 1483 | } |
| | 1484 | } |
| | 1485 | sz = dst - tmp; |
| | 1486 | } |
| | 1487 | while (dstsize) { |
| | 1488 | dstsize--; |
| | 1489 | *att++ = 0; |
| | 1490 | *dst++ = ' '; |
| | 1491 | } |
| | 1492 | *dst = '\0'; |
| | 1493 | return sz; |
| | 1494 | } |
| | 1495 | |
| | 1496 | |
| | 1497 | /** |
| | 1498 | * Read line from file, converting tabs to spaces and padding with spaces. |
| | 1499 | * |
| | 1500 | * \param f file stream to read from |
| | 1501 | * \param off offset of line inside file |
| | 1502 | * \param dst buffer to read to |
| | 1503 | * \param dstsize size of dst buffer, excluding trailing null |
| | 1504 | * \param skip number of characters to skip |
| | 1505 | * \param ts tab size |
| | 1506 | * \param show_cr show trailing carriage return as ^M |
| | 1507 | * |
| | 1508 | * \return negative on error, otherwise number of bytes except padding |
| | 1509 | */ |
| | 1510 | static int |
| | 1511 | cvt_fget (FBUF *f, off_t off, char *dst, int dstsize, int skip, int ts, int show_cr) |
| | 1512 | { |
| | 1513 | int base = 0; |
| | 1514 | int old_base = base; |
| | 1515 | const int amount = dstsize; |
| | 1516 | |
| | 1517 | int useful; |
| | 1518 | int offset; |
| | 1519 | |
| | 1520 | ssize_t i; |
| | 1521 | size_t sz; |
| | 1522 | |
| | 1523 | int lastch = '\0'; |
| | 1524 | |
| | 1525 | const char *q = NULL; |
| | 1526 | char tmp[BUFSIZ]; /* XXX capacity must be >= max{dstsize + 1, amount} */ |
| | 1527 | char cvt[BUFSIZ]; /* XXX capacity must be >= MAX_TAB_WIDTH * amount */ |
| | 1528 | |
| | 1529 | if ((int)sizeof(tmp) < amount || (int)sizeof(tmp) <= dstsize || (int)sizeof(cvt) < 8 * amount) { |
| | 1530 | /* abnormal, but avoid buffer overflow */ |
| | 1531 | memset(dst, ' ', dstsize); |
| | 1532 | dst[dstsize] = '\0'; |
| | 1533 | return 0; |
| | 1534 | } |
| | 1535 | |
| | 1536 | f_seek(f, off, SEEK_SET); |
| | 1537 | |
| | 1538 | while (skip > base) { |
| | 1539 | old_base = base; |
| | 1540 | if (!(sz = f_gets(tmp, amount, f))) { |
| | 1541 | break; |
| | 1542 | } |
| | 1543 | base = cvt_cpy(cvt, tmp, sz, old_base, ts); |
| | 1544 | if (cvt[base - old_base - 1] == '\n') { |
| | 1545 | q = &cvt[base - old_base - 1]; |
| | 1546 | base = old_base + q - cvt + 1; |
| | 1547 | break; |
| | 1548 | } |
| | 1549 | } |
| | 1550 | |
| | 1551 | useful = base - skip; |
| | 1552 | offset = skip - old_base; |
| | 1553 | |
| | 1554 | if (useful < 0) { |
| | 1555 | memset(dst, ' ', dstsize); |
| | 1556 | dst[dstsize] = '\0'; |
| | 1557 | return 0; |
| | 1558 | } |
| | 1559 | |
| | 1560 | if (useful <= dstsize) { |
| | 1561 | if (useful) { |
| | 1562 | memmove(dst, cvt + offset, useful); |
| | 1563 | } |
| | 1564 | if (q == NULL && (sz = f_gets(tmp, dstsize - useful + 1, f))) { |
| | 1565 | const char *ptr = tmp; |
| | 1566 | useful += cvt_ncpy(dst + useful, dstsize - useful, &ptr, sz, base, ts) - base; |
| | 1567 | if (ptr < tmp + sz) { |
| | 1568 | lastch = *ptr; |
| | 1569 | } |
| | 1570 | } |
| | 1571 | sz = useful; |
| | 1572 | } else { |
| | 1573 | memmove(dst, cvt + offset, dstsize); |
| | 1574 | sz = dstsize; |
| | 1575 | lastch = cvt[offset + dstsize]; |
| | 1576 | } |
| | 1577 | |
| | 1578 | dst[sz] = lastch; |
| | 1579 | for (i = 0; i < sz && dst[i] != '\n'; i++) { |
| | 1580 | if (dst[i] == '\r' && dst[i + 1] == '\n') { |
| | 1581 | if (show_cr) { |
| | 1582 | if (i + 1 < dstsize) { |
| | 1583 | dst[i++] = '^'; |
| | 1584 | dst[i++] = 'M'; |
| | 1585 | } else { |
| | 1586 | dst[i++] = '.'; |
| | 1587 | } |
| | 1588 | } |
| | 1589 | break; |
| | 1590 | } else if (!is_printable(dst[i])) { |
| | 1591 | dst[i] = '.'; |
| | 1592 | } |
| | 1593 | } |
| | 1594 | for (; i < dstsize; i++) { |
| | 1595 | dst[i] = ' '; |
| | 1596 | } |
| | 1597 | dst[i] = '\0'; |
| | 1598 | return sz; |
| | 1599 | } |
| | 1600 | |
| | 1601 | |
| | 1602 | /* diff printers et al *******************************************************/ |
| | 1603 | |
| | 1604 | |
| | 1605 | static void |
| | 1606 | cc_free_elt (void *elt) |
| | 1607 | { |
| | 1608 | DIFFLN *p = elt; |
| | 1609 | if (p->p) { |
| | 1610 | free(p->p); |
| | 1611 | } |
| | 1612 | } |
| | 1613 | |
| | 1614 | |
| | 1615 | static int |
| | 1616 | printer (void *ctx, int ch, int line, off_t off, size_t sz, const char *str) |
| | 1617 | { |
| | 1618 | DIFFLN *p; |
| | 1619 | ARRAY *a = ((PRINTER_CTX *)ctx)->a; |
| | 1620 | DSRC dsrc = ((PRINTER_CTX *)ctx)->dsrc; |
| | 1621 | if (a->error) { |
| | 1622 | return -1; |
| | 1623 | } |
| | 1624 | if (ch) { |
| | 1625 | p = arr_enlarge(a); |
| | 1626 | if (p == NULL) { |
| | 1627 | return -1; |
| | 1628 | } |
| | 1629 | p->p = NULL; |
| | 1630 | p->ch = ch; |
| | 1631 | p->line = line; |
| | 1632 | p->u.off = off; |
| | 1633 | if (dsrc == DATA_SRC_MEM && line) { |
| | 1634 | if (sz && str[sz - 1] == '\n') { |
| | 1635 | sz--; |
| | 1636 | } |
| | 1637 | if (sz) { |
| | 1638 | p->p = malloc(sz); |
| | 1639 | if (p->p == NULL) { |
| | 1640 | a->error = 1; |
| | 1641 | return -1; |
| | 1642 | } |
| | 1643 | memcpy(p->p, str, sz); |
| | 1644 | } |
| | 1645 | p->u.len = sz; |
| | 1646 | } |
| | 1647 | } else if (dsrc == DATA_SRC_MEM) { |
| | 1648 | if (!a->len) { |
| | 1649 | a->error = 1; |
| | 1650 | return -1; |
| | 1651 | } |
| | 1652 | p = (DIFFLN *)a->data + a->len - 1; |
| | 1653 | if (sz && str[sz - 1] == '\n') { |
| | 1654 | sz--; |
| | 1655 | } |
| | 1656 | if (sz) { |
| | 1657 | size_t new_size = p->u.len + sz; |
| | 1658 | char *q = realloc(p->p, new_size); |
| | 1659 | if (q == NULL) { |
| | 1660 | a->error = 1; |
| | 1661 | return -1; |
| | 1662 | } |
| | 1663 | memcpy(q + p->u.len, str, sz); |
| | 1664 | p->p = q; |
| | 1665 | } |
| | 1666 | p->u.len += sz; |
| | 1667 | } |
| | 1668 | if (dsrc == DATA_SRC_TMP && (line || !ch)) { |
| | 1669 | FBUF *f = ((PRINTER_CTX *)ctx)->f; |
| | 1670 | f_write(f, str, sz); |
| | 1671 | } |
| | 1672 | return 0; |
| | 1673 | } |
| | 1674 | |
| | 1675 | |
| | 1676 | static int |
| | 1677 | redo_diff (WDiff *view) |
| | 1678 | { |
| | 1679 | FBUF *const *f = view->f; |
| | 1680 | ARRAY *a = view->a; |
| | 1681 | |
| | 1682 | PRINTER_CTX ctx; |
| | 1683 | ARRAY ops; |
| | 1684 | int ndiff; |
| | 1685 | int rv; |
| | 1686 | |
| | 1687 | char extra[256]; |
| | 1688 | |
| | 1689 | extra[0] = '\0'; |
| | 1690 | if (view->opt.quality == 2) { |
| | 1691 | strcat(extra, " -d"); |
| | 1692 | } |
| | 1693 | if (view->opt.quality == 1) { |
| | 1694 | strcat(extra, " --speed-large-files"); |
| | 1695 | } |
| | 1696 | if (view->opt.strip_trailing_cr) { |
| | 1697 | strcat(extra, " --strip-trailing-cr"); |
| | 1698 | } |
| | 1699 | if (view->opt.ignore_tab_expansion) { |
| | 1700 | strcat(extra, " -E"); |
| | 1701 | } |
| | 1702 | if (view->opt.ignore_space_change) { |
| | 1703 | strcat(extra, " -b"); |
| | 1704 | } |
| | 1705 | if (view->opt.ignore_all_space) { |
| | 1706 | strcat(extra, " -w"); |
| | 1707 | } |
| | 1708 | if (view->opt.ignore_case) { |
| | 1709 | strcat(extra, " -i"); |
| | 1710 | } |
| | 1711 | |
| | 1712 | if (view->dsrc != DATA_SRC_MEM) { |
| | 1713 | f_reset(f[0]); |
| | 1714 | f_reset(f[1]); |
| | 1715 | } |
| | 1716 | |
| | 1717 | ndiff = dff_execute(view->args, extra, view->file[0], view->file[1], &ops); |
| | 1718 | if (ndiff < 0) { |
| | 1719 | return -1; |
| | 1720 | } |
| | 1721 | |
| | 1722 | ctx.dsrc = view->dsrc; |
| | 1723 | |
| | 1724 | rv = 0; |
| | 1725 | |
| | 1726 | arr_init(&a[0], sizeof(DIFFLN), 256); |
| | 1727 | ctx.a = &a[0]; |
| | 1728 | ctx.f = f[0]; |
| | 1729 | rv |= dff_reparse(0, view->file[0], &ops, printer, &ctx); |
| | 1730 | |
| | 1731 | arr_init(&a[1], sizeof(DIFFLN), 256); |
| | 1732 | ctx.a = &a[1]; |
| | 1733 | ctx.f = f[1]; |
| | 1734 | rv |= dff_reparse(1, view->file[1], &ops, printer, &ctx); |
| | 1735 | |
| | 1736 | arr_free(&ops, NULL); |
| | 1737 | |
| | 1738 | if (rv || a[0].error || a[1].error || a[0].len != a[1].len) { |
| | 1739 | arr_free(&a[0], cc_free_elt); |
| | 1740 | arr_free(&a[1], cc_free_elt); |
| | 1741 | return -1; |
| | 1742 | } |
| | 1743 | |
| | 1744 | if (view->dsrc == DATA_SRC_TMP) { |
| | 1745 | f_trunc(f[0]); |
| | 1746 | f_trunc(f[1]); |
| | 1747 | } |
| | 1748 | |
| | 1749 | if (view->dsrc == DATA_SRC_MEM && HDIFF_ENABLE) { |
| | 1750 | view->hdiff = malloc(a[0].len * sizeof(ARRAY *)); |
| | 1751 | if (view->hdiff != NULL) { |
| | 1752 | int i; |
| | 1753 | const DIFFLN *p; |
| | 1754 | const DIFFLN *q; |
| | 1755 | for (p = a[0].data, q = a[1].data, i = 0; i < a[0].len; i++, q++, p++) { |
| | 1756 | ARRAY *h = NULL; |
| | 1757 | if (p->line && q->line && p->ch == CHG_CH) { |
| | 1758 | h = malloc(sizeof(ARRAY)); |
| | 1759 | if (h != NULL) { |
| | 1760 | int rv = hdiff_scan(p->p, p->u.len, q->p, q->u.len, HDIFF_MINCTX, h, HDIFF_DEPTH); |
| | 1761 | if (rv != 0) { |
| | 1762 | free(h); |
| | 1763 | h = NULL; |
| | 1764 | } |
| | 1765 | } |
| | 1766 | } |
| | 1767 | view->hdiff[i] = h; |
| | 1768 | } |
| | 1769 | } |
| | 1770 | } |
| | 1771 | |
| | 1772 | return ndiff; |
| | 1773 | } |
| | 1774 | |
| | 1775 | |
| | 1776 | static void |
| | 1777 | destroy_hdiff (WDiff *view) |
| | 1778 | { |
| | 1779 | if (view->hdiff != NULL) { |
| | 1780 | int i; |
| | 1781 | int len = view->a[0].len; |
| | 1782 | for (i = 0; i < len; i++) { |
| | 1783 | ARRAY *h = view->hdiff[i]; |
| | 1784 | if (h != NULL) { |
| | 1785 | arr_free(h, NULL); |
| | 1786 | free(h); |
| | 1787 | } |
| | 1788 | } |
| | 1789 | free(view->hdiff); |
| | 1790 | view->hdiff = NULL; |
| | 1791 | } |
| | 1792 | } |
| | 1793 | |
| | 1794 | |
| | 1795 | /* stuff *********************************************************************/ |
| | 1796 | |
| | 1797 | |
| | 1798 | static int |
| | 1799 | get_digits (unsigned int n) |
| | 1800 | { |
| | 1801 | int d = 1; |
| | 1802 | while (n /= 10) { |
| | 1803 | d++; |
| | 1804 | } |
| | 1805 | return d; |
| | 1806 | } |
| | 1807 | |
| | 1808 | |
| | 1809 | static int |
| | 1810 | get_line_numbers (const ARRAY *a, int pos, int *linenum, int *lineofs) |
| | 1811 | { |
| | 1812 | const DIFFLN *p; |
| | 1813 | |
| | 1814 | *linenum = 0; |
| | 1815 | *lineofs = 0; |
| | 1816 | |
| | 1817 | if (a->len) { |
| | 1818 | if (pos >= a->len) { |
| | 1819 | pos = a->len - 1; |
| | 1820 | } |
| | 1821 | |
| | 1822 | p = (DIFFLN *)a->data + pos; |
| | 1823 | |
| | 1824 | if (!p->line) { |
| | 1825 | int n; |
| | 1826 | for (n = pos; n > 0; n--) { |
| | 1827 | p--; |
| | 1828 | if (p->line) { |
| | 1829 | break; |
| | 1830 | } |
| | 1831 | } |
| | 1832 | *lineofs = pos - n + 1; |
| | 1833 | } |
| | 1834 | |
| | 1835 | *linenum = p->line; |
| | 1836 | } |
| | 1837 | return 0; |
| | 1838 | } |
| | 1839 | |
| | 1840 | |
| | 1841 | static int |
| | 1842 | calc_nwidth (const ARRAY *const a) |
| | 1843 | { |
| | 1844 | int l1, o1; |
| | 1845 | int l2, o2; |
| | 1846 | get_line_numbers(&a[0], a[0].len - 1, &l1, &o1); |
| | 1847 | get_line_numbers(&a[1], a[1].len - 1, &l2, &o2); |
| | 1848 | if (l1 < l2) { |
| | 1849 | l1 = l2; |
| | 1850 | } |
| | 1851 | return get_digits(l1); |
| | 1852 | } |
| | 1853 | |
| | 1854 | |
| | 1855 | static int |
| | 1856 | find_prev_hunk (const ARRAY *a, int pos) |
| | 1857 | { |
| | 1858 | #if 1 |
| | 1859 | while (pos > 0 && ((DIFFLN *)a->data)[pos].ch != EQU_CH) { |
| | 1860 | pos--; |
| | 1861 | } |
| | 1862 | while (pos > 0 && ((DIFFLN *)a->data)[pos].ch == EQU_CH) { |
| | 1863 | pos--; |
| | 1864 | } |
| | 1865 | #else |
| | 1866 | while (pos > 0 && ((DIFFLN *)a->data)[pos - 1].ch == EQU_CH) { |
| | 1867 | pos--; |
| | 1868 | } |
| | 1869 | while (pos > 0 && ((DIFFLN *)a->data)[pos - 1].ch != EQU_CH) { |
| | 1870 | pos--; |
| | 1871 | } |
| | 1872 | #endif |
| | 1873 | |
| | 1874 | return pos; |
| | 1875 | } |
| | 1876 | |
| | 1877 | |
| | 1878 | static int |
| | 1879 | find_next_hunk (const ARRAY *a, int pos) |
| | 1880 | { |
| | 1881 | while (pos < a->len && ((DIFFLN *)a->data)[pos].ch != EQU_CH) { |
| | 1882 | pos++; |
| | 1883 | } |
| | 1884 | while (pos < a->len && ((DIFFLN *)a->data)[pos].ch == EQU_CH) { |
| | 1885 | pos++; |
| | 1886 | } |
| | 1887 | |
| | 1888 | return pos; |
| | 1889 | } |
| | 1890 | |
| | 1891 | |
| | 1892 | /* view routines and callbacks ***********************************************/ |
| | 1893 | |
| | 1894 | |
| | 1895 | static void |
| | 1896 | view_compute_split (WDiff *view, int i) |
| | 1897 | { |
| | 1898 | view->bias += i; |
| | 1899 | if (view->bias < 2 - view->half1) { |
| | 1900 | view->bias = 2 - view->half1; |
| | 1901 | } |
| | 1902 | if (view->bias > view->half2 - 2) { |
| | 1903 | view->bias = view->half2 - 2; |
| | 1904 | } |
| | 1905 | } |
| | 1906 | |
| | 1907 | |
| | 1908 | static void |
| | 1909 | view_compute_areas (WDiff *view) |
| | 1910 | { |
| | 1911 | view->height = LINES - 2; |
| | 1912 | view->half1 = COLS / 2; |
| | 1913 | view->half2 = COLS - view->half1; |
| | 1914 | |
| | 1915 | view_compute_split(view, 0); |
| | 1916 | } |
| | 1917 | |
| | 1918 | |
| | 1919 | static int |
| | 1920 | view_init (WDiff *view, const char *args, const char *file1, const char *file2, const char *label1, const char *label2, DSRC dsrc) |
| | 1921 | { |
| | 1922 | int ndiff; |
| | 1923 | FBUF *f[2]; |
| | 1924 | |
| | 1925 | f[0] = NULL; |
| | 1926 | f[1] = NULL; |
| | 1927 | |
| | 1928 | if (dsrc == DATA_SRC_TMP) { |
| | 1929 | f[0] = f_temp(); |
| | 1930 | if (f[0] == NULL) { |
| | 1931 | goto err_2; |
| | 1932 | } |
| | 1933 | f[1] = f_temp(); |
| | 1934 | if (f[1] == NULL) { |
| | 1935 | f_close(f[0]); |
| | 1936 | goto err_2; |
| | 1937 | } |
| | 1938 | } |
| | 1939 | if (dsrc == DATA_SRC_ORG) { |
| | 1940 | f[0] = f_open(file1, O_RDONLY); |
| | 1941 | if (f[0] == NULL) { |
| | 1942 | goto err_2; |
| | 1943 | } |
| | 1944 | f[1] = f_open(file2, O_RDONLY); |
| | 1945 | if (f[1] == NULL) { |
| | 1946 | f_close(f[0]); |
| | 1947 | goto err_2; |
| | 1948 | } |
| | 1949 | } |
| | 1950 | |
| | 1951 | view->args = args; |
| | 1952 | view->file[0] = file1; |
| | 1953 | view->file[1] = file2; |
| | 1954 | view->label[0] = label1; |
| | 1955 | view->label[1] = label2; |
| | 1956 | view->f[0] = f[0]; |
| | 1957 | view->f[1] = f[1]; |
| | 1958 | view->hdiff = NULL; |
| | 1959 | view->dsrc = dsrc; |
| | 1960 | |
| | 1961 | ndiff = redo_diff(view); |
| | 1962 | if (ndiff < 0) { |
| | 1963 | goto err_3; |
| | 1964 | } |
| | 1965 | |
| | 1966 | view->ndiff = ndiff; |
| | 1967 | |
| | 1968 | view->view_quit = 0; |
| | 1969 | |
| | 1970 | view->bias = 0; |
| | 1971 | view->new_frame = 1; |
| | 1972 | view->skip_rows = 0; |
| | 1973 | view->skip_cols = 0; |
| | 1974 | view->display_symbols = 0; |
| | 1975 | view->display_numbers = 0; |
| | 1976 | view->show_cr = 1; |
| | 1977 | view->show_hdiff = 1; |
| | 1978 | view->tab_size = 8; |
| | 1979 | view->ord = 0; |
| | 1980 | view->full = 0; |
| | 1981 | view->last_found = -1; |
| | 1982 | |
| | 1983 | view->opt.quality = 0; |
| | 1984 | view->opt.strip_trailing_cr = 0; |
| | 1985 | view->opt.ignore_tab_expansion = 0; |
| | 1986 | view->opt.ignore_space_change = 0; |
| | 1987 | view->opt.ignore_all_space = 0; |
| | 1988 | view->opt.ignore_case = 0; |
| | 1989 | |
| | 1990 | view_compute_areas(view); |
| | 1991 | return 0; |
| | 1992 | |
| | 1993 | err_3: |
| | 1994 | if (dsrc != DATA_SRC_MEM) { |
| | 1995 | f_close(f[1]); |
| | 1996 | f_close(f[0]); |
| | 1997 | } |
| | 1998 | err_2: |
| | 1999 | return -1; |
| | 2000 | } |
| | 2001 | |
| | 2002 | |
| | 2003 | static int |
| | 2004 | view_reinit (WDiff *view) |
| | 2005 | { |
| | 2006 | int ndiff = view->ndiff; |
| | 2007 | |
| | 2008 | diffopt_widgets[2].value = view->opt.quality; |
| | 2009 | diffopt_widgets[2].result = &view->opt.quality; |
| | 2010 | diffopt_widgets[3].result = &view->opt.strip_trailing_cr; |
| | 2011 | diffopt_widgets[4].result = &view->opt.ignore_all_space; |
| | 2012 | diffopt_widgets[5].result = &view->opt.ignore_space_change; |
| | 2013 | diffopt_widgets[6].result = &view->opt.ignore_tab_expansion; |
| | 2014 | diffopt_widgets[7].result = &view->opt.ignore_case; |
| | 2015 | |
| | 2016 | if (quick_dialog(&diffopt) != B_CANCEL) { |
| | 2017 | destroy_hdiff(view); |
| | 2018 | arr_free(&view->a[1], cc_free_elt); |
| | 2019 | arr_free(&view->a[0], cc_free_elt); |
| | 2020 | ndiff = redo_diff(view); |
| | 2021 | if (ndiff >= 0) { |
| | 2022 | view->ndiff = ndiff; |
| | 2023 | } |
| | 2024 | } |
| | 2025 | return ndiff; |
| | 2026 | } |
| | 2027 | |
| | 2028 | |
| | 2029 | static void |
| | 2030 | view_fini (WDiff *view) |
| | 2031 | { |
| | 2032 | if (view->dsrc != DATA_SRC_MEM) { |
| | 2033 | f_close(view->f[1]); |
| | 2034 | f_close(view->f[0]); |
| | 2035 | } |
| | 2036 | |
| | 2037 | destroy_hdiff(view); |
| | 2038 | arr_free(&view->a[1], cc_free_elt); |
| | 2039 | arr_free(&view->a[0], cc_free_elt); |
| | 2040 | } |
| | 2041 | |
| | 2042 | |
| | 2043 | static int |
| | 2044 | view_display_file (const WDiff *view, int ord, |
| | 2045 | int r, int c, int height, int width) |
| | 2046 | { |
| | 2047 | int i, j, k; |
| | 2048 | char buf[BUFSIZ]; |
| | 2049 | FBUF *f = view->f[ord]; |
| | 2050 | const ARRAY *a = &view->a[ord]; |
| | 2051 | int skip = view->skip_cols; |
| | 2052 | int display_symbols = view->display_symbols; |
| | 2053 | int display_numbers = view->display_numbers; |
| | 2054 | int show_cr = view->show_cr; |
| | 2055 | int tab_size = view->tab_size; |
| | 2056 | const DIFFLN *p; |
| | 2057 | |
| | 2058 | int nwidth = display_numbers; |
| | 2059 | int xwidth = display_symbols + display_numbers; |
| | 2060 | |
| | 2061 | if (xwidth) { |
| | 2062 | if (xwidth > width && display_symbols) { |
| | 2063 | xwidth--; |
| | 2064 | display_symbols = 0; |
| | 2065 | } |
| | 2066 | if (xwidth > width && display_numbers) { |
| | 2067 | xwidth = width; |
| | 2068 | display_numbers = width; |
| | 2069 | } |
| | 2070 | |
| | 2071 | xwidth++; |
| | 2072 | |
| | 2073 | c += xwidth; |
| | 2074 | width -= xwidth; |
| | 2075 | |
| | 2076 | if (width < 0) { |
| | 2077 | width = 0; |
| | 2078 | } |
| | 2079 | } |
| | 2080 | |
| | 2081 | if ((int)sizeof(buf) <= width || (int)sizeof(buf) <= nwidth) { |
| | 2082 | /* abnormal, but avoid buffer overflow */ |
| | 2083 | return -1; |
| | 2084 | } |
| | 2085 | |
| | 2086 | for (i = view->skip_rows, j = 0, p = (DIFFLN *)a->data + i; i < a->len && j < height; p++, j++, i++) { |
| | 2087 | int ch = p->ch; |
| | 2088 | tty_setcolor(NORMAL_COLOR); |
| | 2089 | if (display_symbols) { |
| | 2090 | tty_gotoyx(r + j, c - 2); |
| | 2091 | tty_print_char(ch); |
| | 2092 | } |
| | 2093 | if (p->line) { |
| | 2094 | if (display_numbers) { |
| | 2095 | tty_gotoyx(r + j, c - xwidth); |
| | 2096 | snprintf(buf, display_numbers + 1, "%*d", nwidth, p->line); |
| | 2097 | tty_print_string(buf); |
| | 2098 | } |
| | 2099 | if (ch == ADD_CH) { |
| | 2100 | tty_setcolor(DFFADD_COLOR); |
| | 2101 | } |
| | 2102 | if (ch == CHG_CH) { |
| | 2103 | tty_setcolor(DFFCHG_COLOR); |
| | 2104 | } |
| | 2105 | if (f == NULL) { |
| | 2106 | if (i == view->last_found) { |
| | 2107 | tty_setcolor(MARKED_SELECTED_COLOR); |
| | 2108 | } else if (view->show_hdiff) { |
| | 2109 | if (view->hdiff != NULL && view->hdiff[i] != NULL) { |
| | 2110 | char att[BUFSIZ]; |
| | 2111 | cvt_mgeta(p->p, p->u.len, buf, width, skip, tab_size, show_cr, view->hdiff[i], ord, att); |
| | 2112 | tty_gotoyx(r + j, c); |
| | 2113 | for (k = 0; k < width; k++) { |
| | 2114 | tty_setcolor(att[k] ? DFFCHH_COLOR : DFFCHG_COLOR); |
| | 2115 | tty_print_char(buf[k]); |
| | 2116 | } |
| | 2117 | continue; |
| | 2118 | } else if (ch == CHG_CH) { |
| | 2119 | tty_setcolor(DFFCHH_COLOR); |
| | 2120 | } |
| | 2121 | } |
| | 2122 | cvt_mget(p->p, p->u.len, buf, width, skip, tab_size, show_cr); |
| | 2123 | } else { |
| | 2124 | cvt_fget(f, p->u.off, buf, width, skip, tab_size, show_cr); |
| | 2125 | } |
| | 2126 | } else { |
| | 2127 | if (display_numbers) { |
| | 2128 | tty_gotoyx(r + j, c - xwidth); |
| | 2129 | memset(buf, ' ', display_numbers); |
| | 2130 | buf[display_numbers] = '\0'; |
| | 2131 | tty_print_nstring(buf, display_numbers); |
| | 2132 | } |
| | 2133 | if (ch == DEL_CH) { |
| | 2134 | tty_setcolor(DFFDEL_COLOR); |
| | 2135 | } |
| | 2136 | if (ch == CHG_CH) { |
| | 2137 | tty_setcolor(DFFCHD_COLOR); |
| | 2138 | } |
| | 2139 | memset(buf, ' ', width); |
| | 2140 | buf[width] = '\0'; |
| | 2141 | } |
| | 2142 | tty_gotoyx(r + j, c); |
| | 2143 | tty_print_nstring(buf, width); |
| | 2144 | } |
| | 2145 | tty_setcolor(NORMAL_COLOR); |
| | 2146 | k = width; |
| | 2147 | if (width < xwidth - 1) { |
| | 2148 | k = xwidth - 1; |
| | 2149 | } |
| | 2150 | memset(buf, ' ', k); |
| | 2151 | buf[k] = '\0'; |
| | 2152 | for (; j < height; j++) { |
| | 2153 | if (xwidth) { |
| | 2154 | tty_gotoyx(r + j, c - xwidth); |
| | 2155 | tty_print_nstring(buf, xwidth - 1); |
| | 2156 | } |
| | 2157 | tty_gotoyx(r + j, c); |
| | 2158 | tty_print_nstring(buf, width); |
| | 2159 | } |
| | 2160 | |
| | 2161 | return 0; |
| | 2162 | } |
| | 2163 | |
| | 2164 | |
| | 2165 | static void |
| | 2166 | view_status (const WDiff *view, int ord, int width, int c) |
| | 2167 | { |
| | 2168 | int skip_rows = view->skip_rows; |
| | 2169 | int skip_cols = view->skip_cols; |
| | 2170 | |
| | 2171 | char buf[BUFSIZ]; |
| | 2172 | int filename_width; |
| | 2173 | int linenum, lineofs; |
| | 2174 | |
| | 2175 | tty_setcolor(SELECTED_COLOR); |
| | 2176 | |
| | 2177 | tty_gotoyx(0, c); |
| | 2178 | get_line_numbers(&view->a[ord], skip_rows, &linenum, &lineofs); |
| | 2179 | |
| | 2180 | filename_width = width - 22; |
| | 2181 | if (filename_width < 8) { |
| | 2182 | filename_width = 8; |
| | 2183 | } |
| | 2184 | if (filename_width >= (int)sizeof(buf)) { |
| | 2185 | /* abnormal, but avoid buffer overflow */ |
| | 2186 | filename_width = sizeof(buf) - 1; |
| | 2187 | } |
| | 2188 | trim(strip_home_and_password(view->label[ord]), buf, filename_width); |
| | 2189 | if (ord == 0) { |
| | 2190 | tty_printf("%-*s %6d+%-4d Col %-4d ", filename_width, buf, linenum, lineofs, skip_cols); |
| | 2191 | } else { |
| | 2192 | tty_printf("%-*s %6d+%-4d Dif %-4d ", filename_width, buf, linenum, lineofs, view->ndiff); |
| | 2193 | } |
| | 2194 | } |
| | 2195 | |
| | 2196 | |
| | 2197 | static void |
| | 2198 | view_update (WDiff *view) |
| | 2199 | { |
| | 2200 | int height = view->height; |
| | 2201 | int width1; |
| | 2202 | int width2; |
| | 2203 | |
| | 2204 | int last = view->a[0].len - 1; |
| | 2205 | |
| | 2206 | if (view->skip_rows > last) { |
| | 2207 | view->skip_rows = last; |
| | 2208 | } |
| | 2209 | if (view->skip_rows < 0) { |
| | 2210 | view->skip_rows = 0; |
| | 2211 | } |
| | 2212 | if (view->skip_cols < 0) { |
| | 2213 | view->skip_cols = 0; |
| | 2214 | } |
| | 2215 | |
| | 2216 | if (height < 2) { |
| | 2217 | return; |
| | 2218 | } |
| | 2219 | |
| | 2220 | width1 = view->half1 + view->bias; |
| | 2221 | width2 = view->half2 - view->bias; |
| | 2222 | if (view->full) { |
| | 2223 | width1 = COLS; |
| | 2224 | width2 = 0; |
| | 2225 | } |
| | 2226 | |
| | 2227 | if (view->new_frame) { |
| | 2228 | Dlg_head *h = view->widget.parent; |
| | 2229 | |
| | 2230 | int xwidth = view->display_symbols + view->display_numbers; |
| | 2231 | |
| | 2232 | tty_setcolor(NORMAL_COLOR); |
| | 2233 | if (width1 > 1) { |
| | 2234 | draw_double_box(h, 1, 0, height, width1); |
| | 2235 | } |
| | 2236 | if (width2 > 1) { |
| | 2237 | draw_double_box(h, 1, width1, height, width2); |
| | 2238 | } |
| | 2239 | |
| | 2240 | if (xwidth) { |
| | 2241 | xwidth++; |
| | 2242 | if (xwidth < width1 - 1) { |
| | 2243 | tty_gotoyx(1, xwidth); |
| | 2244 | tty_print_alt_char(ACS_TTEE); |
| | 2245 | tty_gotoyx(height, xwidth); |
| | 2246 | tty_print_alt_char(ACS_BTEE); |
| | 2247 | tty_print_vline(2, xwidth, height - 2); |
| | 2248 | } |
| | 2249 | if (xwidth < width2 - 1) { |
| | 2250 | tty_gotoyx(1, width1 + xwidth); |
| | 2251 | tty_print_alt_char(ACS_TTEE); |
| | 2252 | tty_gotoyx(height, width1 + xwidth); |
| | 2253 | tty_print_alt_char(ACS_BTEE); |
| | 2254 | tty_print_vline(2, width1 + xwidth, height - 2); |
| | 2255 | } |
| | 2256 | } |
| | 2257 | |
| | 2258 | view->new_frame = 0; |
| | 2259 | } |
| | 2260 | |
| | 2261 | if (width1 > 2) { |
| | 2262 | view_status(view, view->ord, width1, 0); |
| | 2263 | view_display_file(view, view->ord, 2, 1, height - 2, width1 - 2); |
| | 2264 | } |
| | 2265 | if (width2 > 2) { |
| | 2266 | view_status(view, view->ord ^ 1, width2, width1); |
| | 2267 | view_display_file(view, view->ord ^ 1, 2, width1 + 1, height - 2, width2 - 2); |
| | 2268 | } |
| | 2269 | } |
| | 2270 | |
| | 2271 | |
| | 2272 | static void |
| | 2273 | view_redo (WDiff *view) |
| | 2274 | { |
| | 2275 | if (view_reinit(view) < 0) { |
| | 2276 | view->view_quit = 1; |
| | 2277 | } else if (view->display_numbers) { |
| | 2278 | int old = view->display_numbers; |
| | 2279 | view->display_numbers = calc_nwidth(view->a); |
| | 2280 | view->new_frame = (old != view->display_numbers); |
| | 2281 | } |
| | 2282 | } |
| | 2283 | |
| | 2284 | |
| | 2285 | #define IS_WHOLE_OR_DONT_CARE() \ |
| | 2286 | (!whole || ( \ |
| | 2287 | (i == 0 || strchr(wholechars, haystack[i - 1]) == NULL) && \ |
| | 2288 | (i + nlen == hlen || strchr(wholechars, haystack[i + nlen]) == NULL) \ |
| | 2289 | )) |
| | 2290 | |
| | 2291 | |
| | 2292 | static const unsigned char * |
| | 2293 | memmem_dummy (const unsigned char *haystack, size_t i, size_t hlen, const unsigned char *needle, size_t nlen, int whole) |
| | 2294 | { |
| | 2295 | for (; i + nlen <= hlen; i++) { |
| | 2296 | if (haystack[i] == needle[0]) { |
| | 2297 | size_t j; |
| | 2298 | for (j = 1; j < nlen; j++) { |
| | 2299 | if (haystack[i + j] != needle[j]) { |
| | 2300 | break; |
| | 2301 | } |
| | 2302 | } |
| | 2303 | if (j == nlen && IS_WHOLE_OR_DONT_CARE()) { |
| | 2304 | return haystack + i; |
| | 2305 | } |
| | 2306 | } |
| | 2307 | } |
| | 2308 | |
| | 2309 | return NULL; |
| | 2310 | } |
| | 2311 | |
| | 2312 | |
| | 2313 | static const unsigned char * |
| | 2314 | memmem_dummy_nocase (const unsigned char *haystack, size_t i, size_t hlen, const unsigned char *needle, size_t nlen, int whole) |
| | 2315 | { |
| | 2316 | for (; i + nlen <= hlen; i++) { |
| | 2317 | if (toupper(haystack[i]) == toupper(needle[0])) { |
| | 2318 | size_t j; |
| | 2319 | for (j = 1; j < nlen; j++) { |
| | 2320 | if (toupper(haystack[i + j]) != toupper(needle[j])) { |
| | 2321 | break; |
| | 2322 | } |
| | 2323 | } |
| | 2324 | if (j == nlen && IS_WHOLE_OR_DONT_CARE()) { |
| | 2325 | return haystack + i; |
| | 2326 | } |
| | 2327 | } |
| | 2328 | } |
| | 2329 | |
| | 2330 | return NULL; |
| | 2331 | } |
| | 2332 | |
| | 2333 | |
| | 2334 | static const unsigned char * |
| | 2335 | memmem_dummy_rev (const unsigned char *haystack, size_t i, size_t hlen, const unsigned char *needle, size_t nlen, int whole) |
| | 2336 | { |
| | 2337 | while (i--) { |
| | 2338 | if (haystack[i] == needle[0] && i + nlen <= hlen) { |
| | 2339 | size_t j; |
| | 2340 | for (j = 1; j < nlen; j++) { |
| | 2341 | if (haystack[i + j] != needle[j]) { |
| | 2342 | break; |
| | 2343 | } |
| | 2344 | } |
| | 2345 | if (j == nlen && IS_WHOLE_OR_DONT_CARE()) { |
| | 2346 | return haystack + i; |
| | 2347 | } |
| | 2348 | } |
| | 2349 | } |
| | 2350 | |
| | 2351 | return NULL; |
| | 2352 | } |
| | 2353 | |
| | 2354 | |
| | 2355 | static const unsigned char * |
| | 2356 | memmem_dummy_rev_nocase (const unsigned char *haystack, size_t i, size_t hlen, const unsigned char *needle, size_t nlen, int whole) |
| | 2357 | { |
| | 2358 | while (i--) { |
| | 2359 | if (toupper(haystack[i]) == toupper(needle[0]) && i + nlen <= hlen) { |
| | 2360 | size_t j; |
| | 2361 | for (j = 1; j < nlen; j++) { |
| | 2362 | if (toupper(haystack[i + j]) != toupper(needle[j])) { |
| | 2363 | break; |
| | 2364 | } |
| | 2365 | } |
| | 2366 | if (j == nlen && IS_WHOLE_OR_DONT_CARE()) { |
| | 2367 | return haystack + i; |
| | 2368 | } |
| | 2369 | } |
| | 2370 | } |
| | 2371 | |
| | 2372 | return NULL; |
| | 2373 | } |
| | 2374 | |
| | 2375 | |
| | 2376 | static const unsigned char * |
| | 2377 | search_string (const DIFFLN *p, size_t xpos, const void *needle, size_t nlen, int whole, int ccase) |
| | 2378 | { |
| | 2379 | const unsigned char *haystack = p->p; |
| | 2380 | size_t hlen = p->u.len; |
| | 2381 | |
| | 2382 | if (xpos > hlen || nlen <= 0 || haystack == NULL || needle == NULL) { |
| | 2383 | return NULL; |
| | 2384 | } |
| | 2385 | |
| | 2386 | /* XXX I should use Boyer-Moore */ |
| | 2387 | if (ccase) { |
| | 2388 | return memmem_dummy(haystack, xpos, hlen, needle, nlen, whole); |
| | 2389 | } else { |
| | 2390 | return memmem_dummy_nocase(haystack, xpos, hlen, needle, nlen, whole); |
| | 2391 | } |
| | 2392 | } |
| | 2393 | |
| | 2394 | |
| | 2395 | static int |
| | 2396 | view_search_string (WDiff *view, const char *needle, int ccase, int back, int whole) |
| | 2397 | { |
| | 2398 | size_t nlen = strlen(needle); |
| | 2399 | size_t xpos = 0; |
| | 2400 | |
| | 2401 | int ord = view->ord; |
| | 2402 | const ARRAY *a = &view->a[ord]; |
| | 2403 | const DIFFLN *p; |
| | 2404 | |
| | 2405 | int i = view->last_found; |
| | 2406 | |
| | 2407 | if (back) { |
| | 2408 | if (i == -1) { |
| | 2409 | i = view->skip_rows; |
| | 2410 | } |
| | 2411 | for (--i, p = (DIFFLN *)a->data + i; i >= 0; p--, i--) { |
| | 2412 | const unsigned char *q = search_string(p, xpos, needle, nlen, whole, ccase); |
| | 2413 | if (q != NULL) { |
| | 2414 | return i; |
| | 2415 | } |
| | 2416 | } |
| | 2417 | } else { |
| | 2418 | if (i == -1) { |
| | 2419 | i = view->skip_rows - 1; |
| | 2420 | } |
| | 2421 | for (++i, p = (DIFFLN *)a->data + i; i < a->len; p++, i++) { |
| | 2422 | const unsigned char *q = search_string(p, xpos, needle, nlen, whole, ccase); |
| | 2423 | if (q != NULL) { |
| | 2424 | return i; |
| | 2425 | } |
| | 2426 | } |
| | 2427 | } |
| | 2428 | |
| | 2429 | return -1; |
| | 2430 | } |
| | 2431 | |
| | 2432 | |
| | 2433 | static void |
| | 2434 | view_search (WDiff *view, int again) |
| | 2435 | { |
| | 2436 | /* XXX some statics here, to be remembered between runs */ |
| | 2437 | static char *searchopt_text = NULL; |
| | 2438 | static int searchopt_type; |
| | 2439 | static int searchopt_case; |
| | 2440 | static int searchopt_backwards; |
| | 2441 | static int searchopt_whole; |
| | 2442 | |
| | 2443 | static int compiled = 0; |
| | 2444 | |
| | 2445 | if (again < 0) { |
| | 2446 | g_free(searchopt_text); |
| | 2447 | searchopt_text = NULL; |
| | 2448 | if (compiled) { |
| | 2449 | compiled = 0; |
| | 2450 | /*XXX free search exp*/ |
| | 2451 | } |
| | 2452 | return; |
| | 2453 | } |
| | 2454 | |
| | 2455 | if (view->dsrc != DATA_SRC_MEM) { |
| | 2456 | error_dialog(_("Search"), _(" Search is disabled ")); |
| | 2457 | return; |
| | 2458 | } |
| | 2459 | |
| | 2460 | if (!again || searchopt_text == NULL) { |
| | 2461 | char *tsearchopt_text; |
| | 2462 | int tsearchopt_type = searchopt_type; |
| | 2463 | int tsearchopt_case = searchopt_case; |
| | 2464 | int tsearchopt_backwards = searchopt_backwards; |
| | 2465 | int tsearchopt_whole = searchopt_whole; |
| | 2466 | |
| | 2467 | search_widgets[2].result = &tsearchopt_whole; |
| | 2468 | search_widgets[3].result = &tsearchopt_backwards; |
| | 2469 | search_widgets[4].result = &tsearchopt_case; |
| | 2470 | search_widgets[5].result = &tsearchopt_type; |
| | 2471 | search_widgets[6].str_result = &tsearchopt_text; |
| | 2472 | search_widgets[6].text = searchopt_text; |
| | 2473 | |
| | 2474 | if (quick_dialog(&search_input) == B_CANCEL) { |
| | 2475 | return; |
| | 2476 | } |
| | 2477 | if (tsearchopt_text == NULL || !*tsearchopt_text) { |
| | 2478 | g_free(tsearchopt_text); |
| | 2479 | return; |
| | 2480 | } |
| | 2481 | g_free(searchopt_text); |
| | 2482 | |
| | 2483 | searchopt_text = tsearchopt_text; |
| | 2484 | searchopt_type = tsearchopt_type; |
| | 2485 | searchopt_case = tsearchopt_case; |
| | 2486 | searchopt_backwards = tsearchopt_backwards; |
| | 2487 | searchopt_whole = tsearchopt_whole; |
| | 2488 | } |
| | 2489 | |
| | 2490 | if (compiled) { |
| | 2491 | compiled = 0; |
| | 2492 | /*XXX free search exp*/ |
| | 2493 | } |
| | 2494 | if (0/*XXX new search exp*/) { |
| | 2495 | error_dialog(_("Error"), _(" Cannot search ")); |
| | 2496 | return; |
| | 2497 | } |
| | 2498 | compiled = 1; |
| | 2499 | if (searchopt_type == 0) { |
| | 2500 | view->last_found = view_search_string(view, searchopt_text, searchopt_case, searchopt_backwards, searchopt_whole); |
| | 2501 | } |
| | 2502 | |
| | 2503 | if (view->last_found == -1) { |
| | 2504 | error_dialog(_("Search"), _(" Search string not found ")); |
| | 2505 | } else { |
| | 2506 | view->skip_rows = view->last_found; |
| | 2507 | view_update(view); |
| | 2508 | } |
| | 2509 | } |
| | 2510 | |
| | 2511 | |
| | 2512 | static void |
| | 2513 | view_search_cmd (WDiff *view) |
| | 2514 | { |
| | 2515 | view_search(view, 0); |
| | 2516 | } |
| | 2517 | |
| | 2518 | |
| | 2519 | static void |
| | 2520 | view_edit (WDiff *view, int ord) |
| | 2521 | { |
| | 2522 | int linenum, lineofs; |
| | 2523 | |
| | 2524 | if (view->dsrc == DATA_SRC_TMP) { |
| | 2525 | error_dialog(_("Edit"), _(" Edit is disabled ")); |
| | 2526 | return; |
| | 2527 | } |
| | 2528 | |
| | 2529 | get_line_numbers(&view->a[ord], view->skip_rows, &linenum, &lineofs); |
| | 2530 | do_edit_at_line(view->file[ord], linenum); |
| | 2531 | view_redo(view); |
| | 2532 | view_update(view); |
| | 2533 | } |
| | 2534 | |
| | 2535 | |
| | 2536 | static void |
| | 2537 | view_edit_cmd (WDiff *view) |
| | 2538 | { |
| | 2539 | view_edit(view, view->ord); |
| | 2540 | } |
| | 2541 | |
| | 2542 | |
| | 2543 | static void |
| | 2544 | view_goto_cmd (WDiff *view, int ord) |
| | 2545 | { |
| | 2546 | static const char *title[2] = { " Goto line (left) ", " Goto line (right) " }; |
| | 2547 | static char prev[256]; |
| | 2548 | /* XXX some statics here, to be remembered between runs */ |
| | 2549 | |
| | 2550 | int newline; |
| | 2551 | char *input; |
| | 2552 | |
| | 2553 | input = input_dialog(_(title[ord]), _(" Enter line: "), MC_HISTORY_YDIFF_GOTO_LINE, prev); |
| | 2554 | if (input != NULL) { |
| | 2555 | const char *s = input; |
| | 2556 | if (scan_deci(&s, &newline) == 0 && *s == '\0') { |
| | 2557 | int i = 0; |
| | 2558 | if (newline > 0) { |
| | 2559 | const DIFFLN *p; |
| | 2560 | for (p = view->a[ord].data; i < view->a[ord].len; i++, p++) { |
| | 2561 | if (p->line == newline) { |
| | 2562 | break; |
| | 2563 | } |
| | 2564 | } |
| | 2565 | } |
| | 2566 | view->skip_rows = i; |
| | 2567 | snprintf(prev, sizeof(prev), "%d", newline); |
| | 2568 | } |
| | 2569 | g_free(input); |
| | 2570 | } |
| | 2571 | } |
| | 2572 | |
| | 2573 | |
| | 2574 | static void |
| | 2575 | view_help_cmd (void) |
| | 2576 | { |
| | 2577 | interactive_display(NULL, "[Diff Viewer]"); |
| | 2578 | } |
| | 2579 | |
| | 2580 | |
| | 2581 | static void |
| | 2582 | view_quit_cmd (WDiff *view) |
| | 2583 | { |
| | 2584 | dlg_stop(view->widget.parent); |
| | 2585 | } |
| | 2586 | |
| | 2587 | |
| | 2588 | static void |
| | 2589 | view_labels (WDiff *view) |
| | 2590 | { |
| | 2591 | Dlg_head *h = view->widget.parent; |
| | 2592 | |
| | 2593 | buttonbar_set_label(h, 1, Q_("ButtonBar|Help"), view_help_cmd); |
| | 2594 | |
| | 2595 | buttonbar_set_label_data(h, 4, Q_("ButtonBar|Edit"), (buttonbarfn)view_edit_cmd, view); |
| | 2596 | buttonbar_set_label_data(h, 7, Q_("ButtonBar|Search"), (buttonbarfn)view_search_cmd, view); |
| | 2597 | buttonbar_set_label_data(h, 10, Q_("ButtonBar|Quit"), (buttonbarfn)view_quit_cmd, view); |
| | 2598 | } |
| | 2599 | |
| | 2600 | |
| | 2601 | static int |
| | 2602 | view_event (Gpm_Event *event, void *x) |
| | 2603 | { |
| | 2604 | WDiff *view = (WDiff *)x; |
| | 2605 | int result = MOU_NORMAL; |
| | 2606 | |
| | 2607 | /* We are not interested in the release events */ |
| | 2608 | if (!(event->type & (GPM_DOWN | GPM_DRAG))) { |
| | 2609 | return result; |
| | 2610 | } |
| | 2611 | |
| | 2612 | /* Wheel events */ |
| | 2613 | if ((event->buttons & GPM_B_UP) && (event->type & GPM_DOWN)) { |
| | 2614 | view->skip_rows -= 2; |
| | 2615 | view_update(view); |
| | 2616 | return result; |
| | 2617 | } |
| | 2618 | if ((event->buttons & GPM_B_DOWN) && (event->type & GPM_DOWN)) { |
| | 2619 | view->skip_rows += 2; |
| | 2620 | view_update(view); |
| | 2621 | return result; |
| | 2622 | } |
| | 2623 | |
| | 2624 | return result; |
| | 2625 | } |
| | 2626 | |
| | 2627 | |
| | 2628 | static cb_ret_t |
| | 2629 | view_handle_key (WDiff *view, int c) |
| | 2630 | { |
| | 2631 | c = convert_from_input_c(c); |
| | 2632 | |
| | 2633 | switch (c) { |
| | 2634 | case 's': |
| | 2635 | view->display_symbols ^= 1; |
| | 2636 | view->new_frame = 1; |
| | 2637 | return MSG_HANDLED; |
| | 2638 | |
| | 2639 | case 'l': |
| | 2640 | view->display_numbers ^= calc_nwidth(view->a); |
| | 2641 | view->new_frame = 1; |
| | 2642 | return MSG_HANDLED; |
| | 2643 | |
| | 2644 | case 'f': |
| | 2645 | view->full ^= 1; |
| | 2646 | view->new_frame = 1; |
| | 2647 | return MSG_HANDLED; |
| | 2648 | |
| | 2649 | case '=': |
| | 2650 | if (!view->full) { |
| | 2651 | view->bias = 0; |
| | 2652 | view->new_frame = 1; |
| | 2653 | } |
| | 2654 | return MSG_HANDLED; |
| | 2655 | |
| | 2656 | case '>': |
| | 2657 | if (!view->full) { |
| | 2658 | view_compute_split(view, 1); |
| | 2659 | view->new_frame = 1; |
| | 2660 | } |
| | 2661 | return MSG_HANDLED; |
| | 2662 | |
| | 2663 | case '<': |
| | 2664 | if (!view->full) { |
| | 2665 | view_compute_split(view, -1); |
| | 2666 | view->new_frame = 1; |
| | 2667 | } |
| | 2668 | return MSG_HANDLED; |
| | 2669 | |
| | 2670 | case 'c': |
| | 2671 | view->show_cr ^= 1; |
| | 2672 | return MSG_HANDLED; |
| | 2673 | |
| | 2674 | case 'h': |
| | 2675 | view->show_hdiff ^= 1; |
| | 2676 | return MSG_HANDLED; |
| | 2677 | |
| | 2678 | case '2': |
| | 2679 | case '3': |
| | 2680 | case '4': |
| | 2681 | case '8': |
| | 2682 | view->tab_size = c - '0'; |
| | 2683 | return MSG_HANDLED; |
| | 2684 | |
| | 2685 | case XCTRL('u'): |
| | 2686 | view->ord ^= 1; |
| | 2687 | return MSG_HANDLED; |
| | 2688 | |
| | 2689 | case XCTRL('r'): |
| | 2690 | view_redo(view); |
| | 2691 | return MSG_HANDLED; |
| | 2692 | |
| | 2693 | case 'n': |
| | 2694 | view->skip_rows = find_next_hunk(&view->a[0], view->skip_rows); |
| | 2695 | return MSG_HANDLED; |
| | 2696 | |
| | 2697 | case 'p': |
| | 2698 | view->skip_rows = find_prev_hunk(&view->a[0], view->skip_rows); |
| | 2699 | return MSG_HANDLED; |
| | 2700 | |
| | 2701 | case 'g': |
| | 2702 | case 'G': |
| | 2703 | view_goto_cmd(view, c == 'G'); |
| | 2704 | return MSG_HANDLED; |
| | 2705 | |
| | 2706 | case KEY_BACKSPACE: |
| | 2707 | view->last_found = -1; |
| | 2708 | return MSG_HANDLED; |
| | 2709 | |
| | 2710 | case KEY_F(4): |
| | 2711 | view_edit(view, view->ord); |
| | 2712 | return MSG_HANDLED; |
| | 2713 | |
| | 2714 | case KEY_F(14): |
| | 2715 | view_edit(view, view->ord ^ 1); |
| | 2716 | return MSG_HANDLED; |
| | 2717 | |
| | 2718 | case KEY_F(17): |
| | 2719 | view_search(view, 1); |
| | 2720 | return MSG_HANDLED; |
| | 2721 | |
| | 2722 | case KEY_HOME: |
| | 2723 | case KEY_M_CTRL | KEY_PPAGE: |
| | 2724 | view->skip_rows = 0; |
| | 2725 | return MSG_HANDLED; |
| | 2726 | |
| | 2727 | case KEY_END: |
| | 2728 | case KEY_M_CTRL | KEY_NPAGE: |
| | 2729 | view->skip_rows = view->a[0].len - 1; |
| | 2730 | return MSG_HANDLED; |
| | 2731 | |
| | 2732 | case KEY_UP: |
| | 2733 | view->skip_rows--; |
| | 2734 | return MSG_HANDLED; |
| | 2735 | |
| | 2736 | case KEY_DOWN: |
| | 2737 | view->skip_rows++; |
| | 2738 | return MSG_HANDLED; |
| | 2739 | |
| | 2740 | case KEY_NPAGE: |
| | 2741 | view->skip_rows += view->height - 2; |
| | 2742 | return MSG_HANDLED; |
| | 2743 | |
| | 2744 | case KEY_PPAGE: |
| | 2745 | view->skip_rows -= view->height - 2; |
| | 2746 | return MSG_HANDLED; |
| | 2747 | |
| | 2748 | case KEY_LEFT: |
| | 2749 | view->skip_cols--; |
| | 2750 | return MSG_HANDLED; |
| | 2751 | |
| | 2752 | case KEY_RIGHT: |
| | 2753 | view->skip_cols++; |
| | 2754 | return MSG_HANDLED; |
| | 2755 | |
| | 2756 | case KEY_M_CTRL | KEY_LEFT: |
| | 2757 | view->skip_cols -= 8; |
| | 2758 | return MSG_HANDLED; |
| | 2759 | |
| | 2760 | case KEY_M_CTRL | KEY_RIGHT: |
| | 2761 | view->skip_cols += 8; |
| | 2762 | return MSG_HANDLED; |
| | 2763 | |
| | 2764 | case XCTRL('a'): |
| | 2765 | view->skip_cols = 0; |
| | 2766 | return MSG_HANDLED; |
| | 2767 | |
| | 2768 | case XCTRL('o'): |
| | 2769 | view_other_cmd(); |
| | 2770 | return MSG_HANDLED; |
| | 2771 | |
| | 2772 | case 'q': |
| | 2773 | case XCTRL('g'): |
| | 2774 | case ESC_CHAR: |
| | 2775 | view->view_quit = 1; |
| | 2776 | return MSG_HANDLED; |
| | 2777 | } |
| | 2778 | |
| | 2779 | /* Key not used */ |
| | 2780 | return MSG_NOT_HANDLED; |
| | 2781 | } |
| | 2782 | |
| | 2783 | |
| | 2784 | static cb_ret_t |
| | 2785 | view_callback (Widget *w, widget_msg_t msg, int parm) |
| | 2786 | { |
| | 2787 | cb_ret_t i; |
| | 2788 | WDiff *view = (WDiff *)w; |
| | 2789 | Dlg_head *h = view->widget.parent; |
| | 2790 | |
| | 2791 | switch (msg) { |
| | 2792 | case WIDGET_INIT: |
| | 2793 | view_labels(view); |
| | 2794 | return MSG_HANDLED; |
| | 2795 | |
| | 2796 | case WIDGET_DRAW: |
| | 2797 | view->new_frame = 1; |
| | 2798 | view_update(view); |
| | 2799 | return MSG_HANDLED; |
| | 2800 | |
| | 2801 | case WIDGET_CURSOR: |
| | 2802 | return MSG_HANDLED; |
| | 2803 | |
| | 2804 | case WIDGET_KEY: |
| | 2805 | i = view_handle_key((WDiff *)view, parm); |
| | 2806 | if (view->view_quit) |
| | 2807 | dlg_stop(h); |
| | 2808 | else { |
| | 2809 | view_update(view); |
| | 2810 | } |
| | 2811 | return i; |
| | 2812 | |
| | 2813 | case WIDGET_IDLE: |
| | 2814 | return MSG_HANDLED; |
| | 2815 | |
| | 2816 | case WIDGET_FOCUS: |
| | 2817 | view_labels(view); |
| | 2818 | return MSG_HANDLED; |
| | 2819 | |
| | 2820 | case WIDGET_DESTROY: |
| | 2821 | return MSG_HANDLED; |
| | 2822 | |
| | 2823 | default: |
| | 2824 | return default_proc(msg, parm); |
| | 2825 | } |
| | 2826 | } |
| | 2827 | |
| | 2828 | |
| | 2829 | static void |
| | 2830 | view_adjust_size (Dlg_head *h) |
| | 2831 | { |
| | 2832 | WDiff *view; |
| | 2833 | WButtonBar *bar; |
| | 2834 | |
| | 2835 | /* Look up the viewer and the buttonbar, we assume only two widgets here */ |
| | 2836 | view = (WDiff *)find_widget_type(h, view_callback); |
| | 2837 | bar = find_buttonbar(h); |
| | 2838 | widget_set_size(&view->widget, 0, 0, LINES, COLS); |
| | 2839 | widget_set_size((Widget *)bar, LINES - 1, 0, 1, COLS); |
| | 2840 | |
| | 2841 | view_compute_areas(view); |
| | 2842 | } |
| | 2843 | |
| | 2844 | |
| | 2845 | static cb_ret_t |
| | 2846 | view_dialog_callback (Dlg_head *h, dlg_msg_t msg, int parm) |
| | 2847 | { |
| | 2848 | switch (msg) { |
| | 2849 | case DLG_RESIZE: |
| | 2850 | view_adjust_size(h); |
| | 2851 | return MSG_HANDLED; |
| | 2852 | |
| | 2853 | default: |
| | 2854 | return default_dlg_callback(h, msg, parm); |
| | 2855 | } |
| | 2856 | } |
| | 2857 | |
| | 2858 | |
| | 2859 | int |
| | 2860 | diff_view (const char *file1, const char *file2, const char *label1, const char *label2) |
| | 2861 | { |
| | 2862 | int error; |
| | 2863 | WDiff *view; |
| | 2864 | WButtonBar *bar; |
| | 2865 | Dlg_head *view_dlg; |
| | 2866 | |
| | 2867 | /* Create dialog and widgets, put them on the dialog */ |
| | 2868 | view_dlg = |
| | 2869 | create_dlg(0, 0, LINES, COLS, NULL, view_dialog_callback, |
| | 2870 | "[Diff Viewer]", NULL, DLG_WANT_TAB); |
| | 2871 | |
| | 2872 | view = g_new0(WDiff, 1); |
| | 2873 | |
| | 2874 | init_widget(&view->widget, 0, 0, LINES, COLS, |
| | 2875 | (callback_fn)view_callback, |
| | 2876 | (mouse_h)view_event); |
| | 2877 | |
| | 2878 | widget_want_cursor(view->widget, 0); |
| | 2879 | |
| | 2880 | bar = buttonbar_new(1); |
| | 2881 | |
| | 2882 | add_widget(view_dlg, bar); |
| | 2883 | add_widget(view_dlg, view); |
| | 2884 | |
| | 2885 | error = view_init(view, "-a", file1, file2, label1, label2, DATA_SRC_MEM); /* XXX binary diff? */ |
| | 2886 | |
| | 2887 | /* Please note that if you add another widget, |
| | 2888 | * you have to modify view_adjust_size to |
| | 2889 | * be aware of it |
| | 2890 | */ |
| | 2891 | if (!error) { |
| | 2892 | run_dlg(view_dlg); |
| | 2893 | view_search(view, -1); |
| | 2894 | view_fini(view); |
| | 2895 | } |
| | 2896 | destroy_dlg(view_dlg); |
| | 2897 | |
| | 2898 | return error; |
| | 2899 | } |
| | 2900 | #endif |
