gitweb.dragonflybsd.org Git - dragonfly.git/blob

1 /* GNU DIFF entry routine.

4 This file is part of GNU DIFF.

6 GNU DIFF is free software; you can redistribute it and/or modify

7 it under the terms of the GNU General Public License as published by

8 the Free Software Foundation; either version 2, or (at your option)

9 any later version.

11 GNU DIFF is distributed in the hope that it will be useful,

12 but WITHOUT ANY WARRANTY; without even the implied warranty of

13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14 GNU General Public License for more details.

16 */

18 /* GNU DIFF was written by Mike Haertel, David Hayes,

19 Richard Stallman, Len Tower, and Paul Eggert. */

21 #define GDIFF_MAIN

22 #include "diff.h"

23 #include <signal.h>

24 #include "error.h"

25 #include "getopt.h"

27 #ifdef HAVE_FNMATCH

28 # include <fnmatch.h> /* This is supposed to be available on Posix systems */

29 #else /* HAVE_FNMATCH */

30 # include "fnmatch.h" /* Our substitute */

31 #endif /* HAVE_FNMATCH */

33 #ifndef DEFAULT_WIDTH

34 #define DEFAULT_WIDTH 130

35 #endif

37 #ifndef GUTTER_WIDTH_MINIMUM

38 #define GUTTER_WIDTH_MINIMUM 3

39 #endif

41 /* diff.c has a real initialize_main function. */

42 #ifdef initialize_main

43 #undef initialize_main

44 #endif

46 static char const *filetype PARAMS((struct stat const *));

47 static char *option_list PARAMS((char **, int));

48 static int add_exclude_file PARAMS((char const *));

49 static int ck_atoi PARAMS((char const *, int *));

50 static int compare_files PARAMS((char const *, char const *, char const *, char const *, int));

51 static int specify_format PARAMS((char **, char *));

52 static void add_exclude PARAMS((char const *));

53 static void add_regexp PARAMS((struct regexp_list **, char const *));

54 static void specify_style PARAMS((enum output_style));

55 static int try_help PARAMS((char const *));

56 static void check_output PARAMS((FILE *));

57 static void usage PARAMS((void));

58 static void initialize_main PARAMS((int *, char ***));

60 /* Nonzero for -r: if comparing two directories,

61 compare their common subdirectories recursively. */

63 static int recursive;

65 /* For debugging: don't do discard_confusing_lines. */

67 int no_discards;

69 #if HAVE_SETMODE

70 /* I/O mode: nonzero only if using binary input/output. */

71 static int binary_I_O;

72 #endif

74 /* Return a string containing the command options with which diff was invoked.

75 Spaces appear between what were separate ARGV-elements.

76 There is a space at the beginning but none at the end.

77 If there were no options, the result is an empty string.

79 Arguments: OPTIONVEC, a vector containing separate ARGV-elements, and COUNT,

80 the length of that vector. */

82 static char *

83 option_list (optionvec, count)

84 char **optionvec; /* Was `vector', but that collides on Alliant. */

85 int count;

86 {

87 int i;

88 size_t length = 0;

89 char *result;

91 for (i = 0; i < count; i++)

92 length += strlen (optionvec[i]) + 1;

94 result = xmalloc (length + 1);

95 result[0] = 0;

97 for (i = 0; i < count; i++)

98 {

99 strcat (result, " ");

100 strcat (result, optionvec[i]);

101 }

102

103 return result;

104 }

105 \f

106 /* Convert STR to a positive integer, storing the result in *OUT.

107 If STR is not a valid integer, return -1 (otherwise 0). */

108 static int

109 ck_atoi (str, out)

110 char const *str;

111 int *out;

112 {

113 char const *p;

114 for (p = str; *p; p++)

115 if (*p < '0' || *p > '9')

116 return -1;

117

118 *out = atoi (optarg);

119 return 0;

120 }

121 \f

122 /* Keep track of excluded file name patterns. */

123

124 static char const **exclude;

125 static int exclude_alloc, exclude_count;

126

127 int

128 excluded_filename (f)

129 char const *f;

130 {

131 int i;

132 for (i = 0; i < exclude_count; i++)

133 if (fnmatch (exclude[i], f, 0) == 0)

134 return 1;

135 return 0;

136 }

137

138 static void

139 add_exclude (pattern)

140 char const *pattern;

141 {

142 if (exclude_alloc <= exclude_count)

143 exclude = (char const **)

144 (exclude_alloc == 0

145 ? xmalloc ((exclude_alloc = 64) * sizeof (*exclude))

146 : xrealloc (exclude, (exclude_alloc *= 2) * sizeof (*exclude)));

147

148 exclude[exclude_count++] = pattern;

149 }

150

151 static int

152 add_exclude_file (name)

153 char const *name;

154 {

155 struct file_data f;

156 char *p, *q, *lim;

157

158 f.name = optarg;

159 f.desc = (strcmp (optarg, "-") == 0

160 ? STDIN_FILENO

161 : open (optarg, O_RDONLY, 0));

162 if (f.desc < 0 || fstat (f.desc, &f.stat) != 0)

163 return -1;

164

165 sip (&f, 1);

166 slurp (&f);

167

168 for (p = f.buffer, lim = p + f.buffered_chars; p < lim; p = q)

169 {

170 q = (char *) memchr (p, '\n', lim - p);

171 if (!q)

172 q = lim;

173 *q++ = 0;

174 add_exclude (p);

175 }

176

177 return close (f.desc);

178 }

179 \f

180 /* The numbers 129- that appear in the fourth element of some entries

181 tell the big switch in `diff_run' how to process those options. */

182

183 static struct option const longopts[] =

184 {

185 {"ignore-blank-lines", 0, 0, 'B'},

186 {"context", 2, 0, 'C'},

187 {"ifdef", 1, 0, 'D'},

188 {"show-function-line", 1, 0, 'F'},

189 {"speed-large-files", 0, 0, 'H'},

190 {"ignore-matching-lines", 1, 0, 'I'},

191 {"label", 1, 0, 'L'},

192 {"file-label", 1, 0, 'L'}, /* An alias, no longer recommended */

193 {"new-file", 0, 0, 'N'},

194 {"entire-new-file", 0, 0, 'N'}, /* An alias, no longer recommended */

195 {"unidirectional-new-file", 0, 0, 'P'},

196 {"starting-file", 1, 0, 'S'},

197 {"initial-tab", 0, 0, 'T'},

198 {"width", 1, 0, 'W'},

199 {"text", 0, 0, 'a'},

200 {"ascii", 0, 0, 'a'}, /* An alias, no longer recommended */

201 {"ignore-space-change", 0, 0, 'b'},

202 {"minimal", 0, 0, 'd'},

203 {"ed", 0, 0, 'e'},

204 {"forward-ed", 0, 0, 'f'},

205 {"ignore-case", 0, 0, 'i'},

206 {"paginate", 0, 0, 'l'},

207 {"print", 0, 0, 'l'}, /* An alias, no longer recommended */

208 {"rcs", 0, 0, 'n'},

209 {"show-c-function", 0, 0, 'p'},

210 {"brief", 0, 0, 'q'},

211 {"recursive", 0, 0, 'r'},

212 {"report-identical-files", 0, 0, 's'},

213 {"expand-tabs", 0, 0, 't'},

214 {"version", 0, 0, 'v'},

215 {"ignore-all-space", 0, 0, 'w'},

216 {"exclude", 1, 0, 'x'},

217 {"exclude-from", 1, 0, 'X'},

218 {"side-by-side", 0, 0, 'y'},

219 {"unified", 2, 0, 'U'},

220 {"left-column", 0, 0, 129},

221 {"suppress-common-lines", 0, 0, 130},

222 {"sdiff-merge-assist", 0, 0, 131},

223 {"old-line-format", 1, 0, 132},

224 {"new-line-format", 1, 0, 133},

225 {"unchanged-line-format", 1, 0, 134},

226 {"line-format", 1, 0, 135},

227 {"old-group-format", 1, 0, 136},

228 {"new-group-format", 1, 0, 137},

229 {"unchanged-group-format", 1, 0, 138},

230 {"changed-group-format", 1, 0, 139},

231 {"horizon-lines", 1, 0, 140},

232 {"help", 0, 0, 141},

233 {"binary", 0, 0, 142},

234 {0, 0, 0, 0}

235 };

236

237

238

239 int

240 diff_run (argc, argv, out, callbacks_arg)

241 int argc;

242 char *argv[];

243 const char *out;

244 const struct diff_callbacks *callbacks_arg;

245 {

246 int val;

247 int c;

248 int prev = -1;

249 int width = DEFAULT_WIDTH;

250 int show_c_function = 0;

251 int optind_old;

252 int opened_file = 0;

253

254 callbacks = callbacks_arg;

255

256 /* Do our initializations. */

257 initialize_main (&argc, &argv);

258 optind_old = optind;

259 optind = 0;

260

261 /* Set the jump buffer, so that diff may abort execution without

262 terminating the process. */

263 val = setjmp (diff_abort_buf);

264 if (val != 0)

265 {

266 optind = optind_old;

267 if (opened_file)

268 fclose (outfile);

269 return val;

270 }

271

272 /* Decode the options. */

273 while ((c = getopt_long (argc, argv,

274 "0123456789abBcC:dD:efF:hHiI:lL:nNpPqrsS:tTuU:vwW:x:X:y",

275 longopts, 0)) != EOF)

276 {

277 switch (c)

278 {

279 /* All digits combine in decimal to specify the context-size. */

280 case '1':

281 case '2':

282 case '3':

283 case '4':

284 case '5':

285 case '6':

286 case '7':

287 case '8':

288 case '9':

289 case '0':

290 if (context == -1)

291 context = 0;

292 /* If a context length has already been specified,

293 more digits allowed only if they follow right after the others.

294 Reject two separate runs of digits, or digits after -C. */

295 else if (prev < '0' || prev > '9')

296 fatal ("context length specified twice");

297

298 context = context * 10 + c - '0';

299 break;

300

301 case 'a':

302 /* Treat all files as text files; never treat as binary. */

303 always_text_flag = 1;

304 break;

305

306 case 'b':

307 /* Ignore changes in amount of white space. */

308 ignore_space_change_flag = 1;

309 ignore_some_changes = 1;

310 ignore_some_line_changes = 1;

311 break;

312

313 case 'B':

314 /* Ignore changes affecting only blank lines. */

315 ignore_blank_lines_flag = 1;

316 ignore_some_changes = 1;

317 break;

318

319 case 'C': /* +context[=lines] */

320 case 'U': /* +unified[=lines] */

321 if (optarg)

322 {

323 if (context >= 0)

324 fatal ("context length specified twice");

325

326 if (ck_atoi (optarg, &context))

327 fatal ("invalid context length argument");

328 }

329

330 /* Falls through. */

331 case 'c':

332 /* Make context-style output. */

333 specify_style (c == 'U' ? OUTPUT_UNIFIED : OUTPUT_CONTEXT);

334 break;

335

336 case 'd':

337 /* Don't discard lines. This makes things slower (sometimes much

338 slower) but will find a guaranteed minimal set of changes. */

339 no_discards = 1;

340 break;

341

342 case 'D':

343 /* Make merged #ifdef output. */

344 specify_style (OUTPUT_IFDEF);

345 {

346 int i, err = 0;

347 static char const C_ifdef_group_formats[] =

348 "#ifndef %s\n%%<#endif /* not %s */\n%c#ifdef %s\n%%>#endif /* %s */\n%c%%=%c#ifndef %s\n%%<#else /* %s */\n%%>#endif /* %s */\n";

349 char *b = xmalloc (sizeof (C_ifdef_group_formats)

350 + 7 * strlen(optarg) - 14 /* 7*"%s" */

351 - 8 /* 5*"%%" + 3*"%c" */);

352 sprintf (b, C_ifdef_group_formats,

353 optarg, optarg, 0,

354 optarg, optarg, 0, 0,

355 optarg, optarg, optarg);

356 for (i = 0; i < 4; i++)

357 {

358 err |= specify_format (&group_format[i], b);

359 b += strlen (b) + 1;

360 }

361 if (err)

362 diff_error ("conflicting #ifdef formats", 0, 0);

363 }

364 break;

365

366 case 'e':

367 /* Make output that is a valid `ed' script. */

368 specify_style (OUTPUT_ED);

369 break;

370

371 case 'f':

372 /* Make output that looks vaguely like an `ed' script

373 but has changes in the order they appear in the file. */

374 specify_style (OUTPUT_FORWARD_ED);

375 break;

376

377 case 'F':

378 /* Show, for each set of changes, the previous line that

379 matches the specified regexp. Currently affects only

380 context-style output. */

381 add_regexp (&function_regexp_list, optarg);

382 break;

383

384 case 'h':

385 /* Split the files into chunks of around 1500 lines

386 for faster processing. Usually does not change the result.

387

388 This currently has no effect. */

389 break;

390

391 case 'H':

392 /* Turn on heuristics that speed processing of large files

393 with a small density of changes. */

394 heuristic = 1;

395 break;

396

397 case 'i':

398 /* Ignore changes in case. */

399 ignore_case_flag = 1;

400 ignore_some_changes = 1;

401 ignore_some_line_changes = 1;

402 break;

403

404 case 'I':

405 /* Ignore changes affecting only lines that match the

406 specified regexp. */

407 add_regexp (&ignore_regexp_list, optarg);

408 ignore_some_changes = 1;

409 break;

410

411 case 'l':

412 /* Pass the output through `pr' to paginate it. */

413 paginate_flag = 1;

414 #if !defined(SIGCHLD) && defined(SIGCLD)

415 #define SIGCHLD SIGCLD

416 #endif

417 #ifdef SIGCHLD

418 /* Pagination requires forking and waiting, and

419 System V fork+wait does not work if SIGCHLD is ignored. */

420 signal (SIGCHLD, SIG_DFL);

421 #endif

422 break;

423

424 case 'L':

425 /* Specify file labels for `-c' output headers. */

426 if (!file_label[0])

427 file_label[0] = optarg;

428 else if (!file_label[1])

429 file_label[1] = optarg;

430 else

431 fatal ("too many file label options");

432 break;

433

434 case 'n':

435 /* Output RCS-style diffs, like `-f' except that each command

436 specifies the number of lines affected. */

437 specify_style (OUTPUT_RCS);

438 break;

439

440 case 'N':

441 /* When comparing directories, if a file appears only in one

442 directory, treat it as present but empty in the other. */

443 entire_new_file_flag = 1;

444 break;

445

446 case 'p':

447 /* Make context-style output and show name of last C function. */

448 show_c_function = 1;

449 add_regexp (&function_regexp_list, "^[_a-zA-Z$]");

450 break;

451

452 case 'P':

453 /* When comparing directories, if a file appears only in

454 the second directory of the two,

455 treat it as present but empty in the other. */

456 unidirectional_new_file_flag = 1;

457 break;

458

459 case 'q':

460 no_details_flag = 1;

461 break;

462

463 case 'r':

464 /* When comparing directories,

465 recursively compare any subdirectories found. */

466 recursive = 1;

467 break;

468

469 case 's':

470 /* Print a message if the files are the same. */

471 print_file_same_flag = 1;

472 break;

473

474 case 'S':

475 /* When comparing directories, start with the specified

476 file name. This is used for resuming an aborted comparison. */

477 dir_start_file = optarg;

478 break;

479

480 case 't':

481 /* Expand tabs to spaces in the output so that it preserves

482 the alignment of the input files. */

483 tab_expand_flag = 1;

484 break;

485

486 case 'T':

487 /* Use a tab in the output, rather than a space, before the

488 text of an input line, so as to keep the proper alignment

489 in the input line without changing the characters in it. */

490 tab_align_flag = 1;

491 break;

492

493 case 'u':

494 /* Output the context diff in unidiff format. */

495 specify_style (OUTPUT_UNIFIED);

496 break;

497

498 case 'v':

499 if (callbacks && callbacks->write_stdout)

500 {

501 (*callbacks->write_stdout) ("diff - GNU diffutils version ");

502 (*callbacks->write_stdout) (diff_version_string);

503 (*callbacks->write_stdout) ("\n");

504 }

505 else

506 printf ("diff - GNU diffutils version %s\n", diff_version_string);

507 return 0;

508

509 case 'w':

510 /* Ignore horizontal white space when comparing lines. */

511 ignore_all_space_flag = 1;

512 ignore_some_changes = 1;

513 ignore_some_line_changes = 1;

514 break;

515

516 case 'x':

517 add_exclude (optarg);

518 break;

519

520 case 'X':

521 if (add_exclude_file (optarg) != 0)

522 pfatal_with_name (optarg);

523 break;

524

525 case 'y':

526 /* Use side-by-side (sdiff-style) columnar output. */

527 specify_style (OUTPUT_SDIFF);

528 break;

529

530 case 'W':

531 /* Set the line width for OUTPUT_SDIFF. */

532 if (ck_atoi (optarg, &width) || width <= 0)

533 fatal ("column width must be a positive integer");

534 break;

535

536 case 129:

537 sdiff_left_only = 1;

538 break;

539

540 case 130:

541 sdiff_skip_common_lines = 1;

542 break;

543

544 case 131:

545 /* sdiff-style columns output. */

546 specify_style (OUTPUT_SDIFF);

547 sdiff_help_sdiff = 1;

548 break;

549

550 case 132:

551 case 133:

552 case 134:

553 specify_style (OUTPUT_IFDEF);

554 if (specify_format (&line_format[c - 132], optarg) != 0)

555 diff_error ("conflicting line format", 0, 0);

556 break;

557

558 case 135:

559 specify_style (OUTPUT_IFDEF);

560 {

561 int i, err = 0;

562 for (i = 0; i < sizeof (line_format) / sizeof (*line_format); i++)

563 err |= specify_format (&line_format[i], optarg);

564 if (err)

565 diff_error ("conflicting line format", 0, 0);

566 }

567 break;

568

569 case 136:

570 case 137:

571 case 138:

572 case 139:

573 specify_style (OUTPUT_IFDEF);

574 if (specify_format (&group_format[c - 136], optarg) != 0)

575 diff_error ("conflicting group format", 0, 0);

576 break;

577

578 case 140:

579 if (ck_atoi (optarg, &horizon_lines) || horizon_lines < 0)

580 fatal ("horizon must be a nonnegative integer");

581 break;

582

583 case 141:

584 usage ();

585 if (! callbacks || ! callbacks->write_stdout)

586 check_output (stdout);

587 return 0;

588

589 case 142:

590 /* Use binary I/O when reading and writing data.

591 On Posix hosts, this has no effect. */

592 #if HAVE_SETMODE

593 binary_I_O = 1;

594 # if 0

595 /* Because this code is leftover from pre-library days,

596 there is no way to set stdout back to the default mode

597 when we are done. As it turns out, I think the only

598 parts of CVS that pass out == NULL, and thus cause diff

599 to write to stdout, are "cvs diff" and "cvs rdiff". So

600 I'm not going to worry about this too much yet. */

601 setmode (STDOUT_FILENO, O_BINARY);

602 # else

603 if (out == NULL)

604 error (0, 0, "warning: did not set stdout to binary mode");

605 # endif

606 #endif

607 break;

608

609 default:

610 return try_help (0);

611 }

612 prev = c;

613 }

614

615 if (argc - optind != 2)

616 return try_help (argc - optind < 2 ? "missing operand" : "extra operand");

617

618 {

619 /*

620 * We maximize first the half line width, and then the gutter width,

621 * according to the following constraints:

622 * 1. Two half lines plus a gutter must fit in a line.

623 * 2. If the half line width is nonzero:

624 * a. The gutter width is at least GUTTER_WIDTH_MINIMUM.

625 * b. If tabs are not expanded to spaces,

626 * a half line plus a gutter is an integral number of tabs,

627 * so that tabs in the right column line up.

628 */

629 int t = tab_expand_flag ? 1 : TAB_WIDTH;

630 int off = (width + t + GUTTER_WIDTH_MINIMUM) / (2*t) * t;

631 sdiff_half_width = max (0, min (off - GUTTER_WIDTH_MINIMUM, width - off)),

632 sdiff_column2_offset = sdiff_half_width ? off : width;

633 }

634

635 if (show_c_function && output_style != OUTPUT_UNIFIED)

636 specify_style (OUTPUT_CONTEXT);

637

638 if (output_style != OUTPUT_CONTEXT && output_style != OUTPUT_UNIFIED)

639 context = 0;

640 else if (context == -1)

641 /* Default amount of context for -c. */

642 context = 3;

643

644 if (output_style == OUTPUT_IFDEF)

645 {

646 /* Format arrays are char *, not char const *,

647 because integer formats are temporarily modified.

648 But it is safe to assign a constant like "%=" to a format array,

649 since "%=" does not format any integers. */

650 int i;

651 for (i = 0; i < sizeof (line_format) / sizeof (*line_format); i++)

652 if (!line_format[i])

653 line_format[i] = "%l\n";

654 if (!group_format[OLD])

655 group_format[OLD]

656 = group_format[UNCHANGED] ? group_format[UNCHANGED] : "%<";

657 if (!group_format[NEW])

658 group_format[NEW]

659 = group_format[UNCHANGED] ? group_format[UNCHANGED] : "%>";

660 if (!group_format[UNCHANGED])

661 group_format[UNCHANGED] = "%=";

662 if (!group_format[CHANGED])

663 group_format[CHANGED] = concat (group_format[OLD],

664 group_format[NEW], "");

665 }

666

667 no_diff_means_no_output =

668 (output_style == OUTPUT_IFDEF ?

669 (!*group_format[UNCHANGED]

670 || (strcmp (group_format[UNCHANGED], "%=") == 0

671 && !*line_format[UNCHANGED]))

672 : output_style == OUTPUT_SDIFF ? sdiff_skip_common_lines : 1);

673

674 switch_string = option_list (argv + 1, optind - 1);

675

676 if (callbacks && callbacks->write_output)

677 {

678 if (out != NULL)

679 {

680 diff_error ("write callback with output file", 0, 0);

681 return 2;

682 }

683 }

684 else

685 {

686 if (out == NULL)

687 outfile = stdout;

688 else

689 {

690 #if HAVE_SETMODE

691 /* A diff which is full of ^Z and such isn't going to work

692 very well in text mode. */

693 if (binary_I_O)

694 outfile = fopen (out, "wb");

695 else

696 #endif

697 outfile = fopen (out, "w");

698 if (outfile == NULL)

699 {

700 perror_with_name ("could not open output file");

701 return 2;

702 }

703 opened_file = 1;

704 }

705 }

706

707 val = compare_files (0, argv[optind], 0, argv[optind + 1], 0);

708

709 /* Print any messages that were saved up for last. */

710 print_message_queue ();

711

712 free (switch_string);

713

714 optind = optind_old;

715

716 if (! callbacks || ! callbacks->write_output)

717 check_output (outfile);

718

719 if (opened_file)

720 if (fclose (outfile) != 0)

721 perror_with_name ("close error on output file");

722

723 return val;

724 }

725

726 /* Add the compiled form of regexp PATTERN to REGLIST. */

727

728 static void

729 add_regexp (reglist, pattern)

730 struct regexp_list **reglist;

731 char const *pattern;

732 {

733 struct regexp_list *r;

734 char const *m;

735

736 r = (struct regexp_list *) xmalloc (sizeof (*r));

737 bzero (r, sizeof (*r));

738 r->buf.fastmap = xmalloc (256);

739 m = re_compile_pattern (pattern, strlen (pattern), &r->buf);

740 if (m != 0)

741 diff_error ("%s: %s", pattern, m);

742

743 /* Add to the start of the list, since it's easier than the end. */

744 r->next = *reglist;

745 *reglist = r;

746 }

747

748 static int

749 try_help (reason)

750 char const *reason;

751 {

752 if (reason)

753 diff_error ("%s", reason, 0);

754 diff_error ("Try `%s --help' for more information.", diff_program_name, 0);

755 return 2;

756 }

757

758 static void

759 check_output (file)

760 FILE *file;

761 {

762 if (ferror (file) || fflush (file) != 0)

763 fatal ("write error");

764 }

765

766 static char const * const option_help[] = {

767 "-i --ignore-case Consider upper- and lower-case to be the same.",

768 "-w --ignore-all-space Ignore all white space.",

769 "-b --ignore-space-change Ignore changes in the amount of white space.",

770 "-B --ignore-blank-lines Ignore changes whose lines are all blank.",

771 "-I RE --ignore-matching-lines=RE Ignore changes whose lines all match RE.",

772 #if HAVE_SETMODE

773 "--binary Read and write data in binary mode.",

774 #endif

775 "-a --text Treat all files as text.\n",

776 "-c -C NUM --context[=NUM] Output NUM (default 2) lines of copied context.",

777 "-u -U NUM --unified[=NUM] Output NUM (default 2) lines of unified context.",

778 " -NUM Use NUM context lines.",

779 " -L LABEL --label LABEL Use LABEL instead of file name.",

780 " -p --show-c-function Show which C function each change is in.",

781 " -F RE --show-function-line=RE Show the most recent line matching RE.",

782 "-q --brief Output only whether files differ.",

783 "-e --ed Output an ed script.",

784 "-n --rcs Output an RCS format diff.",

785 "-y --side-by-side Output in two columns.",

786 " -W NUM --width=NUM Output at most NUM (default 130) characters per line.",

787 " --left-column Output only the left column of common lines.",

788 " --suppress-common-lines Do not output common lines.",

789 "-DNAME --ifdef=NAME Output merged file to show `#ifdef NAME' diffs.",

790 "--GTYPE-group-format=GFMT Similar, but format GTYPE input groups with GFMT.",

791 "--line-format=LFMT Similar, but format all input lines with LFMT.",

792 "--LTYPE-line-format=LFMT Similar, but format LTYPE input lines with LFMT.",

793 " LTYPE is `old', `new', or `unchanged'. GTYPE is LTYPE or `changed'.",

794 " GFMT may contain:",

795 " %< lines from FILE1",

796 " %> lines from FILE2",

797 " %= lines common to FILE1 and FILE2",

798 " %[-][WIDTH][.[PREC]]{doxX}LETTER printf-style spec for LETTER",

799 " LETTERs are as follows for new group, lower case for old group:",

800 " F first line number",

801 " L last line number",

802 " N number of lines = L-F+1",

803 " E F-1",

804 " M L+1",

805 " LFMT may contain:",

806 " %L contents of line",

807 " %l contents of line, excluding any trailing newline",

808 " %[-][WIDTH][.[PREC]]{doxX}n printf-style spec for input line number",

809 " Either GFMT or LFMT may contain:",

810 " %% %",

811 " %c'C' the single character C",

812 " %c'\\OOO' the character with octal code OOO\n",

813 "-l --paginate Pass the output through `pr' to paginate it.",

814 "-t --expand-tabs Expand tabs to spaces in output.",

815 "-T --initial-tab Make tabs line up by prepending a tab.\n",

816 "-r --recursive Recursively compare any subdirectories found.",

817 "-N --new-file Treat absent files as empty.",

818 "-P --unidirectional-new-file Treat absent first files as empty.",

819 "-s --report-identical-files Report when two files are the same.",

820 "-x PAT --exclude=PAT Exclude files that match PAT.",

821 "-X FILE --exclude-from=FILE Exclude files that match any pattern in FILE.",

822 "-S FILE --starting-file=FILE Start with FILE when comparing directories.\n",

823 "--horizon-lines=NUM Keep NUM lines of the common prefix and suffix.",

824 "-d --minimal Try hard to find a smaller set of changes.",

825 "-H --speed-large-files Assume large files and many scattered small changes.\n",

826 "-v --version Output version info.",

827 "--help Output this help.",

828 0

829 };

830

831 static void

832 usage ()

833 {

834 char const * const *p;

835

836 if (callbacks && callbacks->write_stdout)

837 {

838 (*callbacks->write_stdout) ("Usage: ");

839 (*callbacks->write_stdout) (diff_program_name);

840 (*callbacks->write_stdout) (" [OPTION]... FILE1 FILE2\n\n");

841 for (p = option_help; *p; p++)

842 {

843 (*callbacks->write_stdout) (" ");

844 (*callbacks->write_stdout) (*p);

845 (*callbacks->write_stdout) ("\n");

846 }

847 (*callbacks->write_stdout)

848 ("\nIf FILE1 or FILE2 is `-', read standard input.\n");

849 }

850 else

851 {

852 printf ("Usage: %s [OPTION]... FILE1 FILE2\n\n", diff_program_name);

853 for (p = option_help; *p; p++)

854 printf (" %s\n", *p);

855 printf ("\nIf FILE1 or FILE2 is `-', read standard input.\n");

856 }

857 }

858

859 static int

860 specify_format (var, value)

861 char **var;

862 char *value;

863 {

864 int err = *var ? strcmp (*var, value) : 0;

865 *var = value;

866 return err;

867 }

868

869 static void

870 specify_style (style)

871 enum output_style style;

872 {

873 if (output_style != OUTPUT_NORMAL

874 && output_style != style)

875 diff_error ("conflicting specifications of output style", 0, 0);

876 output_style = style;

877 }

878 \f

879 static char const *

880 filetype (st)

881 struct stat const *st;

882 {

883 /* See Posix.2 section 4.17.6.1.1 and Table 5-1 for these formats.

884 To keep diagnostics grammatical, the returned string must start

885 with a consonant. */

886

887 if (S_ISREG (st->st_mode))

888 {

889 if (st->st_size == 0)

890 return "regular empty file";

891 /* Posix.2 section 5.14.2 seems to suggest that we must read the file

892 and guess whether it's C, Fortran, etc., but this is somewhat useless

893 and doesn't reflect historical practice. We're allowed to guess

894 wrong, so we don't bother to read the file. */

895 return "regular file";

896 }

897 if (S_ISDIR (st->st_mode)) return "directory";

898

899 /* other Posix.1 file types */

900 #ifdef S_ISBLK

901 if (S_ISBLK (st->st_mode)) return "block special file";

902 #endif

903 #ifdef S_ISCHR

904 if (S_ISCHR (st->st_mode)) return "character special file";

905 #endif

906 #ifdef S_ISFIFO

907 if (S_ISFIFO (st->st_mode)) return "fifo";

908 #endif

909

910 /* other Posix.1b file types */

911 #ifdef S_TYPEISMQ

912 if (S_TYPEISMQ (st)) return "message queue";

913 #endif

914 #ifdef S_TYPEISSEM

915 if (S_TYPEISSEM (st)) return "semaphore";

916 #endif

917 #ifdef S_TYPEISSHM

918 if (S_TYPEISSHM (st)) return "shared memory object";

919 #endif

920

921 /* other popular file types */

922 /* S_ISLNK is impossible with `fstat' and `stat'. */

923 #ifdef S_ISSOCK

924 if (S_ISSOCK (st->st_mode)) return "socket";

925 #endif

926

927 return "weird file";

928 }

929 \f

930 /* Compare two files (or dirs) with specified names

931 DIR0/NAME0 and DIR1/NAME1, at level DEPTH in directory recursion.

932 (if DIR0 is 0, then the name is just NAME0, etc.)

933 This is self-contained; it opens the files and closes them.

934

935 Value is 0 if files are the same, 1 if different,

936 2 if there is a problem opening them. */

937

938 static int

939 compare_files (dir0, name0, dir1, name1, depth)

940 char const *dir0, *dir1;

941 char const *name0, *name1;

942 int depth;

943 {

944 struct file_data inf[2];

945 register int i;

946 int val;

947 int same_files;

948 int failed = 0;

949 char *free0 = 0, *free1 = 0;

950

951 /* If this is directory comparison, perhaps we have a file

952 that exists only in one of the directories.

953 If so, just print a message to that effect. */

954

955 if (! ((name0 != 0 && name1 != 0)

956 || (unidirectional_new_file_flag && name1 != 0)

957 || entire_new_file_flag))

958 {

959 char const *name = name0 == 0 ? name1 : name0;

960 char const *dir = name0 == 0 ? dir1 : dir0;

961 message ("Only in %s: %s\n", dir, name);

962 /* Return 1 so that diff_dirs will return 1 ("some files differ"). */

963 return 1;

964 }

965

966 bzero (inf, sizeof (inf));

967

968 /* Mark any nonexistent file with -1 in the desc field. */

969 /* Mark unopened files (e.g. directories) with -2. */

970

971 inf[0].desc = name0 == 0 ? -1 : -2;

972 inf[1].desc = name1 == 0 ? -1 : -2;

973

974 /* Now record the full name of each file, including nonexistent ones. */

975

976 if (name0 == 0)

977 name0 = name1;

978 if (name1 == 0)

979 name1 = name0;

980

981 inf[0].name = dir0 == 0 ? name0 : (free0 = dir_file_pathname (dir0, name0));

982 inf[1].name = dir1 == 0 ? name1 : (free1 = dir_file_pathname (dir1, name1));

983

984 /* Stat the files. Record whether they are directories. */

985

986 for (i = 0; i <= 1; i++)

987 {

988 if (inf[i].desc != -1)

989 {

990 int stat_result;

991

992 if (i && filename_cmp (inf[i].name, inf[0].name) == 0)

993 {

994 inf[i].stat = inf[0].stat;

995 stat_result = 0;

996 }

997 else if (strcmp (inf[i].name, "-") == 0)

998 {

999 inf[i].desc = STDIN_FILENO;

1000 stat_result = fstat (STDIN_FILENO, &inf[i].stat);

1001 if (stat_result == 0 && S_ISREG (inf[i].stat.st_mode))

1002 {

1003 off_t pos = lseek (STDIN_FILENO, (off_t) 0, SEEK_CUR);

1004 if (pos == -1)

1005 stat_result = -1;

1006 else

1007 {

1008 if (pos <= inf[i].stat.st_size)

1009 inf[i].stat.st_size -= pos;

1010 else

1011 inf[i].stat.st_size = 0;

1012 /* Posix.2 4.17.6.1.4 requires current time for stdin. */

1013 time (&inf[i].stat.st_mtime);

1014 }

1015 }

1016 }

1017 else

1018 stat_result = stat (inf[i].name, &inf[i].stat);

1019

1020 if (stat_result != 0)

1021 {

1022 perror_with_name (inf[i].name);

1023 failed = 1;

1024 }

1025 else

1026 {

1027 inf[i].dir_p = S_ISDIR (inf[i].stat.st_mode) && inf[i].desc != 0;

1028 if (inf[1 - i].desc == -1)

1029 {

1030 inf[1 - i].dir_p = inf[i].dir_p;

1031 inf[1 - i].stat.st_mode = inf[i].stat.st_mode;

1032 }

1033 }

1034 }

1035 }

1036

1037 if (! failed && depth == 0 && inf[0].dir_p != inf[1].dir_p)

1038 {

1039 /* If one is a directory, and it was specified in the command line,

1040 use the file in that dir with the other file's basename. */

1041

1042 int fnm_arg = inf[0].dir_p;

1043 int dir_arg = 1 - fnm_arg;

1044 char const *fnm = inf[fnm_arg].name;

1045 char const *dir = inf[dir_arg].name;

1046 char const *p = filename_lastdirchar (fnm);

1047 char const *filename = inf[dir_arg].name

1048 = dir_file_pathname (dir, p ? p + 1 : fnm);

1049

1050 if (strcmp (fnm, "-") == 0)

1051 fatal ("can't compare - to a directory");

1052

1053 if (stat (filename, &inf[dir_arg].stat) != 0)

1054 {

1055 perror_with_name (filename);

1056 failed = 1;

1057 }

1058 else

1059 inf[dir_arg].dir_p = S_ISDIR (inf[dir_arg].stat.st_mode);

1060 }

1061

1062 if (failed)

1063 {

1064

1065 /* If either file should exist but does not, return 2. */

1066

1067 val = 2;

1068

1069 }

1070 else if ((same_files = inf[0].desc != -1 && inf[1].desc != -1

1071 && 0 < same_file (&inf[0].stat, &inf[1].stat))

1072 && no_diff_means_no_output)

1073 {

1074 /* The two named files are actually the same physical file.

1075 We know they are identical without actually reading them. */

1076

1077 val = 0;

1078 }

1079 else if (inf[0].dir_p & inf[1].dir_p)

1080 {

1081 if (output_style == OUTPUT_IFDEF)

1082 fatal ("-D option not supported with directories");

1083

1084 /* If both are directories, compare the files in them. */

1085

1086 if (depth > 0 && !recursive)

1087 {

1088 /* But don't compare dir contents one level down

1089 unless -r was specified. */

1090 message ("Common subdirectories: %s and %s\n",

1091 inf[0].name, inf[1].name);

1092 val = 0;

1093 }

1094 else

1095 {

1096 val = diff_dirs (inf, compare_files, depth);

1097 }

1098

1099 }

1100 else if ((inf[0].dir_p | inf[1].dir_p)

1101 || (depth > 0

1102 && (! S_ISREG (inf[0].stat.st_mode)

1103 || ! S_ISREG (inf[1].stat.st_mode))))

1104 {

1105 /* Perhaps we have a subdirectory that exists only in one directory.

1106 If so, just print a message to that effect. */

1107

1108 if (inf[0].desc == -1 || inf[1].desc == -1)

1109 {

1110 if ((inf[0].dir_p | inf[1].dir_p)

1111 && recursive

1112 && (entire_new_file_flag

1113 || (unidirectional_new_file_flag && inf[0].desc == -1)))

1114 val = diff_dirs (inf, compare_files, depth);

1115 else

1116 {

1117 char const *dir = (inf[0].desc == -1) ? dir1 : dir0;

1118 /* See Posix.2 section 4.17.6.1.1 for this format. */

1119 message ("Only in %s: %s\n", dir, name0);

1120 val = 1;

1121 }

1122 }

1123 else

1124 {

1125 /* We have two files that are not to be compared. */

1126

1127 /* See Posix.2 section 4.17.6.1.1 for this format. */

1128 message5 ("File %s is a %s while file %s is a %s\n",

1129 inf[0].name, filetype (&inf[0].stat),

1130 inf[1].name, filetype (&inf[1].stat));

1131

1132 /* This is a difference. */

1133 val = 1;

1134 }

1135 }

1136 else if ((no_details_flag & ~ignore_some_changes)

1137 && inf[0].stat.st_size != inf[1].stat.st_size

1138 && (inf[0].desc == -1 || S_ISREG (inf[0].stat.st_mode))

1139 && (inf[1].desc == -1 || S_ISREG (inf[1].stat.st_mode)))

1140 {

1141 message ("Files %s and %s differ\n", inf[0].name, inf[1].name);

1142 val = 1;

1143 }

1144 else

1145 {

1146 /* Both exist and neither is a directory. */

1147

1148 /* Open the files and record their descriptors. */

1149

1150 if (inf[0].desc == -2)

1151 if ((inf[0].desc = open (inf[0].name, O_RDONLY, 0)) < 0)

1152 {

1153 perror_with_name (inf[0].name);

1154 failed = 1;

1155 }

1156 if (inf[1].desc == -2)

1157 {

1158 if (same_files)

1159 inf[1].desc = inf[0].desc;

1160 else if ((inf[1].desc = open (inf[1].name, O_RDONLY, 0)) < 0)

1161 {

1162 perror_with_name (inf[1].name);

1163 failed = 1;

1164 }

1165 }

1166

1167 #if HAVE_SETMODE

1168 if (binary_I_O)

1169 for (i = 0; i <= 1; i++)

1170 if (0 <= inf[i].desc)

1171 setmode (inf[i].desc, O_BINARY);

1172 #endif

1173

1174 /* Compare the files, if no error was found. */

1175

1176 val = failed ? 2 : diff_2_files (inf, depth);

1177

1178 /* Close the file descriptors. */

1179

1180 if (inf[0].desc >= 0 && close (inf[0].desc) != 0)

1181 {

1182 perror_with_name (inf[0].name);

1183 val = 2;

1184 }

1185 if (inf[1].desc >= 0 && inf[0].desc != inf[1].desc

1186 && close (inf[1].desc) != 0)

1187 {

1188 perror_with_name (inf[1].name);

1189 val = 2;

1190 }

1191 }

1192

1193 /* Now the comparison has been done, if no error prevented it,

1194 and VAL is the value this function will return. */

1195

1196 if (val == 0 && !inf[0].dir_p)

1197 {

1198 if (print_file_same_flag)

1199 message ("Files %s and %s are identical\n",

1200 inf[0].name, inf[1].name);

1201 }

1202 else

1203 flush_output ();

1204

1205 if (free0)

1206 free (free0);

1207 if (free1)

1208 free (free1);

1209

1210 return val;

1211 }

1212

1213 /* Initialize status variables and flag variables used in libdiff,

1214 to permit repeated calls to diff_run. */

1215

1216 static void

1217 initialize_main (argcp, argvp)

1218 int *argcp;

1219 char ***argvp;

1220 {

1221 /* These variables really must be reset each time diff_run is called. */

1222 output_style = OUTPUT_NORMAL;

1223 context = -1;

1224 file_label[0] = NULL;

1225 file_label[1] = NULL;

1226 diff_program_name = (*argvp)[0];

1227 outfile = NULL;

1228

1229 /* Reset these also, just for safety's sake. (If one invocation turns

1230 on ignore_case_flag, it must be turned off before diff_run is called

1231 again. But it is possible to make many diffs before encountering

1232 such a problem. */

1233 recursive = 0;

1234 no_discards = 0;

1235 #if HAVE_SETMODE

1236 binary_I_O = 0;

1237 #endif

1238 no_diff_means_no_output = 0;

1239 always_text_flag = 0;

1240 horizon_lines = 0;

1241 ignore_space_change_flag = 0;

1242 ignore_all_space_flag = 0;

1243 ignore_blank_lines_flag = 0;

1244 ignore_some_line_changes = 0;

1245 ignore_some_changes = 0;

1246 ignore_case_flag = 0;

1247 function_regexp_list = NULL;

1248 ignore_regexp_list = NULL;

1249 no_details_flag = 0;

1250 print_file_same_flag = 0;

1251 tab_align_flag = 0;

1252 tab_expand_flag = 0;

1253 dir_start_file = NULL;

1254 entire_new_file_flag = 0;

1255 unidirectional_new_file_flag = 0;

1256 paginate_flag = 0;

1257 bzero (group_format, sizeof (group_format));

1258 bzero (line_format, sizeof (line_format));

1259 sdiff_help_sdiff = 0;

1260 sdiff_left_only = 0;

1261 sdiff_skip_common_lines = 0;

1262 sdiff_half_width = 0;

1263 sdiff_column2_offset = 0;

1264 switch_string = NULL;

1265 heuristic = 0;

1266 bzero (files, sizeof (files));

1267 }