1 /*- 2 * Copyright (c) 2015 Hans Petter Selasky. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 * 25 * $FreeBSD$ 26 */ 27 28 #include <stdio.h> 29 #include <stdint.h> 30 #include <sys/queue.h> 31 #include <sysexits.h> 32 #include <err.h> 33 #include <fcntl.h> 34 #include <stdlib.h> 35 #include <unistd.h> 36 #include <string.h> 37 #include <ctype.h> 38 #include <signal.h> 39 40 extern char **environ; 41 42 static int opt_verbose; 43 static char *opt_diff_tool; 44 45 #define BLOCK_SIZE 4096 46 #define BLOCK_MASK 0x100 47 #define BLOCK_ADD 0x200 48 49 struct block { 50 TAILQ_ENTRY(block) entry; 51 uint32_t length; 52 uint32_t flags; 53 uint8_t *data; 54 uint8_t *mask; 55 }; 56 57 typedef TAILQ_HEAD(, block) block_head_t; 58 59 static void 60 sigpipe(int sig) 61 { 62 } 63 64 static struct block * 65 alloc_block(void) 66 { 67 struct block *pb; 68 size_t size = sizeof(*pb) + (2 * BLOCK_SIZE); 69 70 pb = malloc(size); 71 if (pb == NULL) 72 errx(EX_SOFTWARE, "Out of memory"); 73 memset(pb, 0, size); 74 pb->data = (void *)(pb + 1); 75 pb->mask = pb->data + BLOCK_SIZE; 76 pb->length = BLOCK_SIZE; 77 return (pb); 78 } 79 80 static int 81 write_block(int fd, block_head_t *ph) 82 { 83 struct block *ptr; 84 85 if (fd < 0) 86 return (-1); 87 88 TAILQ_FOREACH(ptr, ph, entry) { 89 if (write(fd, ptr->data, ptr->length) != ptr->length) 90 return (-1); 91 } 92 return (0); 93 } 94 95 static uint16_t 96 peek_block(block_head_t *pbh, uint64_t off) 97 { 98 struct block *ptr; 99 100 TAILQ_FOREACH(ptr, pbh, entry) { 101 if (off < ptr->length) 102 break; 103 off -= ptr->length; 104 } 105 if (ptr == NULL) 106 return (0); 107 return (ptr->data[off] | (ptr->mask[off] << 8)); 108 } 109 110 static void 111 set_block(block_head_t *pbh, uint64_t off, uint16_t ch) 112 { 113 struct block *ptr; 114 115 TAILQ_FOREACH(ptr, pbh, entry) { 116 if (off < ptr->length) 117 break; 118 off -= ptr->length; 119 } 120 if (ptr == NULL) 121 return; 122 ptr->data[off] = ch & 0xFF; 123 ptr->mask[off] = (ch >> 8) & 0xFF; 124 } 125 126 static uint64_t 127 size_block(block_head_t *pbh) 128 { 129 struct block *ptr; 130 uint64_t off = 0; 131 132 TAILQ_FOREACH(ptr, pbh, entry) 133 off += ptr->length; 134 return (off); 135 } 136 137 static int 138 diff_tool(block_head_t *pa, block_head_t *pb) 139 { 140 char ca[] = {"/tmp/diff.orig.XXXXXX"}; 141 char cb[] = {"/tmp/diff.styled.XXXXXX"}; 142 char cc[256]; 143 uint64_t sa; 144 uint64_t sb; 145 uint64_t s; 146 uint64_t x; 147 int fa; 148 int fb; 149 150 sa = size_block(pa); 151 sb = size_block(pb); 152 s = (sa > sb) ? sa : sb; 153 154 for (x = 0; x != s; x++) { 155 char cha = peek_block(pa, x) & 0xFF; 156 char chb = peek_block(pb, x) & 0xFF; 157 158 if (cha != chb) { 159 /* false positive */ 160 if (cha == '\n' && chb == 0 && x == sa - 1) 161 return (0); 162 break; 163 } 164 } 165 if (x == s) 166 return (0); /* identical */ 167 168 fa = mkstemp(ca); 169 fb = mkstemp(cb); 170 171 if (write_block(fa, pa) < 0 || write_block(fb, pb) < 0) { 172 close(fa); 173 close(fb); 174 unlink(ca); 175 unlink(cb); 176 err(EX_SOFTWARE, "Could not write data to temporary files"); 177 } 178 close(fa); 179 close(fb); 180 181 snprintf(cc, sizeof(cc), "%s %s %s", opt_diff_tool, ca, cb); 182 system(cc); 183 184 unlink(ca); 185 unlink(cb); 186 return (-1); 187 } 188 189 static int 190 diff_block(block_head_t *pa, block_head_t *pb) 191 { 192 uint64_t sa = size_block(pa); 193 uint64_t sb = size_block(pb); 194 uint64_t s; 195 uint64_t x; 196 uint64_t y; 197 uint64_t n; 198 199 s = (sa > sb) ? sa : sb; 200 201 for (y = x = 0; x != s; x++) { 202 char cha = peek_block(pa, x) & 0xFF; 203 char chb = peek_block(pb, x) & 0xFF; 204 205 if (cha != chb) { 206 int nonspace; 207 208 /* false positive */ 209 if (cha == '\n' && chb == 0 && x == sa - 1) 210 return (0); 211 212 n = x - y; 213 printf("Style error:\n"); 214 nonspace = 0; 215 for (n = y; n < sa; n++) { 216 char ch = peek_block(pa, n) & 0xFF; 217 218 if (nonspace && ch == '\n') 219 break; 220 printf("%c", ch); 221 if (!isspace(ch)) 222 nonspace = 1; 223 } 224 printf("\n"); 225 printf("Style corrected:\n"); 226 nonspace = 0; 227 for (n = y; n < sb; n++) { 228 char ch = peek_block(pb, n) & 0xFF; 229 230 if (nonspace && ch == '\n') 231 break; 232 printf("%c", ch); 233 if (!isspace(ch)) 234 nonspace = 1; 235 } 236 printf("\n"); 237 for (n = y; n != x; n++) { 238 if ((peek_block(pa, n) & 0xFF) == '\t') 239 printf("\t"); 240 else 241 printf(" "); 242 } 243 printf("^ %sdifference%s\n", 244 (isspace(cha) || isspace(chb)) ? "whitespace " : "", 245 (x >= sa || x >= sb) ? " in the end of a block" : ""); 246 return (1); 247 } else if (cha == '\n') { 248 y = x + 1; 249 } 250 } 251 return (0); 252 } 253 254 static void 255 free_block(block_head_t *pbh) 256 { 257 struct block *ptr; 258 259 while ((ptr = TAILQ_FIRST(pbh))) { 260 TAILQ_REMOVE(pbh, ptr, entry); 261 free(ptr); 262 } 263 } 264 265 static void 266 cmd_popen(char *command, FILE **iop) 267 { 268 char *argv[4]; 269 int pdes[4]; 270 int pid; 271 272 if (pipe(pdes) < 0) 273 goto error; 274 275 if (pipe(pdes + 2) < 0) { 276 close(pdes[0]); 277 close(pdes[1]); 278 goto error; 279 } 280 argv[0] = "sh"; 281 argv[1] = "-c"; 282 argv[2] = command; 283 argv[3] = NULL; 284 285 switch ((pid = vfork())) { 286 case -1: /* Error. */ 287 close(pdes[0]); 288 close(pdes[1]); 289 close(pdes[2]); 290 close(pdes[3]); 291 goto error; 292 case 0: /* Child. */ 293 dup2(pdes[1], STDOUT_FILENO); 294 dup2(pdes[2], STDIN_FILENO); 295 close(pdes[0]); 296 close(pdes[3]); 297 execve("/bin/sh", argv, environ); 298 exit(127); 299 default: 300 break; 301 } 302 iop[0] = fdopen(pdes[3], "w"); 303 iop[1] = fdopen(pdes[0], "r"); 304 close(pdes[1]); 305 close(pdes[2]); 306 return; 307 error: 308 iop[0] = iop[1] = NULL; 309 } 310 311 static void 312 cmd_block_process(block_head_t *pbh_in, block_head_t *pbh_out, char *cmd_str) 313 { 314 FILE *pfd[2]; 315 struct block *ptr; 316 317 TAILQ_INIT(pbh_out); 318 319 cmd_popen(cmd_str, pfd); 320 321 if (pfd[0] == NULL || pfd[1] == NULL) 322 errx(EX_SOFTWARE, "Cannot invoke command '%s'", cmd_str); 323 324 if (pbh_in != NULL) { 325 TAILQ_FOREACH(ptr, pbh_in, entry) { 326 if (fwrite(ptr->data, 1, ptr->length, pfd[0]) != ptr->length) 327 err(EX_SOFTWARE, "Cannot write all data to command '%s'", cmd_str); 328 } 329 fflush(pfd[0]); 330 } 331 fclose(pfd[0]); 332 333 while (1) { 334 int len; 335 336 ptr = alloc_block(); 337 len = fread(ptr->data, 1, BLOCK_SIZE, pfd[1]); 338 if (len <= 0) { 339 free(ptr); 340 break; 341 } 342 ptr->length = len; 343 TAILQ_INSERT_TAIL(pbh_out, ptr, entry); 344 } 345 fclose(pfd[1]); 346 } 347 348 static void 349 usage(void) 350 { 351 fprintf(stderr, 352 "indent_wrapper [-v] [-d] [-D] [-g <githash>]\n" 353 "\t" "[-s <svnrevision> ] [ -t <tool> ] [ -c <command> ]\n" 354 "\t" "-v Increase verbosity\n" 355 "\t" "-d Check output from git diff\n" 356 "\t" "-D Check output from svn diff\n" 357 "\t" "-c <cmd> Set custom command to produce diff\n" 358 "\t" "-g <hash> Check output from git hash\n" 359 "\t" "-s <rev> Check output from svn revision\n" 360 "\t" "-t <tool> Launch external diff tool\n" 361 "\n" 362 "Examples:\n" 363 "\t" "indent_wrapper -D\n" 364 "\t" "indent_wrapper -D -t meld\n" 365 "\t" "indent_wrapper -D -t \"diff -u\"\n"); 366 exit(EX_SOFTWARE); 367 } 368 369 int 370 main(int argc, char **argv) 371 { 372 block_head_t diff_head; 373 block_head_t diff_a_head; 374 block_head_t diff_b_head; 375 block_head_t indent_in_head; 376 block_head_t indent_out_head; 377 struct block *p1 = NULL; 378 struct block *p2 = NULL; 379 uint64_t size; 380 uint64_t x; 381 uint64_t y1 = 0; 382 uint64_t y2 = 0; 383 int recurse = 0; 384 int inside_string = 0; 385 int escape_char = 0; 386 int do_parse = 0; 387 char cmdbuf[256]; 388 uint16_t ch; 389 uint16_t chn; 390 int c; 391 int retval = 0; 392 393 signal(SIGPIPE, &sigpipe); 394 395 cmdbuf[0] = 0; 396 397 while ((c = getopt(argc, argv, "dDvg:s:c:ht:")) != -1) { 398 switch (c) { 399 case 'v': 400 opt_verbose++; 401 break; 402 case 't': 403 opt_diff_tool = optarg; 404 break; 405 case 'g': 406 snprintf(cmdbuf, sizeof(cmdbuf), "git show -U1000000 %s", optarg); 407 break; 408 case 'd': 409 snprintf(cmdbuf, sizeof(cmdbuf), "git diff -U1000000"); 410 break; 411 case 'D': 412 snprintf(cmdbuf, sizeof(cmdbuf), "svn diff --diff-cmd=diff -x -U1000000"); 413 break; 414 case 's': 415 snprintf(cmdbuf, sizeof(cmdbuf), "svn diff --diff-cmd=diff -x -U1000000 -r %s", optarg); 416 break; 417 case 'c': 418 snprintf(cmdbuf, sizeof(cmdbuf), "%s", optarg); 419 break; 420 default: 421 usage(); 422 } 423 } 424 if (cmdbuf[0] == 0) 425 usage(); 426 427 cmd_block_process(NULL, &diff_head, cmdbuf); 428 429 TAILQ_INIT(&diff_a_head); 430 TAILQ_INIT(&diff_b_head); 431 432 size = size_block(&diff_head); 433 p1 = alloc_block(); 434 y1 = 0; 435 p2 = alloc_block(); 436 y2 = 0; 437 438 for (x = 0; x < size;) { 439 ch = peek_block(&diff_head, x); 440 switch (ch & 0xFF) { 441 case '+': 442 if (ch == peek_block(&diff_head, x + 1) && 443 ch == peek_block(&diff_head, x + 2) && 444 ' ' == (peek_block(&diff_head, x + 3) & 0xFF)) 445 goto parse_filename; 446 if (do_parse == 0) 447 break; 448 for (x++; x != size; x++) { 449 ch = peek_block(&diff_head, x); 450 p1->mask[y1] = BLOCK_ADD >> 8; 451 p1->data[y1++] = ch; 452 if (y1 == BLOCK_SIZE) { 453 TAILQ_INSERT_TAIL(&diff_a_head, p1, entry); 454 p1 = alloc_block(); 455 y1 = 0; 456 } 457 if ((ch & 0xFF) == '\n') 458 break; 459 } 460 break; 461 case '-': 462 if (ch == peek_block(&diff_head, x + 1) && 463 ch == peek_block(&diff_head, x + 2) && 464 ' ' == (peek_block(&diff_head, x + 3) & 0xFF)) 465 goto parse_filename; 466 if (do_parse == 0) 467 break; 468 for (x++; x != size; x++) { 469 ch = peek_block(&diff_head, x); 470 p2->data[y2++] = ch; 471 if (y2 == BLOCK_SIZE) { 472 TAILQ_INSERT_TAIL(&diff_b_head, p2, entry); 473 p2 = alloc_block(); 474 y2 = 0; 475 } 476 if ((ch & 0xFF) == '\n') 477 break; 478 } 479 break; 480 case ' ': 481 if (do_parse == 0) 482 break; 483 for (x++; x != size; x++) { 484 ch = peek_block(&diff_head, x); 485 p1->data[y1++] = ch; 486 if (y1 == BLOCK_SIZE) { 487 TAILQ_INSERT_TAIL(&diff_a_head, p1, entry); 488 p1 = alloc_block(); 489 y1 = 0; 490 } 491 p2->data[y2++] = ch; 492 if (y2 == BLOCK_SIZE) { 493 TAILQ_INSERT_TAIL(&diff_b_head, p2, entry); 494 p2 = alloc_block(); 495 y2 = 0; 496 } 497 if ((ch & 0xFF) == '\n') 498 break; 499 } 500 break; 501 parse_filename: 502 for (x += 3; x != size; x++) { 503 ch = peek_block(&diff_head, x); 504 chn = peek_block(&diff_head, x + 1); 505 if ((ch & 0xFF) == '.') { 506 /* only accept .c and .h files */ 507 do_parse = ((chn & 0xFF) == 'c' || (chn & 0xFF) == 'h'); 508 } 509 if ((ch & 0xFF) == '\n') 510 break; 511 } 512 default: 513 break; 514 } 515 /* skip till end of line */ 516 for (; x < size; x++) { 517 ch = peek_block(&diff_head, x); 518 if ((ch & 0xFF) == '\n') { 519 x++; 520 break; 521 } 522 } 523 } 524 p1->length = y1; 525 p2->length = y2; 526 TAILQ_INSERT_TAIL(&diff_a_head, p1, entry); 527 TAILQ_INSERT_TAIL(&diff_b_head, p2, entry); 528 529 /* first pass - verify input */ 530 size = size_block(&diff_a_head); 531 for (x = 0; x != size; x++) { 532 ch = peek_block(&diff_a_head, x) & 0xFF; 533 if (!(ch & 0x80) && ch != '\t' && ch != '\r' && ch != '\n' && 534 ch != ' ' && !isprint(ch)) 535 errx(EX_SOFTWARE, "Non printable characters are not allowed: '%c'", ch); 536 else if (ch & 0x80) { 537 set_block(&diff_a_head, x, ch | BLOCK_MASK); 538 } 539 } 540 541 /* second pass - identify all comments */ 542 for (x = 0; x < size; x++) { 543 ch = peek_block(&diff_a_head, x); 544 chn = peek_block(&diff_a_head, x + 1); 545 if ((ch & 0xFF) == '/' && (chn & 0xFF) == '/') { 546 set_block(&diff_a_head, x, ch | BLOCK_MASK); 547 set_block(&diff_a_head, x + 1, chn | BLOCK_MASK); 548 for (x += 2; x < size; x++) { 549 ch = peek_block(&diff_a_head, x); 550 if ((ch & 0xFF) == '\n') 551 break; 552 set_block(&diff_a_head, x, ch | BLOCK_MASK); 553 } 554 } else if ((ch & 0xFF) == '/' && (chn & 0xFF) == '*') { 555 set_block(&diff_a_head, x, ch | BLOCK_MASK); 556 set_block(&diff_a_head, x + 1, chn | BLOCK_MASK); 557 for (x += 2; x < size; x++) { 558 ch = peek_block(&diff_a_head, x); 559 chn = peek_block(&diff_a_head, x + 1); 560 if ((ch & 0xFF) == '*' && (chn & 0xFF) == '/') { 561 set_block(&diff_a_head, x, ch | BLOCK_MASK); 562 set_block(&diff_a_head, x + 1, chn | BLOCK_MASK); 563 x++; 564 break; 565 } 566 set_block(&diff_a_head, x, ch | BLOCK_MASK); 567 } 568 } 569 } 570 571 /* third pass - identify preprocessor tokens and strings */ 572 for (x = 0; x < size; x++) { 573 ch = peek_block(&diff_a_head, x); 574 if (ch & BLOCK_MASK) 575 continue; 576 if (inside_string == 0 && (ch & 0xFF) == '#') { 577 int skip_newline = 0; 578 579 set_block(&diff_a_head, x, ch | BLOCK_MASK); 580 for (x++; x < size; x++) { 581 ch = peek_block(&diff_a_head, x); 582 if ((ch & 0xFF) == '\n') { 583 if (!skip_newline) 584 break; 585 skip_newline = 0; 586 } 587 if (ch & BLOCK_MASK) 588 continue; 589 if ((ch & 0xFF) == '\\') 590 skip_newline = 1; 591 set_block(&diff_a_head, x, ch | BLOCK_MASK); 592 } 593 } 594 if ((ch & 0xFF) == '"' || (ch & 0xFF) == '\'') { 595 if (inside_string == 0) { 596 inside_string = (ch & 0xFF); 597 } else { 598 if (escape_char == 0 && inside_string == (ch & 0xFF)) 599 inside_string = 0; 600 } 601 escape_char = 0; 602 set_block(&diff_a_head, x, ch | BLOCK_MASK); 603 } else if (inside_string != 0) { 604 if ((ch & 0xFF) == '\\') 605 escape_char = !escape_char; 606 else 607 escape_char = 0; 608 set_block(&diff_a_head, x, ch | BLOCK_MASK); 609 } 610 } 611 612 /* fourth pass - identify function blocks */ 613 if (opt_verbose > 0) { 614 chn = peek_block(&diff_a_head, x); 615 printf("L%02d%c|", recurse, 616 (chn & BLOCK_ADD) ? '+' : ' '); 617 } 618 for (x = 0; x < size; x++) { 619 ch = peek_block(&diff_a_head, x); 620 if (opt_verbose > 0) { 621 printf("%c", ch & 0xFF); 622 if ((ch & 0xFF) == '\n') { 623 chn = peek_block(&diff_a_head, x + 1); 624 printf("L%02d%c|", recurse, 625 (chn & BLOCK_ADD) ? '+' : ' '); 626 } 627 } 628 if (ch & BLOCK_MASK) 629 continue; 630 switch (ch & 0xFF) { 631 case '{': 632 case '(': 633 recurse++; 634 break; 635 default: 636 break; 637 } 638 if (recurse != 0) 639 set_block(&diff_a_head, x, ch | BLOCK_MASK); 640 switch (ch & 0xFF) { 641 case '}': 642 case ')': 643 recurse--; 644 break; 645 default: 646 break; 647 } 648 } 649 if (opt_verbose > 0) 650 printf("\n"); 651 if (recurse != 0) 652 errx(EX_SOFTWARE, "Unbalanced parenthesis"); 653 if (inside_string != 0) 654 errx(EX_SOFTWARE, "String without end"); 655 656 /* fifth pass - on the same line statements */ 657 for (x = 0; x < size; x++) { 658 ch = peek_block(&diff_a_head, x); 659 if (ch & BLOCK_MASK) 660 continue; 661 switch (ch & 0xFF) { 662 case '\n': 663 break; 664 default: 665 set_block(&diff_a_head, x, ch | BLOCK_MASK); 666 break; 667 } 668 } 669 670 /* sixth pass - output relevant blocks to indent */ 671 for (y1 = x = 0; x < size; x++) { 672 ch = peek_block(&diff_a_head, x); 673 if (ch & BLOCK_ADD) { 674 TAILQ_INIT(&indent_in_head); 675 676 p2 = alloc_block(); 677 y2 = 0; 678 for (; y1 < size; y1++) { 679 ch = peek_block(&diff_a_head, y1); 680 if (y1 > x && !(ch & (BLOCK_MASK | BLOCK_ADD))) 681 break; 682 p2->data[y2++] = ch & 0xFF; 683 if (y2 == BLOCK_SIZE) { 684 TAILQ_INSERT_TAIL(&indent_in_head, p2, entry); 685 p2 = alloc_block(); 686 y2 = 0; 687 } 688 } 689 if (p2->data[y2] != '\n') 690 p2->data[y2++] = '\n'; 691 p2->length = y2; 692 TAILQ_INSERT_TAIL(&indent_in_head, p2, entry); 693 694 cmd_block_process(&indent_in_head, &indent_out_head, 695 "indent " 696 "-Tbool " 697 "-Tclass " 698 "-TFILE " 699 "-TLIST_ENTRY " 700 "-TLIST_HEAD " 701 "-TSLIST_ENTRY " 702 "-TSLIST_HEAD " 703 "-TSTAILQ_ENTRY " 704 "-TSTAILQ_HEAD " 705 "-TTAILQ_ENTRY " 706 "-TTAILQ_HEAD " 707 "-T__aligned " 708 "-T__packed " 709 "-T__unused " 710 "-T__used " 711 "-Tfd_set " 712 "-Toss_mixerinfo " 713 "-Tu_char " 714 "-Tu_int " 715 "-Tu_long " 716 "-Tu_short " 717 "-ta -st -bad -bap -nbbb -nbc -br -nbs " 718 "-c41 -cd41 -cdb -ce -ci4 -cli0 -d0 -di8 -ndj -ei -nfc1 " 719 "-nfcb -i8 -ip8 -l79 -lc77 -ldi0 -nlp -npcs -psl -sc " 720 "-nsob -nv " 721 " | " 722 "sed " 723 "-e 's/_HEAD [(]/_HEAD(/g' " 724 "-e 's/_ENTRY [(]/_ENTRY(/g' " 725 "-e 's/\t__aligned/ __aligned/g' " 726 "-e 's/\t__packed/ __packed/g' " 727 "-e 's/\t__unused/ __unused/g' " 728 "-e 's/\t__used/ __used/g' " 729 "-e 's/^#define /#define\t/g'"); 730 731 if (opt_diff_tool != NULL) { 732 if (diff_tool(&indent_in_head, &indent_out_head)) 733 retval = 1; 734 } else { 735 if (diff_block(&indent_in_head, &indent_out_head)) 736 retval = 1; 737 } 738 free_block(&indent_in_head); 739 free_block(&indent_out_head); 740 x = y1; 741 } else if (!(ch & BLOCK_MASK)) { 742 y1 = x + 1; 743 } 744 } 745 return (retval); 746 } 747