diffutils-2.4/ 40777 74720 1 0 5445723660 12250 5ustar eggertdaemondiffutils-2.4/diff.c100444 74720 14 63732 5444444505 13353 0ustar eggertguest/* GNU DIFF main routine. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* GNU DIFF was written by Mike Haertel, David Hayes, Richard Stallman, Len Tower, and Paul Eggert. */ #define GDIFF_MAIN #include "diff.h" #include "getopt.h" #include "fnmatch.h" #include "system.h" #ifndef DEFAULT_WIDTH #define DEFAULT_WIDTH 130 #endif #ifndef GUTTER_WIDTH_MINIMUM #define GUTTER_WIDTH_MINIMUM 3 #endif static char const *filetype PARAMS((struct stat const *)); static char *option_list PARAMS((char **, int)); static int add_exclude_file PARAMS((char const *)); static int ck_atoi PARAMS((char const *, int *)); static int compare_files PARAMS((char const *, char const *, char const *, char const *, int)); static int specify_format PARAMS((char **, char *)); static void add_exclude PARAMS((char const *)); static void add_regexp PARAMS((struct regexp_list **, char const *)); static void specify_style PARAMS((enum output_style)); static void usage PARAMS((void)); /* Nonzero for -r: if comparing two directories, compare their common subdirectories recursively. */ static int recursive; /* For debugging: don't do discard_confusing_lines. */ int no_discards; /* Return a string containing the command options with which diff was invoked. Spaces appear between what were separate ARGV-elements. There is a space at the beginning but none at the end. If there were no options, the result is an empty string. Arguments: OPTIONVEC, a vector containing separate ARGV-elements, and COUNT, the length of that vector. */ static char * option_list (optionvec, count) char **optionvec; /* Was `vector', but that collides on Alliant. */ int count; { int i; size_t length = 0; char *result; for (i = 0; i < count; i++) length += strlen (optionvec[i]) + 1; result = xmalloc (length + 1); result[0] = 0; for (i = 0; i < count; i++) { strcat (result, " "); strcat (result, optionvec[i]); } return result; } /* Convert STR to a positive integer, storing the result in *OUT. If STR is not a valid integer, return -1 (otherwise 0). */ static int ck_atoi (str, out) char const *str; int *out; { char const *p; for (p = str; *p; p++) if (*p < '0' || *p > '9') return -1; *out = atoi (optarg); return 0; } /* Keep track of excluded file name patterns. */ static char const **exclude; static int exclude_alloc, exclude_count; int excluded_filename (f) char const *f; { int i; for (i = 0; i < exclude_count; i++) if (fnmatch (exclude[i], f, 0) == 0) return 1; return 0; } static void add_exclude (pattern) char const *pattern; { if (exclude_alloc <= exclude_count) exclude = (char const **) (exclude_alloc == 0 ? xmalloc ((exclude_alloc = 64) * sizeof (*exclude)) : xrealloc (exclude, (exclude_alloc *= 2) * sizeof (*exclude))); exclude[exclude_count++] = pattern; } static int add_exclude_file (name) char const *name; { struct file_data f; char *p, *q, *lim; f.name = optarg; f.desc = (strcmp (optarg, "-") == 0 ? STDIN_FILENO : open (optarg, O_RDONLY, 0)); if (f.desc < 0 || fstat (f.desc, &f.stat) != 0) return -1; sip (&f, 1); slurp (&f); for (p = f.buffer, lim = p + f.buffered_chars; p < lim; p = q) { q = memchr (p, '\n', lim - p); if (!q) q = lim; *q++ = 0; add_exclude (p); } return close (f.desc); } /* The numbers 129- that appear in the fourth element of some entries tell the big switch in `main' how to process those options. */ static struct option const longopts[] = { {"ignore-blank-lines", 0, 0, 'B'}, {"context", 2, 0, 'C'}, {"ifdef", 1, 0, 'D'}, {"show-function-line", 1, 0, 'F'}, {"speed-large-files", 0, 0, 'H'}, {"ignore-matching-lines", 1, 0, 'I'}, {"label", 1, 0, 'L'}, {"file-label", 1, 0, 'L'}, /* An alias, no longer recommended */ {"new-file", 0, 0, 'N'}, {"entire-new-file", 0, 0, 'N'}, /* An alias, no longer recommended */ {"unidirectional-new-file", 0, 0, 'P'}, {"starting-file", 1, 0, 'S'}, {"initial-tab", 0, 0, 'T'}, {"width", 1, 0, 'W'}, {"text", 0, 0, 'a'}, {"ascii", 0, 0, 'a'}, /* An alias, no longer recommended */ {"ignore-space-change", 0, 0, 'b'}, {"minimal", 0, 0, 'd'}, {"ed", 0, 0, 'e'}, {"forward-ed", 0, 0, 'f'}, {"ignore-case", 0, 0, 'i'}, {"paginate", 0, 0, 'l'}, {"print", 0, 0, 'l'}, /* An alias, no longer recommended */ {"rcs", 0, 0, 'n'}, {"show-c-function", 0, 0, 'p'}, {"binary", 0, 0, 'q'}, /* An alias, no longer recommended */ {"brief", 0, 0, 'q'}, {"recursive", 0, 0, 'r'}, {"report-identical-files", 0, 0, 's'}, {"expand-tabs", 0, 0, 't'}, {"version", 0, 0, 'v'}, {"ignore-all-space", 0, 0, 'w'}, {"exclude", 1, 0, 'x'}, {"exclude-from", 1, 0, 'X'}, {"side-by-side", 0, 0, 'y'}, {"unified", 2, 0, 'U'}, {"left-column", 0, 0, 129}, {"suppress-common-lines", 0, 0, 130}, {"sdiff-merge-assist", 0, 0, 131}, {"old-line-format", 1, 0, 132}, {"new-line-format", 1, 0, 133}, {"unchanged-line-format", 1, 0, 134}, {"line-format", 1, 0, 135}, {"old-group-format", 1, 0, 136}, {"new-group-format", 1, 0, 137}, {"unchanged-group-format", 1, 0, 138}, {"changed-group-format", 1, 0, 139}, {"horizon-lines", 1, 0, 140}, {0, 0, 0, 0} }; int main (argc, argv) int argc; char *argv[]; { int val; int c; int prev = -1; int width = DEFAULT_WIDTH; /* Do our initializations. */ program = argv[0]; output_style = OUTPUT_NORMAL; context = -1; line_end_char = '\n'; /* Decode the options. */ while ((c = getopt_long (argc, argv, "0123456789abBcC:dD:efF:hHiI:lL:nNpPqrsS:tTuU:vwW:x:X:y", longopts, 0)) != EOF) { switch (c) { /* All digits combine in decimal to specify the context-size. */ case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '0': if (context == -1) context = 0; /* If a context length has already been specified, more digits allowed only if they follow right after the others. Reject two separate runs of digits, or digits after -C. */ else if (prev < '0' || prev > '9') fatal ("context length specified twice"); context = context * 10 + c - '0'; break; case 'a': /* Treat all files as text files; never treat as binary. */ always_text_flag = 1; break; case 'b': /* Ignore changes in amount of white space. */ ignore_space_change_flag = 1; length_varies = 1; ignore_some_changes = 1; break; case 'B': /* Ignore changes affecting only blank lines. */ ignore_blank_lines_flag = 1; ignore_some_changes = 1; break; case 'C': /* +context[=lines] */ case 'U': /* +unified[=lines] */ if (optarg) { if (context >= 0) fatal ("context length specified twice"); if (ck_atoi (optarg, &context)) fatal ("invalid context length argument"); } /* Falls through. */ case 'c': /* Make context-style output. */ specify_style (c == 'U' ? OUTPUT_UNIFIED : OUTPUT_CONTEXT); break; case 'd': /* Don't discard lines. This makes things slower (sometimes much slower) but will find a guaranteed minimal set of changes. */ no_discards = 1; break; case 'D': /* Make merged #ifdef output. */ specify_style (OUTPUT_IFDEF); { int i, err = 0; static char const C_ifdef_group_formats[] = "#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"; char *b = xmalloc (sizeof (C_ifdef_group_formats) + 7 * strlen(optarg) - 14 /* 7*"%s" */ - 8 /* 5*"%%" + 3*"%c" */); sprintf (b, C_ifdef_group_formats, optarg, optarg, 0, optarg, optarg, 0, 0, optarg, optarg, optarg); for (i = 0; i < 4; i++) { err |= specify_format (&group_format[i], b); b += strlen (b) + 1; } if (err) error ("conflicting #ifdef formats", 0, 0); } break; case 'e': /* Make output that is a valid `ed' script. */ specify_style (OUTPUT_ED); break; case 'f': /* Make output that looks vaguely like an `ed' script but has changes in the order they appear in the file. */ specify_style (OUTPUT_FORWARD_ED); break; case 'F': /* Show, for each set of changes, the previous line that matches the specified regexp. Currently affects only context-style output. */ add_regexp (&function_regexp_list, optarg); break; case 'h': /* Split the files into chunks of around 1500 lines for faster processing. Usually does not change the result. This currently has no effect. */ break; case 'H': /* Turn on heuristics that speed processing of large files with a small density of changes. */ heuristic = 1; break; case 'i': /* Ignore changes in case. */ ignore_case_flag = 1; ignore_some_changes = 1; break; case 'I': /* Ignore changes affecting only lines that match the specified regexp. */ add_regexp (&ignore_regexp_list, optarg); ignore_some_changes = 1; break; case 'l': /* Pass the output through `pr' to paginate it. */ paginate_flag = 1; break; case 'L': /* Specify file labels for `-c' output headers. */ if (!file_label[0]) file_label[0] = optarg; else if (!file_label[1]) file_label[1] = optarg; else fatal ("too many file label options"); break; case 'n': /* Output RCS-style diffs, like `-f' except that each command specifies the number of lines affected. */ specify_style (OUTPUT_RCS); break; case 'N': /* When comparing directories, if a file appears only in one directory, treat it as present but empty in the other. */ entire_new_file_flag = 1; break; case 'p': /* Make context-style output and show name of last C function. */ specify_style (OUTPUT_CONTEXT); add_regexp (&function_regexp_list, "^[_a-zA-Z$]"); break; case 'P': /* When comparing directories, if a file appears only in the second directory of the two, treat it as present but empty in the other. */ unidirectional_new_file_flag = 1; break; case 'q': no_details_flag = 1; break; case 'r': /* When comparing directories, recursively compare any subdirectories found. */ recursive = 1; break; case 's': /* Print a message if the files are the same. */ print_file_same_flag = 1; break; case 'S': /* When comparing directories, start with the specified file name. This is used for resuming an aborted comparison. */ dir_start_file = optarg; break; case 't': /* Expand tabs to spaces in the output so that it preserves the alignment of the input files. */ tab_expand_flag = 1; break; case 'T': /* Use a tab in the output, rather than a space, before the text of an input line, so as to keep the proper alignment in the input line without changing the characters in it. */ tab_align_flag = 1; break; case 'u': /* Output the context diff in unidiff format. */ specify_style (OUTPUT_UNIFIED); break; case 'v': fprintf (stderr, "GNU diff version %s\n", version_string); break; case 'w': /* Ignore horizontal white space when comparing lines. */ ignore_all_space_flag = 1; ignore_some_changes = 1; length_varies = 1; break; case 'x': add_exclude (optarg); break; case 'X': if (add_exclude_file (optarg) != 0) pfatal_with_name (optarg); break; case 'y': /* Use side-by-side (sdiff-style) columnar output. */ specify_style (OUTPUT_SDIFF); break; case 'W': /* Set the line width for OUTPUT_SDIFF. */ if (ck_atoi (optarg, &width) || width <= 0) fatal ("column width must be a positive integer"); break; case 129: sdiff_left_only = 1; break; case 130: sdiff_skip_common_lines = 1; break; case 131: /* sdiff-style columns output. */ specify_style (OUTPUT_SDIFF); sdiff_help_sdiff = 1; break; case 132: case 133: case 134: specify_style (OUTPUT_IFDEF); if (specify_format (&line_format[c - 132], optarg) != 0) error ("conflicting line format", 0, 0); break; case 135: specify_style (OUTPUT_IFDEF); { int i, err = 0; for (i = 0; i < sizeof (line_format) / sizeof (*line_format); i++) err |= specify_format (&line_format[i], optarg); if (err) error ("conflicting line format", 0, 0); } break; case 136: case 137: case 138: case 139: specify_style (OUTPUT_IFDEF); if (specify_format (&group_format[c - 136], optarg) != 0) error ("conflicting group format", 0, 0); break; case 140: if (ck_atoi (optarg, &horizon_lines) || horizon_lines < 0) fatal ("horizon must be a nonnegative integer"); break; default: usage (); } prev = c; } if (optind != argc - 2) usage (); { /* * We maximize first the half line width, and then the gutter width, * according to the following constraints: * 1. Two half lines plus a gutter must fit in a line. * 2. If the half line width is nonzero: * a. The gutter width is at least GUTTER_WIDTH_MINIMUM. * b. If tabs are not expanded to spaces, * a half line plus a gutter is an integral number of tabs, * so that tabs in the right column line up. */ int t = tab_expand_flag ? 1 : TAB_WIDTH; int off = (width + t + GUTTER_WIDTH_MINIMUM) / (2*t) * t; sdiff_half_width = max (0, min (off - GUTTER_WIDTH_MINIMUM, width - off)), sdiff_column2_offset = sdiff_half_width ? off : width; } if (output_style != OUTPUT_CONTEXT && output_style != OUTPUT_UNIFIED) context = 0; else if (context == -1) /* Default amount of context for -c. */ context = 3; if (output_style == OUTPUT_IFDEF) { int i; for (i = 0; i < sizeof (line_format) / sizeof (*line_format); i++) if (!line_format[i]) line_format[i] = "%l\n"; if (!group_format[OLD]) group_format[OLD] = group_format[UNCHANGED] ? group_format[UNCHANGED] : "%<"; if (!group_format[NEW]) group_format[NEW] = group_format[UNCHANGED] ? group_format[UNCHANGED] : "%>"; if (!group_format[UNCHANGED]) group_format[UNCHANGED] = "%="; if (!group_format[CHANGED]) group_format[CHANGED] = concat (group_format[OLD], group_format[NEW], ""); } no_diff_means_no_output = (output_style == OUTPUT_IFDEF ? (!*group_format[UNCHANGED] || (strcmp (group_format[UNCHANGED], "%=") == 0 && !*line_format[UNCHANGED])) : output_style == OUTPUT_SDIFF ? sdiff_skip_common_lines : 1); switch_string = option_list (argv + 1, optind - 1); val = compare_files (0, argv[optind], 0, argv[optind + 1], 0); /* Print any messages that were saved up for last. */ print_message_queue (); if (ferror (stdout) || fclose (stdout) != 0) fatal ("write error"); exit (val); return val; } /* Add the compiled form of regexp PATTERN to REGLIST. */ static void add_regexp (reglist, pattern) struct regexp_list **reglist; char const *pattern; { struct regexp_list *r; char const *m; r = (struct regexp_list *) xmalloc (sizeof (*r)); bzero (r, sizeof (*r)); r->buf.fastmap = xmalloc (256); m = re_compile_pattern (pattern, strlen (pattern), &r->buf); if (m != 0) error ("%s: %s", pattern, m); /* Add to the start of the list, since it's easier than the end. */ r->next = *reglist; *reglist = r; } static void usage () { fprintf (stderr, "Usage: %s [options] from-file to-file\n", program); fprintf (stderr, "Options:\n\ [-abBcdefhHilnNpPqrstTuvwy] [-C lines] [-D name] [-F regexp]\n\ [-I regexp] [-L from-label [-L to-label]] [-S starting-file] [-U lines]\n\ [-W columns] [-x pattern] [-X pattern-file]\n"); fprintf (stderr, "\ [--brief] [--changed-group-format=format] [--context[=lines]] [--ed]\n\ [--exclude=pattern] [--exclude-from=pattern-file] [--expand-tabs]\n\ [--forward-ed] [--horizon-lines=lines] [--ifdef=name]\n\ [--ignore-all-space] [--ignore-blank-lines] [--ignore-case]\n"); fprintf (stderr, "\ [--ignore-matching-lines=regexp] [--ignore-space-change]\n\ [--initial-tab] [--label=from-label [--label=to-label]]\n\ [--left-column] [--minimal] [--new-file] [--new-group-format=format]\n\ [--new-line-format=format] [--old-group-format=format]\n"); fprintf (stderr, "\ [--old-line-format=format] [--paginate] [--rcs] [--recursive]\n\ [--report-identical-files] [--sdiff-merge-assist] [--show-c-function]\n\ [--show-function-line=regexp] [--side-by-side] [--speed-large-files]\n\ [--starting-file=starting-file] [--suppress-common-lines] [--text]\n"); fprintf (stderr, "\ [--unchanged-group-format=format] [--unchanged-line-format=format]\n\ [--unidirectional-new-file] [--unified[=lines]] [--version]\n\ [--width=columns]\n"); exit (2); } static int specify_format (var, value) char **var; char *value; { int err = *var ? strcmp (*var, value) : 0; *var = value; return err; } static void specify_style (style) enum output_style style; { if (output_style != OUTPUT_NORMAL && output_style != style) error ("conflicting specifications of output style", 0, 0); output_style = style; } static char const * filetype (st) struct stat const *st; { /* See Posix.2 section 4.17.6.1.1 and Table 5-1 for these formats. To keep diagnostics grammatical, the returned string must start with a consonant. */ if (S_ISREG (st->st_mode)) { if (st->st_size == 0) return "regular empty file"; /* Posix.2 section 5.14.2 seems to suggest that we must read the file and guess whether it's C, Fortran, etc., but this is somewhat useless and doesn't reflect historical practice. We're allowed to guess wrong, so we don't bother to read the file. */ return "regular file"; } if (S_ISDIR (st->st_mode)) return "directory"; /* other Posix.1 file types */ #ifdef S_ISBLK if (S_ISBLK (st->st_mode)) return "block special file"; #endif #ifdef S_ISCHR if (S_ISCHR (st->st_mode)) return "character special file"; #endif #ifdef S_ISFIFO if (S_ISFIFO (st->st_mode)) return "fifo"; #endif /* other popular file types */ /* S_ISLNK is impossible with `stat'. */ #ifdef S_ISSOCK if (S_ISSOCK (st->st_mode)) return "socket"; #endif return "weird file"; } /* Compare two files (or dirs) with specified names DIR0/NAME0 and DIR1/NAME1, at level DEPTH in directory recursion. (if DIR0 is 0, then the name is just NAME0, etc.) This is self-contained; it opens the files and closes them. Value is 0 if files are the same, 1 if different, 2 if there is a problem opening them. */ static int compare_files (dir0, name0, dir1, name1, depth) char const *dir0, *dir1; char const *name0, *name1; int depth; { struct file_data inf[2]; register int i; int val; int same_files; int failed = 0; char *free0 = 0, *free1 = 0; /* If this is directory comparison, perhaps we have a file that exists only in one of the directories. If so, just print a message to that effect. */ if (! ((name0 != 0 && name1 != 0) || (unidirectional_new_file_flag && name1 != 0) || entire_new_file_flag)) { char const *name = name0 == 0 ? name1 : name0; char const *dir = name0 == 0 ? dir1 : dir0; message ("Only in %s: %s\n", dir, name); /* Return 1 so that diff_dirs will return 1 ("some files differ"). */ return 1; } /* Mark any nonexistent file with -1 in the desc field. */ /* Mark unopened files (e.g. directories) with -2. */ inf[0].desc = name0 == 0 ? -1 : -2; inf[1].desc = name1 == 0 ? -1 : -2; /* Now record the full name of each file, including nonexistent ones. */ if (name0 == 0) name0 = name1; if (name1 == 0) name1 = name0; inf[0].name = dir0 == 0 ? name0 : (free0 = dir_file_pathname (dir0, name0)); inf[1].name = dir1 == 0 ? name1 : (free1 = dir_file_pathname (dir1, name1)); /* Stat the files. Record whether they are directories. */ for (i = 0; i <= 1; i++) { bzero (&inf[i].stat, sizeof (struct stat)); inf[i].dir_p = 0; if (inf[i].desc != -1) { int stat_result; if (i && strcmp (inf[i].name, inf[0].name) == 0) { inf[i].stat = inf[0].stat; stat_result = 0; } else if (strcmp (inf[i].name, "-") == 0) { inf[i].desc = STDIN_FILENO; stat_result = fstat (STDIN_FILENO, &inf[i].stat); if (stat_result == 0 && S_ISREG (inf[i].stat.st_mode)) { off_t pos = lseek (STDIN_FILENO, (off_t) 0, SEEK_CUR); if (pos == -1) stat_result = -1; else { if (pos <= inf[i].stat.st_size) inf[i].stat.st_size -= pos; else inf[i].stat.st_size = 0; /* Posix.2 4.17.6.1.4 requires current time for stdin. */ time (&inf[i].stat.st_mtime); } } } else stat_result = stat (inf[i].name, &inf[i].stat); if (stat_result != 0) { perror_with_name (inf[i].name); failed = 1; } else { inf[i].dir_p = S_ISDIR (inf[i].stat.st_mode) && inf[i].desc != 0; if (inf[1 - i].desc == -1) { inf[1 - i].dir_p = inf[i].dir_p; inf[1 - i].stat.st_mode = inf[i].stat.st_mode; } } } } if (! failed && depth == 0 && inf[0].dir_p != inf[1].dir_p) { /* If one is a directory, and it was specified in the command line, use the file in that dir with the other file's basename. */ int fnm_arg = inf[0].dir_p; int dir_arg = 1 - fnm_arg; char const *fnm = inf[fnm_arg].name; char const *dir = inf[dir_arg].name; char const *p = strrchr (fnm, '/'); char const *filename = inf[dir_arg].name = dir_file_pathname (dir, p ? p + 1 : fnm); if (strcmp (fnm, "-") == 0) fatal ("can't compare - to a directory"); if (stat (filename, &inf[dir_arg].stat) != 0) { perror_with_name (filename); failed = 1; } else inf[dir_arg].dir_p = S_ISDIR (inf[dir_arg].stat.st_mode); } if (failed) { /* If either file should exist but does not, return 2. */ val = 2; } else if ((same_files = inf[0].stat.st_ino == inf[1].stat.st_ino && inf[0].stat.st_dev == inf[1].stat.st_dev && inf[0].stat.st_size == inf[1].stat.st_size && inf[0].desc != -1 && inf[1].desc != -1) && no_diff_means_no_output) { /* The two named files are actually the same physical file. We know they are identical without actually reading them. */ val = 0; } else if (inf[0].dir_p & inf[1].dir_p) { if (output_style == OUTPUT_IFDEF) fatal ("-D option not supported with directories"); /* If both are directories, compare the files in them. */ if (depth > 0 && !recursive) { /* But don't compare dir contents one level down unless -r was specified. */ message ("Common subdirectories: %s and %s\n", inf[0].name, inf[1].name); val = 0; } else { val = diff_dirs (inf, compare_files, depth); } } else if ((inf[0].dir_p | inf[1].dir_p) || (depth > 0 && (! S_ISREG (inf[0].stat.st_mode) || ! S_ISREG (inf[1].stat.st_mode)))) { /* Perhaps we have a subdirectory that exists only in one directory. If so, just print a message to that effect. */ if (inf[0].desc == -1 || inf[1].desc == -1) { if ((inf[0].dir_p | inf[1].dir_p) && recursive && (entire_new_file_flag || (unidirectional_new_file_flag && inf[0].desc == -1))) val = diff_dirs (inf, compare_files, depth); else { char const *dir = (inf[0].desc == -1) ? dir1 : dir0; /* See Posix.2 section 4.17.6.1.1 for this format. */ message ("Only in %s: %s\n", dir, name0); val = 1; } } else { /* We have two files that are not to be compared. */ /* See Posix.2 section 4.17.6.1.1 for this format. */ message5 ("File %s is a %s while file %s is a %s\n", inf[0].name, filetype (&inf[0].stat), inf[1].name, filetype (&inf[1].stat)); /* This is a difference. */ val = 1; } } else if ((no_details_flag & ~ignore_some_changes) && inf[0].stat.st_size != inf[1].stat.st_size && (inf[0].desc == -1 || S_ISREG (inf[0].stat.st_mode)) && (inf[1].desc == -1 || S_ISREG (inf[1].stat.st_mode))) { message ("Files %s and %s differ\n", inf[0].name, inf[1].name); val = 1; } else { /* Both exist and neither is a directory. */ /* Open the files and record their descriptors. */ if (inf[0].desc == -2) if ((inf[0].desc = open (inf[0].name, O_RDONLY, 0)) < 0) { perror_with_name (inf[0].name); failed = 1; } if (inf[1].desc == -2) if (same_files) inf[1].desc = inf[0].desc; else if ((inf[1].desc = open (inf[1].name, O_RDONLY, 0)) < 0) { perror_with_name (inf[1].name); failed = 1; } /* Compare the files, if no error was found. */ val = failed ? 2 : diff_2_files (inf, depth); /* Close the file descriptors. */ if (inf[0].desc >= 0 && close (inf[0].desc) != 0) { perror_with_name (inf[0].name); val = 2; } if (inf[1].desc >= 0 && inf[0].desc != inf[1].desc && close (inf[1].desc) != 0) { perror_with_name (inf[1].name); val = 2; } } /* Now the comparison has been done, if no error prevented it, and VAL is the value this function will return. */ if (val == 0 && !inf[0].dir_p) { if (print_file_same_flag) message ("Files %s and %s are identical\n", inf[0].name, inf[1].name); } else fflush (stdout); if (free0) free (free0); if (free1) free (free1); return val; } diffutils-2.4/analyze.c100444 74720 14 65566 5444737320 14115 0ustar eggertguest/* Analyze file differences for GNU DIFF. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* The basic algorithm is described in: "An O(ND) Difference Algorithm and its Variations", Eugene Myers, Algorithmica Vol. 1 No. 2, 1986, p 251. */ #include "diff.h" #include "cmpbuf.h" extern int no_discards; static int *xvec, *yvec; /* Vectors being compared. */ static int *fdiag; /* Vector, indexed by diagonal, containing the X coordinate of the point furthest along the given diagonal in the forward search of the edit matrix. */ static int *bdiag; /* Vector, indexed by diagonal, containing the X coordinate of the point furthest along the given diagonal in the backward search of the edit matrix. */ static int diag PARAMS((int, int, int, int, int *)); static struct change *add_change PARAMS((int, int, int, int, struct change *)); static struct change *build_reverse_script PARAMS((struct file_data const[])); static struct change *build_script PARAMS((struct file_data const[])); static void briefly_report PARAMS((int, struct file_data const[])); static void compareseq PARAMS((int, int, int, int)); static void discard_confusing_lines PARAMS((struct file_data[])); static void shift_boundaries PARAMS((struct file_data[])); /* Find the midpoint of the shortest edit script for a specified portion of the two files. We scan from the beginnings of the files, and simultaneously from the ends, doing a breadth-first search through the space of edit-sequence. When the two searches meet, we have found the midpoint of the shortest edit sequence. The value returned is the number of the diagonal on which the midpoint lies. The diagonal number equals the number of inserted lines minus the number of deleted lines (counting only lines before the midpoint). The edit cost is stored into *COST; this is the total number of lines inserted or deleted (counting only lines before the midpoint). This function assumes that the first lines of the specified portions of the two files do not match, and likewise that the last lines do not match. The caller must trim matching lines from the beginning and end of the portions it is going to specify. Note that if we return the "wrong" diagonal value, or if the value of bdiag at that diagonal is "wrong", the worst this can do is cause suboptimal diff output. It cannot cause incorrect diff output. */ static int diag (xoff, xlim, yoff, ylim, cost) int xoff, xlim, yoff, ylim; int *cost; { int *const fd = fdiag; /* Give the compiler a chance. */ int *const bd = bdiag; /* Additional help for the compiler. */ int *const xv = xvec; /* Still more help for the compiler. */ int *const yv = yvec; /* And more and more . . . */ int const dmin = xoff - ylim; /* Minimum valid diagonal. */ int const dmax = xlim - yoff; /* Maximum valid diagonal. */ int const fmid = xoff - yoff; /* Center diagonal of top-down search. */ int const bmid = xlim - ylim; /* Center diagonal of bottom-up search. */ int fmin = fmid, fmax = fmid; /* Limits of top-down search. */ int bmin = bmid, bmax = bmid; /* Limits of bottom-up search. */ int c; /* Cost. */ int odd = (fmid - bmid) & 1; /* True if southeast corner is on an odd diagonal with respect to the northwest. */ fd[fmid] = xoff; bd[bmid] = xlim; for (c = 1;; ++c) { int d; /* Active diagonal. */ int big_snake = 0; /* Extend the top-down search by an edit step in each diagonal. */ fmin > dmin ? fd[--fmin - 1] = -1 : ++fmin; fmax < dmax ? fd[++fmax + 1] = -1 : --fmax; for (d = fmax; d >= fmin; d -= 2) { int x, y, oldx, tlo = fd[d - 1], thi = fd[d + 1]; if (tlo >= thi) x = tlo + 1; else x = thi; oldx = x; y = x - d; while (x < xlim && y < ylim && xv[x] == yv[y]) ++x, ++y; if (x - oldx > 20) big_snake = 1; fd[d] = x; if (odd && bmin <= d && d <= bmax && bd[d] <= fd[d]) { *cost = 2 * c - 1; return d; } } /* Similar extend the bottom-up search. */ bmin > dmin ? bd[--bmin - 1] = INT_MAX : ++bmin; bmax < dmax ? bd[++bmax + 1] = INT_MAX : --bmax; for (d = bmax; d >= bmin; d -= 2) { int x, y, oldx, tlo = bd[d - 1], thi = bd[d + 1]; if (tlo < thi) x = tlo; else x = thi - 1; oldx = x; y = x - d; while (x > xoff && y > yoff && xv[x - 1] == yv[y - 1]) --x, --y; if (oldx - x > 20) big_snake = 1; bd[d] = x; if (!odd && fmin <= d && d <= fmax && bd[d] <= fd[d]) { *cost = 2 * c; return d; } } /* Heuristic: check occasionally for a diagonal that has made lots of progress compared with the edit distance. If we have any such, find the one that has made the most progress and return it as if it had succeeded. With this heuristic, for files with a constant small density of changes, the algorithm is linear in the file size. */ if (c > 200 && big_snake && heuristic) { int best; int bestpos; best = 0; bestpos = 0; /* Pacify `gcc -Wall'. */ for (d = fmax; d >= fmin; d -= 2) { int dd = d - fmid; if ((fd[d] - xoff)*2 - dd > 12 * (c + (dd > 0 ? dd : -dd))) { if (fd[d] * 2 - dd > best && fd[d] - xoff > 20 && fd[d] - d - yoff > 20) { int k; int x = fd[d]; /* We have a good enough best diagonal; now insist that it end with a significant snake. */ for (k = 1; k <= 20; k++) if (xvec[x - k] != yvec[x - d - k]) break; if (k == 21) { best = fd[d] * 2 - dd; bestpos = d; } } } } if (best > 0) { *cost = 2 * c - 1; return bestpos; } best = 0; for (d = bmax; d >= bmin; d -= 2) { int dd = d - bmid; if ((xlim - bd[d])*2 + dd > 12 * (c + (dd > 0 ? dd : -dd))) { if ((xlim - bd[d]) * 2 + dd > best && xlim - bd[d] > 20 && ylim - (bd[d] - d) > 20) { /* We have a good enough best diagonal; now insist that it end with a significant snake. */ int k; int x = bd[d]; for (k = 0; k < 20; k++) if (xvec[x + k] != yvec[x - d + k]) break; if (k == 20) { best = (xlim - bd[d]) * 2 + dd; bestpos = d; } } } } if (best > 0) { *cost = 2 * c - 1; return bestpos; } } } } /* Compare in detail contiguous subsequences of the two files which are known, as a whole, to match each other. The results are recorded in the vectors files[N].changed_flag, by storing a 1 in the element for each line that is an insertion or deletion. The subsequence of file 0 is [XOFF, XLIM) and likewise for file 1. Note that XLIM, YLIM are exclusive bounds. All line numbers are origin-0 and discarded lines are not counted. */ static void compareseq (xoff, xlim, yoff, ylim) int xoff, xlim, yoff, ylim; { /* Slide down the bottom initial diagonal. */ while (xoff < xlim && yoff < ylim && xvec[xoff] == yvec[yoff]) ++xoff, ++yoff; /* Slide up the top initial diagonal. */ while (xlim > xoff && ylim > yoff && xvec[xlim - 1] == yvec[ylim - 1]) --xlim, --ylim; /* Handle simple cases. */ if (xoff == xlim) while (yoff < ylim) files[1].changed_flag[files[1].realindexes[yoff++]] = 1; else if (yoff == ylim) while (xoff < xlim) files[0].changed_flag[files[0].realindexes[xoff++]] = 1; else { int c, d, f, b; /* Find a point of correspondence in the middle of the files. */ d = diag (xoff, xlim, yoff, ylim, &c); f = fdiag[d]; b = bdiag[d]; if (c == 1) { /* This should be impossible, because it implies that one of the two subsequences is empty, and that case was handled above without calling `diag'. Let's verify that this is true. */ abort (); #if 0 /* The two subsequences differ by a single insert or delete; record it and we are done. */ if (d < xoff - yoff) files[1].changed_flag[files[1].realindexes[b - d - 1]] = 1; else files[0].changed_flag[files[0].realindexes[b]] = 1; #endif } else { /* Use that point to split this problem into two subproblems. */ compareseq (xoff, b, yoff, b - d); /* This used to use f instead of b, but that is incorrect! It is not necessarily the case that diagonal d has a snake from b to f. */ compareseq (b, xlim, b - d, ylim); } } } /* Discard lines from one file that have no matches in the other file. A line which is discarded will not be considered by the actual comparison algorithm; it will be as if that line were not in the file. The file's `realindexes' table maps virtual line numbers (which don't count the discarded lines) into real line numbers; this is how the actual comparison algorithm produces results that are comprehensible when the discarded lines are counted. When we discard a line, we also mark it as a deletion or insertion so that it will be printed in the output. */ void discard_confusing_lines (filevec) struct file_data filevec[]; { unsigned int f, i; char *discarded[2]; int *equiv_count[2]; int *p; /* Allocate our results. */ p = (int *) xmalloc ((filevec[0].buffered_lines + filevec[1].buffered_lines) * (2 * sizeof (int))); for (f = 0; f < 2; f++) { filevec[f].undiscarded = p; p += filevec[f].buffered_lines; filevec[f].realindexes = p; p += filevec[f].buffered_lines; } /* Set up equiv_count[F][I] as the number of lines in file F that fall in equivalence class I. */ p = (int *) xmalloc (filevec[0].equiv_max * (2 * sizeof (int))); equiv_count[0] = p; equiv_count[1] = p + filevec[0].equiv_max; bzero (p, filevec[0].equiv_max * (2 * sizeof (int))); for (i = 0; i < filevec[0].buffered_lines; ++i) ++equiv_count[0][filevec[0].equivs[i]]; for (i = 0; i < filevec[1].buffered_lines; ++i) ++equiv_count[1][filevec[1].equivs[i]]; /* Set up tables of which lines are going to be discarded. */ discarded[0] = xmalloc (sizeof (char) * (filevec[0].buffered_lines + filevec[1].buffered_lines)); discarded[1] = discarded[0] + filevec[0].buffered_lines; bzero (discarded[0], sizeof (char) * (filevec[0].buffered_lines + filevec[1].buffered_lines)); /* Mark to be discarded each line that matches no line of the other file. If a line matches many lines, mark it as provisionally discardable. */ for (f = 0; f < 2; f++) { unsigned int end = filevec[f].buffered_lines; char *discards = discarded[f]; int *counts = equiv_count[1 - f]; int *equivs = filevec[f].equivs; unsigned int many = 5; unsigned int tem = end / 64; /* Multiply MANY by approximate square root of number of lines. That is the threshold for provisionally discardable lines. */ while ((tem = tem >> 2) > 0) many *= 2; for (i = 0; i < end; i++) { int nmatch; if (equivs[i] == 0) continue; nmatch = counts[equivs[i]]; if (nmatch == 0) discards[i] = 1; else if (nmatch > many) discards[i] = 2; } } /* Don't really discard the provisional lines except when they occur in a run of discardables, with nonprovisionals at the beginning and end. */ for (f = 0; f < 2; f++) { unsigned int end = filevec[f].buffered_lines; register char *discards = discarded[f]; for (i = 0; i < end; i++) { /* Cancel provisional discards not in middle of run of discards. */ if (discards[i] == 2) discards[i] = 0; else if (discards[i] != 0) { /* We have found a nonprovisional discard. */ register int j; unsigned int length; unsigned int provisional = 0; /* Find end of this run of discardable lines. Count how many are provisionally discardable. */ for (j = i; j < end; j++) { if (discards[j] == 0) break; if (discards[j] == 2) ++provisional; } /* Cancel provisional discards at end, and shrink the run. */ while (j > i && discards[j - 1] == 2) discards[--j] = 0, --provisional; /* Now we have the length of a run of discardable lines whose first and last are not provisional. */ length = j - i; /* If 1/4 of the lines in the run are provisional, cancel discarding of all provisional lines in the run. */ if (provisional * 4 > length) { while (j > i) if (discards[--j] == 2) discards[j] = 0; } else { register unsigned int consec; unsigned int minimum = 1; unsigned int tem = length / 4; /* MINIMUM is approximate square root of LENGTH/4. A subrun of two or more provisionals can stand when LENGTH is at least 16. A subrun of 4 or more can stand when LENGTH >= 64. */ while ((tem = tem >> 2) > 0) minimum *= 2; minimum++; /* Cancel any subrun of MINIMUM or more provisionals within the larger run. */ for (j = 0, consec = 0; j < length; j++) if (discards[i + j] != 2) consec = 0; else if (minimum == ++consec) /* Back up to start of subrun, to cancel it all. */ j -= consec; else if (minimum < consec) discards[i + j] = 0; /* Scan from beginning of run until we find 3 or more nonprovisionals in a row or until the first nonprovisional at least 8 lines in. Until that point, cancel any provisionals. */ for (j = 0, consec = 0; j < length; j++) { if (j >= 8 && discards[i + j] == 1) break; if (discards[i + j] == 2) consec = 0, discards[i + j] = 0; else if (discards[i + j] == 0) consec = 0; else consec++; if (consec == 3) break; } /* I advances to the last line of the run. */ i += length - 1; /* Same thing, from end. */ for (j = 0, consec = 0; j < length; j++) { if (j >= 8 && discards[i - j] == 1) break; if (discards[i - j] == 2) consec = 0, discards[i - j] = 0; else if (discards[i - j] == 0) consec = 0; else consec++; if (consec == 3) break; } } } } } /* Actually discard the lines. */ for (f = 0; f < 2; f++) { char *discards = discarded[f]; unsigned int end = filevec[f].buffered_lines; unsigned int j = 0; for (i = 0; i < end; ++i) if (no_discards || discards[i] == 0) { filevec[f].undiscarded[j] = filevec[f].equivs[i]; filevec[f].realindexes[j++] = i; } else filevec[f].changed_flag[i] = 1; filevec[f].nondiscarded_lines = j; } free (discarded[0]); free (equiv_count[0]); } /* Adjust inserts/deletes of blank lines to join changes as much as possible. We do something when a run of changed lines include a blank line at one end and have an excluded blank line at the other. We are free to choose which blank line is included. `compareseq' always chooses the one at the beginning, but usually it is cleaner to consider the following blank line to be the "change". The only exception is if the preceding blank line would join this change to other changes. */ int inhibit; static void shift_boundaries (filevec) struct file_data filevec[]; { int f; if (inhibit) return; for (f = 0; f < 2; f++) { char *changed = filevec[f].changed_flag; char *other_changed = filevec[1-f].changed_flag; int i = 0; int j = 0; int i_end = filevec[f].buffered_lines; int preceding = -1; int other_preceding = -1; while (1) { int start, other_start; /* Scan forwards to find beginning of another run of changes. Also keep track of the corresponding point in the other file. */ while (i < i_end && changed[i] == 0) { while (other_changed[j++]) /* Non-corresponding lines in the other file will count as the preceding batch of changes. */ other_preceding = j; i++; } if (i == i_end) break; start = i; other_start = j; while (1) { /* Now find the end of this run of changes. */ while (changed[++i] != 0) ; /* If the first changed line matches the following unchanged one, and this run does not follow right after a previous run, and there are no lines deleted from the other file here, then classify the first changed line as unchanged and the following line as changed in its place. */ /* You might ask, how could this run follow right after another? Only because the previous run was shifted here. */ if (i != i_end && files[f].equivs[start] == files[f].equivs[i] && !other_changed[j] && !(start == preceding || other_start == other_preceding)) { changed[start++] = 0; changed[i] = 1; /* Since one line-that-matches is now before this run instead of after, we must advance in the other file to keep in synch. */ ++j; } else break; } preceding = i; other_preceding = j; } } } /* Cons an additional entry onto the front of an edit script OLD. LINE0 and LINE1 are the first affected lines in the two files (origin 0). DELETED is the number of lines deleted here from file 0. INSERTED is the number of lines inserted here in file 1. If DELETED is 0 then LINE0 is the number of the line before which the insertion was done; vice versa for INSERTED and LINE1. */ static struct change * add_change (line0, line1, deleted, inserted, old) int line0, line1, deleted, inserted; struct change *old; { struct change *new = (struct change *) xmalloc (sizeof (struct change)); new->line0 = line0; new->line1 = line1; new->inserted = inserted; new->deleted = deleted; new->link = old; return new; } /* Scan the tables of which lines are inserted and deleted, producing an edit script in reverse order. */ static struct change * build_reverse_script (filevec) struct file_data const filevec[]; { struct change *script = 0; char *changed0 = filevec[0].changed_flag; char *changed1 = filevec[1].changed_flag; int len0 = filevec[0].buffered_lines; int len1 = filevec[1].buffered_lines; /* Note that changedN[len0] does exist, and contains 0. */ int i0 = 0, i1 = 0; while (i0 < len0 || i1 < len1) { if (changed0[i0] || changed1[i1]) { int line0 = i0, line1 = i1; /* Find # lines changed here in each file. */ while (changed0[i0]) ++i0; while (changed1[i1]) ++i1; /* Record this change. */ script = add_change (line0, line1, i0 - line0, i1 - line1, script); } /* We have reached lines in the two files that match each other. */ i0++, i1++; } return script; } /* Scan the tables of which lines are inserted and deleted, producing an edit script in forward order. */ static struct change * build_script (filevec) struct file_data const filevec[]; { struct change *script = 0; char *changed0 = filevec[0].changed_flag; char *changed1 = filevec[1].changed_flag; int i0 = filevec[0].buffered_lines, i1 = filevec[1].buffered_lines; /* Note that changedN[-1] does exist, and contains 0. */ while (i0 >= 0 || i1 >= 0) { if (changed0[i0 - 1] || changed1[i1 - 1]) { int line0 = i0, line1 = i1; /* Find # lines changed here in each file. */ while (changed0[i0 - 1]) --i0; while (changed1[i1 - 1]) --i1; /* Record this change. */ script = add_change (i0, i1, line0 - i0, line1 - i1, script); } /* We have reached lines in the two files that match each other. */ i0--, i1--; } return script; } /* If CHANGES, briefly report that two files differed. */ static void briefly_report (changes, filevec) int changes; struct file_data const filevec[]; { if (changes) message (no_details_flag ? "Files %s and %s differ\n" : "Binary files %s and %s differ\n", filevec[0].name, filevec[1].name); } /* Report the differences of two files. DEPTH is the current directory depth. */ int diff_2_files (filevec, depth) struct file_data filevec[]; int depth; { int diags; int i; struct change *e, *p; struct change *script; int changes; /* If we have detected that either file is binary, compare the two files as binary. This can happen only when the first chunk is read. Also, --brief without any --ignore-* options means we can speed things up by treating the files as binary. */ if (read_files (filevec, no_details_flag & ~ignore_some_changes)) { /* Files with different lengths must be different. */ if (filevec[0].stat.st_size != filevec[1].stat.st_size && (filevec[0].desc < 0 || S_ISREG (filevec[0].stat.st_mode)) && (filevec[1].desc < 0 || S_ISREG (filevec[1].stat.st_mode))) changes = 1; /* Standard input equals itself. */ else if (filevec[0].desc == filevec[1].desc) changes = 0; else /* Scan both files, a buffer at a time, looking for a difference. */ { /* Allocate same-sized buffers for both files. */ size_t buffer_size = buffer_lcm (STAT_BLOCKSIZE (filevec[0].stat), STAT_BLOCKSIZE (filevec[1].stat)); for (i = 0; i < 2; i++) filevec[i].buffer = xrealloc (filevec[i].buffer, buffer_size); for (;; filevec[0].buffered_chars = filevec[1].buffered_chars = 0) { /* Read a buffer's worth from both files. */ for (i = 0; i < 2; i++) if (0 <= filevec[i].desc) while (filevec[i].buffered_chars != buffer_size) { int r = read (filevec[i].desc, filevec[i].buffer + filevec[i].buffered_chars, buffer_size - filevec[i].buffered_chars); if (r == 0) break; if (r < 0) pfatal_with_name (filevec[i].name); filevec[i].buffered_chars += r; } /* If the buffers differ, the files differ. */ if (filevec[0].buffered_chars != filevec[1].buffered_chars || memcmp (filevec[0].buffer, filevec[1].buffer, filevec[0].buffered_chars) != 0) { changes = 1; break; } /* If we reach end of file, the files are the same. */ if (filevec[0].buffered_chars != buffer_size) { changes = 0; break; } } } briefly_report (changes, filevec); } else { /* Allocate vectors for the results of comparison: a flag for each line of each file, saying whether that line is an insertion or deletion. Allocate an extra element, always zero, at each end of each vector. */ size_t s = filevec[0].buffered_lines + filevec[1].buffered_lines + 4; filevec[0].changed_flag = xmalloc (s); bzero (filevec[0].changed_flag, s); filevec[0].changed_flag++; filevec[1].changed_flag = filevec[0].changed_flag + filevec[0].buffered_lines + 2; /* Some lines are obviously insertions or deletions because they don't match anything. Detect them now, and avoid even thinking about them in the main comparison algorithm. */ discard_confusing_lines (filevec); /* Now do the main comparison algorithm, considering just the undiscarded lines. */ xvec = filevec[0].undiscarded; yvec = filevec[1].undiscarded; diags = filevec[0].nondiscarded_lines + filevec[1].nondiscarded_lines + 3; fdiag = (int *) xmalloc (diags * (2 * sizeof (int))); bdiag = fdiag + diags; fdiag += filevec[1].nondiscarded_lines + 1; bdiag += filevec[1].nondiscarded_lines + 1; files[0] = filevec[0]; files[1] = filevec[1]; compareseq (0, filevec[0].nondiscarded_lines, 0, filevec[1].nondiscarded_lines); free (fdiag - (filevec[1].nondiscarded_lines + 1)); /* Modify the results slightly to make them prettier in cases where that can validly be done. */ shift_boundaries (filevec); /* Get the results of comparison in the form of a chain of `struct change's -- an edit script. */ if (output_style == OUTPUT_ED) script = build_reverse_script (filevec); else script = build_script (filevec); /* Set CHANGES if we had any diffs. If some changes are ignored, we must scan the script to decide. */ if (ignore_blank_lines_flag || ignore_regexp_list) { struct change *next = script; changes = 0; while (next && changes == 0) { struct change *this, *end; int first0, last0, first1, last1, deletes, inserts; /* Find a set of changes that belong together. */ this = next; end = find_change (next); /* Disconnect them from the rest of the changes, making them a hunk, and remember the rest for next iteration. */ next = end->link; end->link = 0; /* Determine whether this hunk is really a difference. */ analyze_hunk (this, &first0, &last0, &first1, &last1, &deletes, &inserts); /* Reconnect the script so it will all be freed properly. */ end->link = next; if (deletes || inserts) changes = 1; } } else changes = (script != 0); if (no_details_flag) briefly_report (changes, filevec); else { if (changes || ! no_diff_means_no_output) { /* Record info for starting up output, to be used if and when we have some output to print. */ setup_output (files[0].name, files[1].name, depth); switch (output_style) { case OUTPUT_CONTEXT: print_context_script (script, 0); break; case OUTPUT_UNIFIED: print_context_script (script, 1); break; case OUTPUT_ED: print_ed_script (script); break; case OUTPUT_FORWARD_ED: pr_forward_ed_script (script); break; case OUTPUT_RCS: print_rcs_script (script); break; case OUTPUT_NORMAL: print_normal_script (script); break; case OUTPUT_IFDEF: print_ifdef_script (script); break; case OUTPUT_SDIFF: print_sdiff_script (script); } finish_output (); } } free (filevec[0].undiscarded); free (filevec[0].changed_flag - 1); for (i = 1; i >= 0; --i) free (filevec[i].equivs); for (i = 0; i < 2; ++i) free (filevec[i].linbuf + filevec[i].linbuf_base); for (e = script; e; e = p) { p = e->link; free (e); } if (! ROBUST_OUTPUT_STYLE (output_style)) for (i = 0; i < 2; ++i) if (filevec[i].missing_newline) { error ("No newline at end of file %s", filevec[i].name, ""); changes = 2; } } if (filevec[0].buffer != filevec[1].buffer) free (filevec[0].buffer); free (filevec[1].buffer); return changes; } diffutils-2.4/cmpbuf.c100444 74720 14 2241 5437442262 13663 0ustar eggertguest/* Buffer primitives for comparison operations. Copyright (C) 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "system.h" #include "cmpbuf.h" /* Least common multiple of two buffer sizes A and B. */ size_t buffer_lcm (a, b) size_t a, b; { size_t m, n, r; /* Yield reasonable values if buffer sizes are zero. */ if (!a) return b ? b : 8 * 1024; if (!b) return a; /* n = gcd (a, b) */ for (m = a, n = b; (r = m % n) != 0; m = n, n = r) continue; return a/n * b; } diffutils-2.4/cmpbuf.h100444 74720 14 1501 5437442262 13666 0ustar eggertguest/* Buffer primitives for comparison operations. Copyright (C) 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ size_t buffer_lcm PARAMS((size_t, size_t)); diffutils-2.4/io.c100444 74720 14 45662 5437442262 13054 0ustar eggertguest/* File I/O for GNU DIFF. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "diff.h" /* Rotate a value n bits to the left. */ #define UINT_BIT (sizeof (unsigned) * CHAR_BIT) #define ROL(v, n) ((v) << (n) | (v) >> (UINT_BIT - (n))) /* Given a hash value and a new character, return a new hash value. */ #define HASH(h, c) ((c) + ROL (h, 7)) /* Guess remaining number of lines from number N of lines so far, size S so far, and total size T. */ #define GUESS_LINES(n,s,t) (((t) - (s)) / ((n) < 10 ? 32 : (s) / ((n)-1)) + 5) /* Type used for fast prefix comparison in find_identical_ends. */ typedef long word; /* Lines are put into equivalence classes (of lines that match in line_cmp). Each equivalence class is represented by one of these structures, but only while the classes are being computed. Afterward, each class is represented by a number. */ struct equivclass { int next; /* Next item in this bucket. */ unsigned hash; /* Hash of lines in this class. */ char const *line; /* A line that fits this class. */ size_t length; /* The length of that line. */ }; /* Hash-table: array of buckets, each being a chain of equivalence classes. */ static int *buckets; /* Number of buckets in the hash table array. */ static int nbuckets; /* Array in which the equivalence classes are allocated. The bucket-chains go through the elements in this array. The number of an equivalence class is its index in this array. */ static struct equivclass *equivs; /* Index of first free element in the array `equivs'. */ static int equivs_index; /* Number of elements allocated in the array `equivs'. */ static int equivs_alloc; static void find_and_hash_each_line PARAMS((struct file_data *)); static void find_identical_ends PARAMS((struct file_data[])); static void prepare_text_end PARAMS((struct file_data *)); /* Check for binary files and compare them for exact identity. */ /* Return 1 if BUF contains a non text character. SIZE is the number of characters in BUF. */ #define binary_file_p(buf, size) (size != 0 && memchr (buf, '\0', size) != 0) /* Get ready to read the current file. Return nonzero if SKIP_TEST is zero, and if it appears to be a binary file. */ int sip (current, skip_test) struct file_data *current; int skip_test; { /* If we have a nonexistent file at this stage, treat it as empty. */ if (current->desc < 0) { /* Leave room for a sentinel. */ current->buffer = xmalloc (sizeof (word)); current->bufsize = sizeof (word); current->buffered_chars = 0; } else { current->bufsize = current->buffered_chars = STAT_BLOCKSIZE (current->stat); if (S_ISREG (current->stat.st_mode)) /* Get the size out of the stat block. Allocate enough room for appended newline and sentinel. Allocate at least one block, to prevent overrunning the buffer when comparing growing binary files. */ current->bufsize = max (current->bufsize, current->stat.st_size + sizeof (word) + 1); current->buffer = xmalloc (current->bufsize); if (skip_test) current->buffered_chars = 0; else { /* Check first part of file to see if it's a binary file. */ current->buffered_chars = read (current->desc, current->buffer, current->buffered_chars); if (current->buffered_chars == -1) pfatal_with_name (current->name); return binary_file_p (current->buffer, current->buffered_chars); } } return 0; } /* Slurp the rest of the current file completely into memory. */ void slurp (current) struct file_data *current; { size_t cc; if (current->desc < 0) /* The file is nonexistent. */ ; else if (S_ISREG (current->stat.st_mode)) { /* It's a regular file; slurp in the rest all at once. */ cc = current->stat.st_size - current->buffered_chars; if (cc) { cc = read (current->desc, current->buffer + current->buffered_chars, cc); if (cc == -1) pfatal_with_name (current->name); current->buffered_chars += cc; } } /* It's not a regular file; read it, growing the buffer as needed. */ else if (always_text_flag || current->buffered_chars != 0) { for (;;) { if (current->buffered_chars == current->bufsize) { current->bufsize = current->bufsize * 2; current->buffer = xrealloc (current->buffer, current->bufsize); } cc = read (current->desc, current->buffer + current->buffered_chars, current->bufsize - current->buffered_chars); if (cc == 0) break; if (cc == -1) pfatal_with_name (current->name); current->buffered_chars += cc; } /* Allocate just enough room for appended newline and sentinel. */ current->bufsize = current->buffered_chars + sizeof (word) + 1; current->buffer = xrealloc (current->buffer, current->bufsize); } } /* Split the file into lines, simultaneously computing the equivalence class for each line. */ static void find_and_hash_each_line (current) struct file_data *current; { unsigned h; unsigned char const *p = (unsigned char const *) current->prefix_end; unsigned char c; int i, *bucket; size_t length; /* Cache often-used quantities in local variables to help the compiler. */ char const **linbuf = current->linbuf; int alloc_lines = current->alloc_lines; int line = 0; int linbuf_base = current->linbuf_base; int *cureqs = (int *) xmalloc (alloc_lines * sizeof (int)); struct equivclass *eqs = equivs; int eqs_index = equivs_index; int eqs_alloc = equivs_alloc; char const *suffix_begin = current->suffix_begin; char const *bufend = current->buffer + current->buffered_chars; char const *incomplete_tail = current->missing_newline && ROBUST_OUTPUT_STYLE (output_style) ? bufend : (char const *) 0; int varies = length_varies; while ((char const *) p < suffix_begin) { char const *ip = (char const *) p; /* Compute the equivalence class for this line. */ h = 0; /* Hash this line until we find a newline. */ if (ignore_case_flag) { if (ignore_all_space_flag) while ((c = *p++) != '\n') { if (! isspace (c)) h = HASH (h, isupper (c) ? tolower (c) : c); } else if (ignore_space_change_flag) while ((c = *p++) != '\n') { if (isspace (c)) { while (isspace (c = *p++)) if (c == '\n') goto hashing_done; h = HASH (h, ' '); } /* C is now the first non-space. */ h = HASH (h, isupper (c) ? tolower (c) : c); } else while ((c = *p++) != '\n') h = HASH (h, isupper (c) ? tolower (c) : c); } else { if (ignore_all_space_flag) while ((c = *p++) != '\n') { if (! isspace (c)) h = HASH (h, c); } else if (ignore_space_change_flag) while ((c = *p++) != '\n') { if (isspace (c)) { while (isspace (c = *p++)) if (c == '\n') goto hashing_done; h = HASH (h, ' '); } /* C is now the first non-space. */ h = HASH (h, c); } else while ((c = *p++) != '\n') h = HASH (h, c); } hashing_done:; bucket = &buckets[h % nbuckets]; length = (char const *) p - ip - ((char const *) p == incomplete_tail); for (i = *bucket; ; i = eqs[i].next) if (!i) { /* Create a new equivalence class in this bucket. */ i = eqs_index++; if (i == eqs_alloc) eqs = (struct equivclass *) xrealloc (eqs, (eqs_alloc*=2) * sizeof(*eqs)); eqs[i].next = *bucket; eqs[i].hash = h; eqs[i].line = ip; eqs[i].length = length; *bucket = i; break; } else if (eqs[i].hash == h && (eqs[i].length == length || varies) && ! line_cmp (eqs[i].line, eqs[i].length, ip, length)) /* Reuse existing equivalence class. */ break; /* Maybe increase the size of the line table. */ if (line == alloc_lines) { /* Double (alloc_lines - linbuf_base) by adding to alloc_lines. */ alloc_lines = 2 * alloc_lines - linbuf_base; cureqs = (int *) xrealloc (cureqs, alloc_lines * sizeof (*cureqs)); linbuf = (char const **) xrealloc (linbuf + linbuf_base, (alloc_lines - linbuf_base) * sizeof (*linbuf)) - linbuf_base; } linbuf[line] = ip; cureqs[line] = i; ++line; } current->buffered_lines = line; for (i = 0; ; i++) { /* Record the line start for lines in the suffix that we care about. Record one more line start than lines, so that we can compute the length of any buffered line. */ if (line == alloc_lines) { /* Double (alloc_lines - linbuf_base) by adding to alloc_lines. */ alloc_lines = 2 * alloc_lines - linbuf_base; linbuf = (char const **) xrealloc (linbuf + linbuf_base, (alloc_lines - linbuf_base) * sizeof (*linbuf)) - linbuf_base; } linbuf[line] = (char const *) p; if ((char const *) p == bufend) { linbuf[line] -= (char const *) p == incomplete_tail; break; } if (context <= i && no_diff_means_no_output) break; line++; while (*p++ != '\n') ; } /* Done with cache in local variables. */ current->linbuf = linbuf; current->valid_lines = line; current->alloc_lines = alloc_lines; current->equivs = cureqs; equivs = eqs; equivs_alloc = eqs_alloc; equivs_index = eqs_index; } /* Prepare the end of the text. Make sure it's initialized. Make sure text ends in a newline, but remember that we had to add one unless -B is in effect. */ static void prepare_text_end (current) struct file_data *current; { size_t buffered_chars = current->buffered_chars; char *p = current->buffer; if (buffered_chars == 0 || p[buffered_chars - 1] == '\n') current->missing_newline = 0; else { p[buffered_chars++] = '\n'; current->buffered_chars = buffered_chars; current->missing_newline = ! ignore_blank_lines_flag; } /* Don't use uninitialized storage when planting or using sentinels. */ if (p) bzero (p + buffered_chars, sizeof (word)); } /* Given a vector of two file_data objects, find the identical prefixes and suffixes of each object. */ static void find_identical_ends (filevec) struct file_data filevec[]; { word *w0, *w1; char *p0, *p1, *buffer0, *buffer1; char const *end0, *beg0; char const **linbuf0, **linbuf1; int i, lines; size_t n0, n1, tem; int alloc_lines0, alloc_lines1; int buffered_prefix, prefix_count, prefix_mask; slurp (&filevec[0]); if (filevec[0].desc != filevec[1].desc) slurp (&filevec[1]); else { filevec[1].buffer = filevec[0].buffer; filevec[1].bufsize = filevec[0].bufsize; filevec[1].buffered_chars = filevec[0].buffered_chars; } for (i = 0; i < 2; i++) prepare_text_end (&filevec[i]); /* Find identical prefix. */ p0 = buffer0 = filevec[0].buffer; p1 = buffer1 = filevec[1].buffer; n0 = filevec[0].buffered_chars; n1 = filevec[1].buffered_chars; if (p0 == p1) /* The buffers are the same; sentinels won't work. */ p0 = p1 += n1; else { /* Insert end sentinels, in this case characters that are guaranteed to make the equality test false, and thus terminate the loop. */ if (n0 < n1) p0[n0] = ~p1[n0]; else p1[n1] = ~p0[n1]; /* Loop until first mismatch, or to the sentinel characters. */ /* Compare a word at a time for speed. */ w0 = (word *) p0; w1 = (word *) p1; while (*w0++ == *w1++) ; --w0, --w1; /* Do the last few bytes of comparison a byte at a time. */ p0 = (char *) w0; p1 = (char *) w1; while (*p0++ == *p1++) ; --p0, --p1; /* Don't mistakenly count missing newline as part of prefix. */ if (ROBUST_OUTPUT_STYLE (output_style) && (buffer0 + n0 - filevec[0].missing_newline < p0) != (buffer1 + n1 - filevec[1].missing_newline < p1)) --p0, --p1; } /* Now P0 and P1 point at the first nonmatching characters. */ /* Skip back to last line-beginning in the prefix, and then discard up to HORIZON_LINES lines from the prefix. */ i = horizon_lines; while (p0 != buffer0 && (p0[-1] != '\n' || i--)) --p0, --p1; /* Record the prefix. */ filevec[0].prefix_end = p0; filevec[1].prefix_end = p1; /* Find identical suffix. */ /* P0 and P1 point beyond the last chars not yet compared. */ p0 = buffer0 + n0; p1 = buffer1 + n1; if (! ROBUST_OUTPUT_STYLE (output_style) || filevec[0].missing_newline == filevec[1].missing_newline) { end0 = p0; /* Addr of last char in file 0. */ /* Get value of P0 at which we should stop scanning backward: this is when either P0 or P1 points just past the last char of the identical prefix. */ beg0 = filevec[0].prefix_end + (n0 < n1 ? 0 : n0 - n1); /* Scan back until chars don't match or we reach that point. */ while (p0 != beg0) if (*--p0 != *--p1) { /* Point at the first char of the matching suffix. */ ++p0, ++p1; beg0 = p0; break; } /* Are we at a line-beginning in both files? If not, add the rest of this line to the main body. Discard up to HORIZON_LINES lines from the identical suffix. Also, discard one extra line, because shift_boundaries may need it. */ i = horizon_lines + !((buffer0 == p0 || p0[-1] == '\n') && (buffer1 == p1 || p1[-1] == '\n')); while (i-- && p0 != end0) while (*p0++ != '\n') ; p1 += p0 - beg0; } /* Record the suffix. */ filevec[0].suffix_begin = p0; filevec[1].suffix_begin = p1; /* Calculate number of lines of prefix to save. prefix_count == 0 means save the whole prefix; we need this with for options like -D that output the whole file. We also need it for options like -F that output some preceding line; at least we will need to find the last few lines, but since we don't know how many, it's easiest to find them all. Otherwise, prefix_count != 0. Save just prefix_count lines at start of the line buffer; they'll be moved to the proper location later. Handle 1 more line than the context says (because we count 1 too many), rounded up to the next power of 2 to speed index computation. */ if (no_diff_means_no_output && ! function_regexp_list) { for (prefix_count = 1; prefix_count < context + 1; prefix_count *= 2) ; prefix_mask = prefix_count - 1; alloc_lines0 = prefix_count + GUESS_LINES (0, 0, p0 - filevec[0].prefix_end) + context; } else { prefix_count = 0; prefix_mask = ~0; alloc_lines0 = GUESS_LINES (0, 0, n0); } lines = 0; linbuf0 = (char const **) xmalloc (alloc_lines0 * sizeof (*linbuf0)); /* If the prefix is needed, find the prefix lines. */ if (! (no_diff_means_no_output && filevec[0].prefix_end == p0 && filevec[1].prefix_end == p1)) { p0 = buffer0; end0 = filevec[0].prefix_end; while (p0 != end0) { int l = lines++ & prefix_mask; if (l == alloc_lines0) linbuf0 = (char const **) xrealloc (linbuf0, (alloc_lines0 *= 2) * sizeof(*linbuf0)); linbuf0[l] = p0; while (*p0++ != '\n') ; } } buffered_prefix = prefix_count && context < lines ? context : lines; /* Allocate line buffer 1. */ tem = prefix_count ? filevec[1].suffix_begin - buffer1 : n1; alloc_lines1 = (buffered_prefix + GUESS_LINES (lines, filevec[1].prefix_end - buffer1, tem) + context); linbuf1 = (char const **) xmalloc (alloc_lines1 * sizeof (*linbuf1)); if (buffered_prefix != lines) { /* Rotate prefix lines to proper location. */ for (i = 0; i < buffered_prefix; i++) linbuf1[i] = linbuf0[(lines - context + i) & prefix_mask]; for (i = 0; i < buffered_prefix; i++) linbuf0[i] = linbuf1[i]; } /* Initialize line buffer 1 from line buffer 0. */ for (i = 0; i < buffered_prefix; i++) linbuf1[i] = linbuf0[i] - buffer0 + buffer1; /* Record the line buffer, adjusted so that linbuf*[0] points at the first differing line. */ filevec[0].linbuf = linbuf0 + buffered_prefix; filevec[1].linbuf = linbuf1 + buffered_prefix; filevec[0].linbuf_base = filevec[1].linbuf_base = - buffered_prefix; filevec[0].alloc_lines = alloc_lines0 - buffered_prefix; filevec[1].alloc_lines = alloc_lines1 - buffered_prefix; filevec[0].prefix_lines = filevec[1].prefix_lines = lines; } /* Largest primes less than some power of two, for nbuckets. Values range from useful to preposterous. If one of these numbers isn't prime after all, don't blame it on me, blame it on primes (6) . . . */ static int const primes[] = { 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, /* Preposterously large . . . */ 134217689, 268435399, 536870909, 1073741789, 2147483647, 0 }; /* Given a vector of two file_data objects, read the file associated with each one, and build the table of equivalence classes. Return 1 if either file appears to be a binary file. If PRETEND_BINARY is nonzero, pretend they are binary regardless. */ int read_files (filevec, pretend_binary) struct file_data filevec[]; int pretend_binary; { int i; int skip_test = always_text_flag | pretend_binary; int appears_binary = pretend_binary | sip (&filevec[0], skip_test); if (filevec[0].desc != filevec[1].desc) appears_binary |= sip (&filevec[1], skip_test | appears_binary); else { filevec[1].buffer = filevec[0].buffer; filevec[1].bufsize = filevec[0].bufsize; filevec[1].buffered_chars = filevec[0].buffered_chars; } if (appears_binary) return 1; find_identical_ends (filevec); equivs_alloc = filevec[0].alloc_lines + filevec[1].alloc_lines + 1; equivs = (struct equivclass *) xmalloc (equivs_alloc * sizeof (struct equivclass)); /* Equivalence class 0 is permanently safe for lines that were not hashed. Real equivalence classes start at 1. */ equivs_index = 1; for (i = 0; primes[i] < equivs_alloc / 3; i++) if (! primes[i]) abort (); nbuckets = primes[i]; buckets = (int *) xmalloc (nbuckets * sizeof (*buckets)); bzero (buckets, nbuckets * sizeof (*buckets)); for (i = 0; i < 2; ++i) find_and_hash_each_line (&filevec[i]); filevec[0].equiv_max = filevec[1].equiv_max = equivs_index; free (equivs); free (buckets); return 0; } diffutils-2.4/context.c100444 74720 14 31557 5437442262 14127 0ustar eggertguest/* Context-format output routines for GNU DIFF. Copyright (C) 1988, 89, 91, 92, 93 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "diff.h" static struct change *find_hunk PARAMS((struct change *)); static void find_function PARAMS((struct file_data const *, int, char const **, size_t *)); static void mark_ignorable PARAMS((struct change *)); static void pr_context_hunk PARAMS((struct change *)); static void pr_unidiff_hunk PARAMS((struct change *)); static void print_context_label PARAMS ((char const *, struct file_data *, char const *)); static void print_context_number_range PARAMS((struct file_data const *, int, int)); static void print_unidiff_number_range PARAMS((struct file_data const *, int, int)); /* Last place find_function started searching from. */ static int find_function_last_search; /* The value find_function returned when it started searching there. */ static int find_function_last_match; /* Print a label for a context diff, with a file name and date or a label. */ static void print_context_label (mark, inf, label) char const *mark; struct file_data *inf; char const *label; { if (label) fprintf (outfile, "%s %s\n", mark, label); else /* See Posix.2 section 4.17.6.1.4 for this format. */ fprintf (outfile, "%s %s\t%s", mark, inf->name, ctime (&inf->stat.st_mtime)); } /* Print a header for a context diff, with the file names and dates. */ void print_context_header (inf, unidiff_flag) struct file_data inf[]; int unidiff_flag; { if (unidiff_flag) { print_context_label ("---", &inf[0], file_label[0]); print_context_label ("+++", &inf[1], file_label[1]); } else { print_context_label ("***", &inf[0], file_label[0]); print_context_label ("---", &inf[1], file_label[1]); } } /* Print an edit script in context format. */ void print_context_script (script, unidiff_flag) struct change *script; int unidiff_flag; { if (ignore_blank_lines_flag || ignore_regexp_list) mark_ignorable (script); else { struct change *e; for (e = script; e; e = e->link) e->ignore = 0; } find_function_last_search = - files[0].prefix_lines; find_function_last_match = find_function_last_search - 1; if (unidiff_flag) print_script (script, find_hunk, pr_unidiff_hunk); else print_script (script, find_hunk, pr_context_hunk); } /* Print a pair of line numbers with a comma, translated for file FILE. If the second number is not greater, use the first in place of it. Args A and B are internal line numbers. We print the translated (real) line numbers. */ static void print_context_number_range (file, a, b) struct file_data const *file; int a, b; { int trans_a, trans_b; translate_range (file, a, b, &trans_a, &trans_b); /* Note: we can have B < A in the case of a range of no lines. In this case, we should print the line number before the range, which is B. */ if (trans_b > trans_a) fprintf (outfile, "%d,%d", trans_a, trans_b); else fprintf (outfile, "%d", trans_b); } /* Print a portion of an edit script in context format. HUNK is the beginning of the portion to be printed. The end is marked by a `link' that has been nulled out. Prints out lines from both files, and precedes each line with the appropriate flag-character. */ static void pr_context_hunk (hunk) struct change *hunk; { int first0, last0, first1, last1, show_from, show_to, i; struct change *next; char const *prefix; char const *function; size_t function_length; FILE *out; /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &first0, &last0, &first1, &last1, &show_from, &show_to); if (!show_from && !show_to) return; /* Include a context's width before and after. */ i = - files[0].prefix_lines; first0 = max (first0 - context, i); first1 = max (first1 - context, i); last0 = min (last0 + context, files[0].valid_lines - 1); last1 = min (last1 + context, files[1].valid_lines - 1); /* If desired, find the preceding function definition line in file 0. */ function = 0; if (function_regexp_list) find_function (&files[0], first0, &function, &function_length); begin_output (); out = outfile; /* If we looked for and found a function this is part of, include its name in the header of the diff section. */ fprintf (out, "***************"); if (function) { fprintf (out, " "); fwrite (function, 1, min (function_length - 1, 40), out); } fprintf (out, "\n*** "); print_context_number_range (&files[0], first0, last0); fprintf (out, " ****\n"); if (show_from) { next = hunk; for (i = first0; i <= last0; i++) { /* Skip past changes that apply (in file 0) only to lines before line I. */ while (next && next->line0 + next->deleted <= i) next = next->link; /* Compute the marking for line I. */ prefix = " "; if (next && next->line0 <= i) /* The change NEXT covers this line. If lines were inserted here in file 1, this is "changed". Otherwise it is "deleted". */ prefix = (next->inserted > 0 ? "!" : "-"); print_1_line (prefix, &files[0].linbuf[i]); } } fprintf (out, "--- "); print_context_number_range (&files[1], first1, last1); fprintf (out, " ----\n"); if (show_to) { next = hunk; for (i = first1; i <= last1; i++) { /* Skip past changes that apply (in file 1) only to lines before line I. */ while (next && next->line1 + next->inserted <= i) next = next->link; /* Compute the marking for line I. */ prefix = " "; if (next && next->line1 <= i) /* The change NEXT covers this line. If lines were deleted here in file 0, this is "changed". Otherwise it is "inserted". */ prefix = (next->deleted > 0 ? "!" : "+"); print_1_line (prefix, &files[1].linbuf[i]); } } } /* Print a pair of line numbers with a comma, translated for file FILE. If the second number is smaller, use the first in place of it. If the numbers are equal, print just one number. Args A and B are internal line numbers. We print the translated (real) line numbers. */ static void print_unidiff_number_range (file, a, b) struct file_data const *file; int a, b; { int trans_a, trans_b; translate_range (file, a, b, &trans_a, &trans_b); /* Note: we can have B < A in the case of a range of no lines. In this case, we should print the line number before the range, which is B. */ if (trans_b <= trans_a) fprintf (outfile, trans_b == trans_a ? "%d" : "%d,0", trans_b); else fprintf (outfile, "%d,%d", trans_a, trans_b - trans_a + 1); } /* Print a portion of an edit script in unidiff format. HUNK is the beginning of the portion to be printed. The end is marked by a `link' that has been nulled out. Prints out lines from both files, and precedes each line with the appropriate flag-character. */ static void pr_unidiff_hunk (hunk) struct change *hunk; { int first0, last0, first1, last1, show_from, show_to, i, j, k; struct change *next; char const *function; size_t function_length; FILE *out; /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &first0, &last0, &first1, &last1, &show_from, &show_to); if (!show_from && !show_to) return; /* Include a context's width before and after. */ i = - files[0].prefix_lines; first0 = max (first0 - context, i); first1 = max (first1 - context, i); last0 = min (last0 + context, files[0].valid_lines - 1); last1 = min (last1 + context, files[1].valid_lines - 1); /* If desired, find the preceding function definition line in file 0. */ function = 0; if (function_regexp_list) find_function (&files[0], first0, &function, &function_length); begin_output (); out = outfile; fprintf (out, "@@ -"); print_unidiff_number_range (&files[0], first0, last0); fprintf (out, " +"); print_unidiff_number_range (&files[1], first1, last1); fprintf (out, " @@"); /* If we looked for and found a function this is part of, include its name in the header of the diff section. */ if (function) { putc (' ', out); fwrite (function, 1, min (function_length - 1, 40), out); } putc ('\n', out); next = hunk; i = first0; j = first1; while (i <= last0 || j <= last1) { /* If the line isn't a difference, output the context from file 0. */ if (!next || i < next->line0) { putc (tab_align_flag ? '\t' : ' ', out); print_1_line (0, &files[0].linbuf[i++]); j++; } else { /* For each difference, first output the deleted part. */ k = next->deleted; while (k--) { putc ('-', out); if (tab_align_flag) putc ('\t', out); print_1_line (0, &files[0].linbuf[i++]); } /* Then output the inserted part. */ k = next->inserted; while (k--) { putc ('+', out); if (tab_align_flag) putc ('\t', out); print_1_line (0, &files[1].linbuf[j++]); } /* We're done with this hunk, so on to the next! */ next = next->link; } } } /* Scan a (forward-ordered) edit script for the first place that more than 2*CONTEXT unchanged lines appear, and return a pointer to the `struct change' for the last change before those lines. */ static struct change * find_hunk (start) struct change *start; { struct change *prev; int top0, top1; int thresh; do { /* Compute number of first line in each file beyond this changed. */ top0 = start->line0 + start->deleted; top1 = start->line1 + start->inserted; prev = start; start = start->link; /* Threshold distance is 2*CONTEXT between two non-ignorable changes, but only CONTEXT if one is ignorable. */ thresh = ((prev->ignore || (start && start->ignore)) ? context : 2 * context + 1); /* It is not supposed to matter which file we check in the end-test. If it would matter, crash. */ if (start && start->line0 - top0 != start->line1 - top1) abort (); } while (start /* Keep going if less than THRESH lines elapse before the affected line. */ && start->line0 < top0 + thresh); return prev; } /* Set the `ignore' flag properly in each change in SCRIPT. It should be 1 if all the lines inserted or deleted in that change are ignorable lines. */ static void mark_ignorable (script) struct change *script; { while (script) { struct change *next = script->link; int first0, last0, first1, last1, deletes, inserts; /* Turn this change into a hunk: detach it from the others. */ script->link = 0; /* Determine whether this change is ignorable. */ analyze_hunk (script, &first0, &last0, &first1, &last1, &deletes, &inserts); /* Reconnect the chain as before. */ script->link = next; /* If the change is ignorable, mark it. */ script->ignore = (!deletes && !inserts); /* Advance to the following change. */ script = next; } } /* Find the last function-header line in FILE prior to line number LINENUM. This is a line containing a match for the regexp in `function_regexp'. Store the address of the line text into LINEP and the length of the line into LENP. Do not store anything if no function-header is found. */ static void find_function (file, linenum, linep, lenp) struct file_data const *file; int linenum; char const **linep; size_t *lenp; { int i = linenum; int last = find_function_last_search; find_function_last_search = i; while (--i >= last) { /* See if this line is what we want. */ struct regexp_list *r; char const *line = file->linbuf[i]; size_t len = file->linbuf[i + 1] - line; for (r = function_regexp_list; r; r = r->next) if (0 <= re_search (&r->buf, line, len, 0, len, 0)) { *linep = line; *lenp = len; find_function_last_match = i; return; } } /* If we search back to where we started searching the previous time, find the line we found last time. */ if (find_function_last_match >= - file->prefix_lines) { i = find_function_last_match; *linep = file->linbuf[i]; *lenp = file->linbuf[i + 1] - *linep; return; } return; } diffutils-2.4/ed.c100444 74720 14 12250 5437442262 13020 0ustar eggertguest/* Output routines for ed-script format. Copyright (C) 1988, 89, 91, 92, 93 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "diff.h" static void print_ed_hunk PARAMS((struct change *)); static void print_rcs_hunk PARAMS((struct change *)); static void pr_forward_ed_hunk PARAMS((struct change *)); /* Print our script as ed commands. */ void print_ed_script (script) struct change *script; { print_script (script, find_reverse_change, print_ed_hunk); } /* Print a hunk of an ed diff */ static void print_ed_hunk (hunk) struct change *hunk; { int f0, l0, f1, l1; int deletes, inserts; #if 0 hunk = flip_script (hunk); #endif #ifdef DEBUG debug_script (hunk); #endif /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &f0, &l0, &f1, &l1, &deletes, &inserts); if (!deletes && !inserts) return; begin_output (); /* Print out the line number header for this hunk */ print_number_range (',', &files[0], f0, l0); fprintf (outfile, "%c\n", change_letter (inserts, deletes)); /* Print new/changed lines from second file, if needed */ if (inserts) { int i; int inserting = 1; for (i = f1; i <= l1; i++) { /* Resume the insert, if we stopped. */ if (! inserting) fprintf (outfile, "%da\n", i - f1 + translate_line_number (&files[0], f0) - 1); inserting = 1; /* If the file's line is just a dot, it would confuse `ed'. So output it with a double dot, and set the flag LEADING_DOT so that we will output another ed-command later to change the double dot into a single dot. */ if (files[1].linbuf[i][0] == '.' && files[1].linbuf[i][1] == '\n') { fprintf (outfile, "..\n"); fprintf (outfile, ".\n"); /* Now change that double dot to the desired single dot. */ fprintf (outfile, "%ds/^\\.\\././\n", i - f1 + translate_line_number (&files[0], f0)); inserting = 0; } else /* Line is not `.', so output it unmodified. */ print_1_line ("", &files[1].linbuf[i]); } /* End insert mode, if we are still in it. */ if (inserting) fprintf (outfile, ".\n"); } } /* Print change script in the style of ed commands, but print the changes in the order they appear in the input files, which means that the commands are not truly useful with ed. */ void pr_forward_ed_script (script) struct change *script; { print_script (script, find_change, pr_forward_ed_hunk); } static void pr_forward_ed_hunk (hunk) struct change *hunk; { int i; int f0, l0, f1, l1; int deletes, inserts; /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &f0, &l0, &f1, &l1, &deletes, &inserts); if (!deletes && !inserts) return; begin_output (); fprintf (outfile, "%c", change_letter (inserts, deletes)); print_number_range (' ', files, f0, l0); fprintf (outfile, "\n"); /* If deletion only, print just the number range. */ if (!inserts) return; /* For insertion (with or without deletion), print the number range and the lines from file 2. */ for (i = f1; i <= l1; i++) print_1_line ("", &files[1].linbuf[i]); fprintf (outfile, ".\n"); } /* Print in a format somewhat like ed commands except that each insert command states the number of lines it inserts. This format is used for RCS. */ void print_rcs_script (script) struct change *script; { print_script (script, find_change, print_rcs_hunk); } /* Print a hunk of an RCS diff */ static void print_rcs_hunk (hunk) struct change *hunk; { int i; int f0, l0, f1, l1; int deletes, inserts; int tf0, tl0, tf1, tl1; /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &f0, &l0, &f1, &l1, &deletes, &inserts); if (!deletes && !inserts) return; begin_output (); translate_range (&files[0], f0, l0, &tf0, &tl0); if (deletes) { fprintf (outfile, "d"); /* For deletion, print just the starting line number from file 0 and the number of lines deleted. */ fprintf (outfile, "%d %d\n", tf0, (tl0 >= tf0 ? tl0 - tf0 + 1 : 1)); } if (inserts) { fprintf (outfile, "a"); /* Take last-line-number from file 0 and # lines from file 1. */ translate_range (&files[1], f1, l1, &tf1, &tl1); fprintf (outfile, "%d %d\n", tl0, (tl1 >= tf1 ? tl1 - tf1 + 1 : 1)); /* Print the inserted lines. */ for (i = f1; i <= l1; i++) print_1_line ("", &files[1].linbuf[i]); } } diffutils-2.4/normal.c100444 74720 14 4246 5437442262 13706 0ustar eggertguest/* Normal-format output routines for GNU DIFF. Copyright (C) 1988, 1989, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "diff.h" static void print_normal_hunk PARAMS((struct change *)); /* Print the edit-script SCRIPT as a normal diff. INF points to an array of descriptions of the two files. */ void print_normal_script (script) struct change *script; { print_script (script, find_change, print_normal_hunk); } /* Print a hunk of a normal diff. This is a contiguous portion of a complete edit script, describing changes in consecutive lines. */ static void print_normal_hunk (hunk) struct change *hunk; { int first0, last0, first1, last1, deletes, inserts; register int i; /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &first0, &last0, &first1, &last1, &deletes, &inserts); if (!deletes && !inserts) return; begin_output (); /* Print out the line number header for this hunk */ print_number_range (',', &files[0], first0, last0); fprintf (outfile, "%c", change_letter (inserts, deletes)); print_number_range (',', &files[1], first1, last1); fprintf (outfile, "\n"); /* Print the lines that the first file has. */ if (deletes) for (i = first0; i <= last0; i++) print_1_line ("<", &files[0].linbuf[i]); if (inserts && deletes) fprintf (outfile, "---\n"); /* Print the lines that the second file has. */ if (inserts) for (i = first1; i <= last1; i++) print_1_line (">", &files[1].linbuf[i]); } diffutils-2.4/ifdef.c100444 74720 14 23404 5445363652 13514 0ustar eggertguest/* #ifdef-format output routines for GNU DIFF. Copyright (C) 1989, 91, 92, 93 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. No author or distributor accepts responsibility to anyone for the consequences of using it or for whether it serves any particular purpose or works at all, unless he says so in writing. Refer to the GNU DIFF General Public License for full details. Everyone is granted permission to copy, modify and redistribute GNU DIFF, but only under the conditions described in the GNU DIFF General Public License. A copy of this license is supposed to have been given to you along with GNU DIFF so you can know your rights and responsibilities. It should be in a file named COPYING. Among other things, the copyright notice and this notice must be preserved on all copies. */ #include "diff.h" struct group { struct file_data const *file; int from, upto; /* start and limit lines for this group of lines */ }; static char *format_group PARAMS((FILE *, char *, int, struct group const[])); static char *scan_char_literal PARAMS((char *, int *)); static char *scan_printf_spec PARAMS((char *)); static int groups_letter_value PARAMS((struct group const[], int)); static void format_ifdef PARAMS((char *, int, int, int, int)); static void print_ifdef_hunk PARAMS((struct change *)); static void print_ifdef_lines PARAMS((FILE *, char *, struct group const *)); static int next_line; /* Print the edit-script SCRIPT as a merged #ifdef file. */ void print_ifdef_script (script) struct change *script; { next_line = - files[0].prefix_lines; print_script (script, find_change, print_ifdef_hunk); if (next_line < files[0].valid_lines) { begin_output (); format_ifdef (group_format[UNCHANGED], next_line, files[0].valid_lines, next_line - files[0].valid_lines + files[1].valid_lines, files[1].valid_lines); } } /* Print a hunk of an ifdef diff. This is a contiguous portion of a complete edit script, describing changes in consecutive lines. */ static void print_ifdef_hunk (hunk) struct change *hunk; { int first0, last0, first1, last1, deletes, inserts; char *format; /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &first0, &last0, &first1, &last1, &deletes, &inserts); if (inserts) format = deletes ? group_format[CHANGED] : group_format[NEW]; else if (deletes) format = group_format[OLD]; else return; begin_output (); /* Print lines up to this change. */ if (next_line < first0) format_ifdef (group_format[UNCHANGED], next_line, first0, next_line - first0 + first1, first1); /* Print this change. */ next_line = last0 + 1; format_ifdef (format, first0, next_line, first1, last1 + 1); } /* Print a set of lines according to FORMAT. Lines BEG0 up to END0 are from the first file; lines BEG1 up to END1 are from the second file. */ static void format_ifdef (format, beg0, end0, beg1, end1) char *format; int beg0, end0, beg1, end1; { struct group groups[2]; groups[0].file = &files[0]; groups[0].from = beg0; groups[0].upto = end0; groups[1].file = &files[1]; groups[1].from = beg1; groups[1].upto = end1; format_group (outfile, format, '\0', groups); } /* Print to file OUT a set of lines according to FORMAT. The format ends at the first free instance of ENDCHAR. Yield the address of the terminating character. GROUPS specifies which lines to print. If OUT is zero, do not actually print anything; just scan the format. */ static char * format_group (out, format, endchar, groups) register FILE *out; char *format; int endchar; struct group const groups[]; { register char c; register char *f = format; while ((c = *f) != endchar && c != 0) { f++; if (c == '%') { char *spec = f; switch ((c = *f++)) { case '%': break; case '(': /* Print if-then-else format e.g. `%(n=1?thenpart:elsepart)'. */ { int i, value[2]; FILE *thenout, *elseout; for (i = 0; i < 2; i++) { if (isdigit (*f)) { value[i] = atoi (f); while (isdigit (*++f)) continue; } else { value[i] = groups_letter_value (groups, *f++); if (value[i] < 0) goto bad_format; } if (*f++ != "=?"[i]) goto bad_format; } if (value[0] == value[1]) thenout = out, elseout = 0; else thenout = 0, elseout = out; f = format_group (thenout, f, ':', groups); if (*f) { f = format_group (elseout, f + 1, ')', groups); if (*f) f++; } } continue; case '<': /* Print lines deleted from first file. */ print_ifdef_lines (out, line_format[OLD], &groups[0]); continue; case '=': /* Print common lines. */ print_ifdef_lines (out, line_format[UNCHANGED], &groups[0]); continue; case '>': /* Print lines inserted from second file. */ print_ifdef_lines (out, line_format[NEW], &groups[1]); continue; default: { int value; char *speclim; f = scan_printf_spec (spec); if (!f) goto bad_format; speclim = f; c = *f++; switch (c) { case '\'': f = scan_char_literal (f, &value); if (!f) goto bad_format; break; default: value = groups_letter_value (groups, c); if (value < 0) goto bad_format; break; } if (out) { /* Temporarily replace e.g. "%3dnx" with "%3d\0x". */ *speclim = 0; fprintf (out, spec - 1, value); /* Undo the temporary replacement. */ *speclim = c; } } continue; bad_format: c = '%'; f = spec; break; } } if (out) putc (c, out); } return f; } /* For the line group pair G, return the number corresponding to LETTER. Return -1 if LETTER is not a group format letter. */ static int groups_letter_value (g, letter) struct group const g[]; int letter; { if (isupper (letter)) { g++; letter = tolower (letter); } switch (letter) { case 'e': return translate_line_number (g->file, g->from) - 1; case 'f': return translate_line_number (g->file, g->from); case 'l': return translate_line_number (g->file, g->upto) - 1; case 'm': return translate_line_number (g->file, g->upto); case 'n': return g->upto - g->from; default: return -1; } } /* Print to file OUT, using FORMAT to print the line group GROUP. But do nothing if OUT is zero. */ static void print_ifdef_lines (out, format, group) register FILE *out; char *format; struct group const *group; { struct file_data const *file = group->file; char const * const *linbuf = file->linbuf; int from = group->from, upto = group->upto; if (!out) return; /* If possible, use a single fwrite; it's faster. */ if (!tab_expand_flag && format[0] == '%') { if (format[1] == 'l' && format[2] == '\n' && !format[3]) { fwrite (linbuf[from], sizeof (char), linbuf[upto] + (linbuf[upto][-1] != '\n') - linbuf[from], out); return; } if (format[1] == 'L' && !format[2]) { fwrite (linbuf[from], sizeof (char), linbuf[upto] - linbuf[from], out); return; } } for (; from < upto; from++) { register char c; register char *f = format; while ((c = *f++) != 0) { if (c == '%') { char *spec = f; switch ((c = *f++)) { case '%': break; case 'l': output_1_line (linbuf[from], linbuf[from + 1] - (linbuf[from + 1][-1] == '\n'), 0, 0); continue; case 'L': output_1_line (linbuf[from], linbuf[from + 1], 0, 0); continue; default: { int value; char *speclim; f = scan_printf_spec (spec); if (!f) goto bad_format; speclim = f; c = *f++; switch (c) { case '\'': f = scan_char_literal (f, &value); if (!f) goto bad_format; break; case 'n': value = translate_line_number (file, from); break; default: goto bad_format; } /* Temporarily replace e.g. "%3dnx" with "%3d\0x". */ *speclim = 0; fprintf (out, spec - 1, value); /* Undo the temporary replacement. */ *speclim = c; } continue; bad_format: c = '%'; f = spec; break; } } putc (c, out); } } } /* Scan the character literal represented in the string LIT; LIT points just after the initial apostrophe. Put the literal's value into *INTPTR. Yield the address of the first character after the closing apostrophe, or zero if the literal is ill-formed. */ static char * scan_char_literal (lit, intptr) char *lit; int *intptr; { register char *p = lit; int value, digits; char c = *p++; switch (c) { case 0: case '\'': return 0; case '\\': value = 0; while ((c = *p++) != '\'') { unsigned digit = c - '0'; if (8 <= digit) return 0; value = 8 * value + digit; } digits = p - lit - 2; if (! (1 <= digits && digits <= 3)) return 0; break; default: value = c; if (*p++ != '\'') return 0; break; } *intptr = value; return p; } /* Scan optional printf-style SPEC of the form `-*[0-9]*(.[0-9]*)?[cdoxX]'. Return the address of the character following SPEC, or zero if failure. */ static char * scan_printf_spec (spec) register char *spec; { register unsigned char c; while ((c = *spec++) == '-') continue; while (isdigit (c)) c = *spec++; if (c == '.') while (isdigit (c = *spec++)) continue; switch (c) { case 'c': case 'd': case 'o': case 'x': case 'X': return spec; default: return 0; } } diffutils-2.4/util.c100444 74720 14 42676 5444737146 13432 0ustar eggertguest/* Support routines for GNU DIFF. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "diff.h" /* Queue up one-line messages to be printed at the end, when -l is specified. Each message is recorded with a `struct msg'. */ struct msg { struct msg *next; char const *format; char const *arg1; char const *arg2; char const *arg3; char const *arg4; }; /* Head of the chain of queues messages. */ static struct msg *msg_chain; /* Tail of the chain of queues messages. */ static struct msg **msg_chain_end = &msg_chain; /* Use when a system call returns non-zero status. TEXT should normally be the file name. */ void perror_with_name (text) char const *text; { int e = errno; fprintf (stderr, "%s: ", program); errno = e; perror (text); } /* Use when a system call returns non-zero status and that is fatal. */ void pfatal_with_name (text) char const *text; { int e = errno; print_message_queue (); fprintf (stderr, "%s: ", program); errno = e; perror (text); exit (2); } /* Print an error message from the format-string FORMAT with args ARG1 and ARG2. */ void error (format, arg, arg1) char const *format, *arg, *arg1; { fprintf (stderr, "%s: ", program); fprintf (stderr, format, arg, arg1); fprintf (stderr, "\n"); } /* Print an error message containing the string TEXT, then exit. */ void fatal (m) char const *m; { print_message_queue (); error ("%s", m, 0); exit (2); } /* Like printf, except if -l in effect then save the message and print later. This is used for things like "binary files differ" and "Only in ...". */ void message (format, arg1, arg2) char const *format, *arg1, *arg2; { message5 (format, arg1, arg2, 0, 0); } void message5 (format, arg1, arg2, arg3, arg4) char const *format, *arg1, *arg2, *arg3, *arg4; { if (paginate_flag) { struct msg *new = (struct msg *) xmalloc (sizeof (struct msg)); new->format = format; new->arg1 = concat (arg1, "", ""); new->arg2 = concat (arg2, "", ""); new->arg3 = arg3 ? concat (arg3, "", "") : 0; new->arg4 = arg4 ? concat (arg4, "", "") : 0; new->next = 0; *msg_chain_end = new; msg_chain_end = &new->next; } else { if (sdiff_help_sdiff) putchar (' '); printf (format, arg1, arg2, arg3, arg4); } } /* Output all the messages that were saved up by calls to `message'. */ void print_message_queue () { struct msg *m; for (m = msg_chain; m; m = m->next) printf (m->format, m->arg1, m->arg2, m->arg3, m->arg4); } /* Call before outputting the results of comparing files NAME0 and NAME1 to set up OUTFILE, the stdio stream for the output to go to. Usually, OUTFILE is just stdout. But when -l was specified we fork off a `pr' and make OUTFILE a pipe to it. `pr' then outputs to our stdout. */ static char const *current_name0; static char const *current_name1; static int current_depth; void setup_output (name0, name1, depth) char const *name0, *name1; int depth; { current_name0 = name0; current_name1 = name1; current_depth = depth; outfile = 0; } static pid_t pr_pid; void begin_output () { char *name; if (outfile != 0) return; /* Construct the header of this piece of diff. */ name = xmalloc (strlen (current_name0) + strlen (current_name1) + strlen (switch_string) + 7); /* Posix.2 section 4.17.6.1.1 specifies this format. But there are some bugs in the first printing (IEEE Std 1003.2-1992 p 251 l 3304): it says that we must print only the last component of the pathnames, and it requires two spaces after "diff" if there are no options. These requirements are silly and do not match historical practice. */ sprintf (name, "diff%s %s %s", switch_string, current_name0, current_name1); if (paginate_flag) { int pipes[2]; /* Fork a `pr' and make OUTFILE a pipe to it. */ if (pipe (pipes) < 0) pfatal_with_name ("pipe"); fflush (stdout); pr_pid = vfork (); if (pr_pid < 0) pfatal_with_name ("vfork"); if (pr_pid == 0) { close (pipes[1]); if (pipes[0] != STDIN_FILENO) { if (dup2 (pipes[0], STDIN_FILENO) < 0) pfatal_with_name ("dup2"); close (pipes[0]); } execl (PR_FILE_NAME, PR_FILE_NAME, "-f", "-h", name, 0); pfatal_with_name (PR_FILE_NAME); } else { close (pipes[0]); outfile = fdopen (pipes[1], "w"); } } else { /* If -l was not specified, output the diff straight to `stdout'. */ outfile = stdout; /* If handling multiple files (because scanning a directory), print which files the following output is about. */ if (current_depth > 0) printf ("%s\n", name); } free (name); /* A special header is needed at the beginning of context output. */ switch (output_style) { case OUTPUT_CONTEXT: print_context_header (files, 0); break; case OUTPUT_UNIFIED: print_context_header (files, 1); break; default: break; } } /* Call after the end of output of diffs for one file. Close OUTFILE and get rid of the `pr' subfork. */ void finish_output () { if (outfile != 0 && outfile != stdout) { int wstatus; if (ferror (outfile)) fatal ("write error"); if (fclose (outfile) != 0) pfatal_with_name ("write error"); #if HAVE_WAITPID if (waitpid (pr_pid, &wstatus, 0) < 0) pfatal_with_name ("waitpid"); #else for (;;) { pid_t w = wait (&wstatus); if (w < 0) pfatal_with_name ("wait"); if (w == pr_pid) break; } #endif if (! WIFEXITED (wstatus) || WEXITSTATUS (wstatus) != 0) fatal ("subsidiary pr failed"); } outfile = 0; } /* Compare two lines (typically one from each input file) according to the command line options. Return 1 if the lines differ, like `memcmp'. */ int line_cmp (s1, len1, s2, len2) char const *s1, *s2; size_t len1, len2; { register unsigned char const *t1, *t2; register unsigned char end_char = line_end_char; /* Check first for exact identity. If that is true, return 0 immediately. This detects the common case of exact identity faster than complete comparison would. */ if (len1 == len2 && memcmp (s1, s2, len1) == 0) return 0; /* Not exactly identical, but perhaps they match anyway when case or white space is ignored. */ if (ignore_case_flag | ignore_space_change_flag | ignore_all_space_flag) { t1 = (unsigned char const *) s1; t2 = (unsigned char const *) s2; while (1) { register unsigned char c1 = *t1++; register unsigned char c2 = *t2++; /* Ignore horizontal white space if -b or -w is specified. */ if (ignore_all_space_flag) { /* For -w, just skip past any white space. */ while (isspace (c1) && c1 != end_char) c1 = *t1++; while (isspace (c2) && c2 != end_char) c2 = *t2++; } else if (ignore_space_change_flag) { /* For -b, advance past any sequence of white space in line 1 and consider it just one Space, or nothing at all if it is at the end of the line. */ if (isspace (c1)) { while (c1 != end_char) { c1 = *t1++; if (! isspace (c1)) { --t1; c1 = ' '; break; } } } /* Likewise for line 2. */ if (isspace (c2)) { while (c2 != end_char) { c2 = *t2++; if (! isspace (c2)) { --t2; c2 = ' '; break; } } } } /* Upcase all letters if -i is specified. */ if (ignore_case_flag) { if (islower (c1)) c1 = toupper (c1); if (islower (c2)) c2 = toupper (c2); } if (c1 != c2) break; if (c1 == end_char) return 0; } } return (1); } /* Find the consecutive changes at the start of the script START. Return the last link before the first gap. */ struct change * find_change (start) struct change *start; { return start; } struct change * find_reverse_change (start) struct change *start; { return start; } /* Divide SCRIPT into pieces by calling HUNKFUN and print each piece with PRINTFUN. Both functions take one arg, an edit script. HUNKFUN is called with the tail of the script and returns the last link that belongs together with the start of the tail. PRINTFUN takes a subscript which belongs together (with a null link at the end) and prints it. */ void print_script (script, hunkfun, printfun) struct change *script; struct change * (*hunkfun) PARAMS((struct change *)); void (*printfun) PARAMS((struct change *)); { struct change *next = script; while (next) { struct change *this, *end; /* Find a set of changes that belong together. */ this = next; end = (*hunkfun) (next); /* Disconnect them from the rest of the changes, making them a hunk, and remember the rest for next iteration. */ next = end->link; end->link = 0; #ifdef DEBUG debug_script (this); #endif /* Print this hunk. */ (*printfun) (this); /* Reconnect the script so it will all be freed properly. */ end->link = next; } } /* Print the text of a single line LINE, flagging it with the characters in LINE_FLAG (which say whether the line is inserted, deleted, changed, etc.). */ void print_1_line (line_flag, line) char const *line_flag; char const * const *line; { char const *text = line[0], *limit = line[1]; /* Help the compiler. */ FILE *out = outfile; /* Help the compiler some more. */ char const *flag_format = 0; /* If -T was specified, use a Tab between the line-flag and the text. Otherwise use a Space (as Unix diff does). Print neither space nor tab if line-flags are empty. */ if (line_flag && *line_flag) { flag_format = tab_align_flag ? "%s\t" : "%s "; fprintf (out, flag_format, line_flag); } output_1_line (text, limit, flag_format, line_flag); if ((!line_flag || line_flag[0]) && limit[-1] != '\n' && line_end_char == '\n') fprintf (out, "\n\\ No newline at end of file\n"); } /* Output a line from TEXT up to LIMIT. Without -t, output verbatim. With -t, expand white space characters to spaces, and if FLAG_FORMAT is nonzero, output it with argument LINE_FLAG after every internal carriage return, so that tab stops continue to line up. */ void output_1_line (text, limit, flag_format, line_flag) char const *text, *limit, *flag_format, *line_flag; { if (!tab_expand_flag) fwrite (text, sizeof (char), limit - text, outfile); else { register FILE *out = outfile; register char c; register char const *t = text; register unsigned column = 0; while (t < limit) switch ((c = *t++)) { case '\t': { unsigned spaces = TAB_WIDTH - column % TAB_WIDTH; column += spaces; do putc (' ', out); while (--spaces); } break; case '\r': putc (c, out); if (flag_format && t < limit && *t != '\n') fprintf (out, flag_format, line_flag); column = 0; break; case '\b': if (column == 0) continue; column--; putc (c, out); break; default: if (isgraph (c) || c == ' ') column++; putc (c, out); break; } } } int change_letter (inserts, deletes) int inserts, deletes; { if (!inserts) return 'd'; else if (!deletes) return 'a'; else return 'c'; } /* Translate an internal line number (an index into diff's table of lines) into an actual line number in the input file. The internal line number is LNUM. FILE points to the data on the file. Internal line numbers count from 0 starting after the prefix. Actual line numbers count from 1 within the entire file. */ int translate_line_number (file, lnum) struct file_data const *file; int lnum; { return lnum + file->prefix_lines + 1; } void translate_range (file, a, b, aptr, bptr) struct file_data const *file; int a, b; int *aptr, *bptr; { *aptr = translate_line_number (file, a - 1) + 1; *bptr = translate_line_number (file, b + 1) - 1; } /* Print a pair of line numbers with SEPCHAR, translated for file FILE. If the two numbers are identical, print just one number. Args A and B are internal line numbers. We print the translated (real) line numbers. */ void print_number_range (sepchar, file, a, b) char sepchar; struct file_data *file; int a, b; { int trans_a, trans_b; translate_range (file, a, b, &trans_a, &trans_b); /* Note: we can have B < A in the case of a range of no lines. In this case, we should print the line number before the range, which is B. */ if (trans_b > trans_a) fprintf (outfile, "%d%c%d", trans_a, sepchar, trans_b); else fprintf (outfile, "%d", trans_b); } /* Look at a hunk of edit script and report the range of lines in each file that it applies to. HUNK is the start of the hunk, which is a chain of `struct change'. The first and last line numbers of file 0 are stored in *FIRST0 and *LAST0, and likewise for file 1 in *FIRST1 and *LAST1. Note that these are internal line numbers that count from 0. If no lines from file 0 are deleted, then FIRST0 is LAST0+1. Also set *DELETES nonzero if any lines of file 0 are deleted and set *INSERTS nonzero if any lines of file 1 are inserted. If only ignorable lines are inserted or deleted, both are set to 0. */ void analyze_hunk (hunk, first0, last0, first1, last1, deletes, inserts) struct change *hunk; int *first0, *last0, *first1, *last1; int *deletes, *inserts; { int l0, l1, show_from, show_to; int i; int trivial = ignore_blank_lines_flag || ignore_regexp_list; struct change *next; show_from = show_to = 0; *first0 = hunk->line0; *first1 = hunk->line1; next = hunk; do { l0 = next->line0 + next->deleted - 1; l1 = next->line1 + next->inserted - 1; show_from += next->deleted; show_to += next->inserted; for (i = next->line0; i <= l0 && trivial; i++) if (!ignore_blank_lines_flag || files[0].linbuf[i][0] != '\n') { struct regexp_list *r; char const *line = files[0].linbuf[i]; int len = files[0].linbuf[i + 1] - line; for (r = ignore_regexp_list; r; r = r->next) if (0 <= re_search (&r->buf, line, len, 0, len, 0)) break; /* Found a match. Ignore this line. */ /* If we got all the way through the regexp list without finding a match, then it's nontrivial. */ if (!r) trivial = 0; } for (i = next->line1; i <= l1 && trivial; i++) if (!ignore_blank_lines_flag || files[1].linbuf[i][0] != '\n') { struct regexp_list *r; char const *line = files[1].linbuf[i]; int len = files[1].linbuf[i + 1] - line; for (r = ignore_regexp_list; r; r = r->next) if (0 <= re_search (&r->buf, line, len, 0, len, 0)) break; /* Found a match. Ignore this line. */ /* If we got all the way through the regexp list without finding a match, then it's nontrivial. */ if (!r) trivial = 0; } } while ((next = next->link) != 0); *last0 = l0; *last1 = l1; /* If all inserted or deleted lines are ignorable, tell the caller to ignore this hunk. */ if (trivial) show_from = show_to = 0; *deletes = show_from; *inserts = show_to; } /* malloc a block of memory, with fatal error message if we can't do it. */ VOID * xmalloc (size) size_t size; { register VOID *value; if (size == 0) size = 1; value = (VOID *) malloc (size); if (!value) fatal ("virtual memory exhausted"); return value; } /* realloc a block of memory, with fatal error message if we can't do it. */ VOID * xrealloc (old, size) VOID *old; size_t size; { register VOID *value; if (size == 0) size = 1; value = (VOID *) realloc (old, size); if (!value) fatal ("virtual memory exhausted"); return value; } /* Concatenate three strings, returning a newly malloc'd string. */ char * concat (s1, s2, s3) char const *s1, *s2, *s3; { size_t len = strlen (s1) + strlen (s2) + strlen (s3); char *new = xmalloc (len + 1); sprintf (new, "%s%s%s", s1, s2, s3); return new; } /* Yield the newly malloc'd pathname of the file in DIR whose filename is FILE. */ char * dir_file_pathname (dir, file) char const *dir, *file; { return concat (dir, "/" + (*dir && dir[strlen (dir) - 1] == '/'), file); } void debug_script (sp) struct change *sp; { fflush (stdout); for (; sp; sp = sp->link) fprintf (stderr, "%3d %3d delete %d insert %d\n", sp->line0, sp->line1, sp->deleted, sp->inserted); fflush (stderr); } #if !HAVE_MEMCHR char * memchr (s, c, n) char *s; int c; size_t n; { unsigned char *p = (unsigned char *) s, *lim = p + n; for (; p < lim; p++) if (*p == c) return (char *) p; return 0; } #endif diffutils-2.4/dir.c100444 74720 14 14010 5444737160 13204 0ustar eggertguest/* Read, sort and compare two directories. Used for GNU DIFF. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "diff.h" /* Read the directory named by DIR and store into DIRDATA a sorted vector of filenames for its contents. DIR->desc == -1 means this directory is known to be nonexistent, so set DIRDATA to an empty vector. Return -1 (setting errno) if error, 0 otherwise. */ struct dirdata { char const **names; /* Sorted names of files in dir, 0-terminated. */ char *data; /* Allocated storage for file names. */ }; static int compare_names PARAMS((void const *, void const *)); static int dir_sort PARAMS((struct file_data const *, struct dirdata *)); static int dir_sort (dir, dirdata) struct file_data const *dir; struct dirdata *dirdata; { register struct dirent *next; register int i; /* Address of block containing the files that are described. */ char const **names; /* Number of files in directory. */ size_t nnames; /* Allocated and used storage for file name data. */ char *data; size_t data_alloc, data_used; dirdata->names = 0; dirdata->data = 0; nnames = 0; data = 0; if (dir->desc != -1) { /* Open the directory and check for errors. */ register DIR *reading = opendir (dir->name); if (!reading) return -1; /* Initialize the table of filenames. */ data_alloc = max (1, (size_t) dir->stat.st_size); data_used = 0; dirdata->data = data = xmalloc (data_alloc); /* Read the directory entries, and insert the subfiles into the `data' table. */ while ((errno = 0, (next = readdir (reading)) != 0)) { char *d_name = next->d_name; size_t d_size; /* Ignore the files `.' and `..' */ if (d_name[0] == '.' && (d_name[1] == 0 || (d_name[1] == '.' && d_name[2] == 0))) continue; if (excluded_filename (d_name)) continue; d_size = strlen (d_name) + 1; while (data_alloc < data_used + d_size) dirdata->data = data = xrealloc (data, data_alloc *= 2); memcpy (data + data_used, d_name, d_size); data_used += d_size; nnames++; } if (errno) { int e = errno; closedir (reading); errno = e; return -1; } #if VOID_CLOSEDIR closedir (reading); #else if (closedir (reading) != 0) return -1; #endif } /* Create the `names' table from the `data' table. */ dirdata->names = names = (char const **) xmalloc (sizeof (char *) * (nnames + 1)); for (i = 0; i < nnames; i++) { names[i] = data; data += strlen (data) + 1; } names[nnames] = 0; /* Sort the table. */ qsort (names, nnames, sizeof (char *), compare_names); return 0; } /* Sort the files now in the table. */ static int compare_names (file1, file2) void const *file1, *file2; { return strcmp (* (char const *const *) file1, * (char const *const *) file2); } /* Compare the contents of two directories named in FILEVEC[0] and FILEVEC[1]. This is a top-level routine; it does everything necessary for diff on two directories. FILEVEC[0].desc == -1 says directory FILEVEC[0] doesn't exist, but pretend it is empty. Likewise for FILEVEC[1]. HANDLE_FILE is a caller-provided subroutine called to handle each file. It gets five operands: dir and name (rel to original working dir) of file in dir 0, dir and name pathname of file in dir 1, and the recursion depth. For a file that appears in only one of the dirs, one of the name-args to HANDLE_FILE is zero. DEPTH is the current depth in recursion, used for skipping top-level files by the -S option. Returns the maximum of all the values returned by HANDLE_FILE, or 2 if trouble is encountered in opening files. */ int diff_dirs (filevec, handle_file, depth) struct file_data const filevec[]; int (*handle_file) PARAMS((char const *, char const *, char const *, char const *, int)); int depth; { struct dirdata dirdata[2]; int val = 0; /* Return value. */ int i; /* Get sorted contents of both dirs. */ for (i = 0; i < 2; i++) if (dir_sort (&filevec[i], &dirdata[i]) != 0) { perror_with_name (filevec[i].name); val = 2; } if (val == 0) { register char const * const *names0 = dirdata[0].names; register char const * const *names1 = dirdata[1].names; char const *name0 = filevec[0].name; char const *name1 = filevec[1].name; /* If `-S name' was given, and this is the topmost level of comparison, ignore all file names less than the specified starting name. */ if (dir_start_file && depth == 0) { while (*names0 && strcmp (*names0, dir_start_file) < 0) names0++; while (*names1 && strcmp (*names1, dir_start_file) < 0) names1++; } /* Loop while files remain in one or both dirs. */ while (*names0 || *names1) { /* Compare next name in dir 0 with next name in dir 1. At the end of a dir, pretend the "next name" in that dir is very large. */ int nameorder = (!*names0 ? 1 : !*names1 ? -1 : strcmp (*names0, *names1)); int v1 = (*handle_file) (name0, 0 < nameorder ? 0 : *names0++, name1, nameorder < 0 ? 0 : *names1++, depth + 1); if (v1 > val) val = v1; } } for (i = 0; i < 2; i++) { if (dirdata[i].names) free (dirdata[i].names); if (dirdata[i].data) free (dirdata[i].data); } return val; } diffutils-2.4/version.c100666 74720 14 136 5445445743 14071 0ustar eggertguest/* Version number of GNU diff. */ #include char const version_string[] = "2.4"; diffutils-2.4/diff.h100444 74720 14 27154 5444737173 13364 0ustar eggertguest/* Shared definitions for GNU DIFF Copyright (C) 1988, 89, 91, 92, 93 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include "system.h" #include "regex.h" #ifndef PR_FILE_NAME #define PR_FILE_NAME "/bin/pr" #endif #define TAB_WIDTH 8 /* Variables for command line options */ #ifndef GDIFF_MAIN #define EXTERN extern #else #define EXTERN #endif enum output_style { /* Default output style. */ OUTPUT_NORMAL, /* Output the differences with lines of context before and after (-c). */ OUTPUT_CONTEXT, /* Output the differences in a unified context diff format (-u). */ OUTPUT_UNIFIED, /* Output the differences as commands suitable for `ed' (-e). */ OUTPUT_ED, /* Output the diff as a forward ed script (-f). */ OUTPUT_FORWARD_ED, /* Like -f, but output a count of changed lines in each "command" (-n). */ OUTPUT_RCS, /* Output merged #ifdef'd file (-D). */ OUTPUT_IFDEF, /* Output sdiff style (-y). */ OUTPUT_SDIFF }; /* True for output styles that are robust, i.e. can handle a file that ends in a non-newline. */ #define ROBUST_OUTPUT_STYLE(S) ((S) != OUTPUT_ED && (S) != OUTPUT_FORWARD_ED) EXTERN enum output_style output_style; /* Nonzero if output cannot be generated for identical files. */ EXTERN int no_diff_means_no_output; /* Number of lines of context to show in each set of diffs. This is zero when context is not to be shown. */ EXTERN int context; /* Consider all files as text files (-a). Don't interpret codes over 0177 as implying a "binary file". */ EXTERN int always_text_flag; /* Number of lines to keep in identical prefix and suffix. */ EXTERN int horizon_lines; /* Ignore changes in horizontal white space (-b). */ EXTERN int ignore_space_change_flag; /* Ignore all horizontal white space (-w). */ EXTERN int ignore_all_space_flag; /* Ignore changes that affect only blank lines (-B). */ EXTERN int ignore_blank_lines_flag; /* 1 if lines may match even if their lengths are different. This depends on various options. */ EXTERN int length_varies; /* 1 if files may match even if their contents are not byte-for-byte identical. This depends on various options. */ EXTERN int ignore_some_changes; /* Ignore differences in case of letters (-i). */ EXTERN int ignore_case_flag; /* File labels for `-c' output headers (-L). */ EXTERN char *file_label[2]; struct regexp_list { struct re_pattern_buffer buf; struct regexp_list *next; }; /* Regexp to identify function-header lines (-F). */ EXTERN struct regexp_list *function_regexp_list; /* Ignore changes that affect only lines matching this regexp (-I). */ EXTERN struct regexp_list *ignore_regexp_list; /* Say only whether files differ, not how (-q). */ EXTERN int no_details_flag; /* Report files compared that match (-s). Normally nothing is output when that happens. */ EXTERN int print_file_same_flag; /* character that ends a line. Currently this is always `\n'. */ EXTERN char line_end_char; /* Output the differences with exactly 8 columns added to each line so that any tabs in the text line up properly (-T). */ EXTERN int tab_align_flag; /* Expand tabs in the output so the text lines up properly despite the characters added to the front of each line (-t). */ EXTERN int tab_expand_flag; /* In directory comparison, specify file to start with (-S). All file names less than this name are ignored. */ EXTERN char *dir_start_file; /* If a file is new (appears in only one dir) include its entire contents (-N). Then `patch' would create the file with appropriate contents. */ EXTERN int entire_new_file_flag; /* If a file is new (appears in only the second dir) include its entire contents (-P). Then `patch' would create the file with appropriate contents. */ EXTERN int unidirectional_new_file_flag; /* Pipe each file's output through pr (-l). */ EXTERN int paginate_flag; enum line_class { /* Lines taken from just the first file. */ OLD, /* Lines taken from just the second file. */ NEW, /* Lines common to both files. */ UNCHANGED, /* A hunk containing both old and new lines (line groups only). */ CHANGED }; /* Line group formats for old, new, unchanged, and changed groups. */ EXTERN char *group_format[CHANGED + 1]; /* Line formats for old, new, and unchanged lines. */ EXTERN char *line_format[UNCHANGED + 1]; /* If using OUTPUT_SDIFF print extra information to help the sdiff filter. */ EXTERN int sdiff_help_sdiff; /* Tell OUTPUT_SDIFF to show only the left version of common lines. */ EXTERN int sdiff_left_only; /* Tell OUTPUT_SDIFF to not show common lines. */ EXTERN int sdiff_skip_common_lines; /* The half line width and column 2 offset for OUTPUT_SDIFF. */ EXTERN unsigned sdiff_half_width; EXTERN unsigned sdiff_column2_offset; /* String containing all the command options diff received, with spaces between and at the beginning but none at the end. If there were no options given, this string is empty. */ EXTERN char * switch_string; /* Nonzero means use heuristics for better speed. */ EXTERN int heuristic; /* Name of program the user invoked (for error messages). */ EXTERN char * program; /* The result of comparison is an "edit script": a chain of `struct change'. Each `struct change' represents one place where some lines are deleted and some are inserted. LINE0 and LINE1 are the first affected lines in the two files (origin 0). DELETED is the number of lines deleted here from file 0. INSERTED is the number of lines inserted here in file 1. If DELETED is 0 then LINE0 is the number of the line before which the insertion was done; vice versa for INSERTED and LINE1. */ struct change { struct change *link; /* Previous or next edit command */ int inserted; /* # lines of file 1 changed here. */ int deleted; /* # lines of file 0 changed here. */ int line0; /* Line number of 1st deleted line. */ int line1; /* Line number of 1st inserted line. */ char ignore; /* Flag used in context.c */ }; /* Structures that describe the input files. */ /* Data on one input file being compared. */ struct file_data { int desc; /* File descriptor */ char const *name; /* File name */ struct stat stat; /* File status from fstat() */ int dir_p; /* nonzero if file is a directory */ /* Buffer in which text of file is read. */ char * buffer; /* Allocated size of buffer. */ size_t bufsize; /* Number of valid characters now in the buffer. */ size_t buffered_chars; /* Array of pointers to lines in the file. */ char const **linbuf; /* linbuf_base <= buffered_lines <= valid_lines <= alloc_lines. linebuf[linbuf_base ... buffered_lines - 1] are possibly differing. linebuf[linbuf_base ... valid_lines - 1] contain valid data. linebuf[linbuf_base ... alloc_lines - 1] are allocated. */ int linbuf_base, buffered_lines, valid_lines, alloc_lines; /* Pointer to end of prefix of this file to ignore when hashing. */ char const *prefix_end; /* Count of lines in the prefix. There are this many lines in the file before linbuf[0]. */ int prefix_lines; /* Pointer to start of suffix of this file to ignore when hashing. */ char const *suffix_begin; /* Vector, indexed by line number, containing an equivalence code for each line. It is this vector that is actually compared with that of another file to generate differences. */ int *equivs; /* Vector, like the previous one except that the elements for discarded lines have been squeezed out. */ int *undiscarded; /* Vector mapping virtual line numbers (not counting discarded lines) to real ones (counting those lines). Both are origin-0. */ int *realindexes; /* Total number of nondiscarded lines. */ int nondiscarded_lines; /* Vector, indexed by real origin-0 line number, containing 1 for a line that is an insertion or a deletion. The results of comparison are stored here. */ char *changed_flag; /* 1 if file ends in a line with no final newline. */ int missing_newline; /* 1 more than the maximum equivalence value used for this or its sibling file. */ int equiv_max; }; /* Describe the two files currently being compared. */ EXTERN struct file_data files[2]; /* Stdio stream to output diffs to. */ EXTERN FILE *outfile; /* Declare various functions. */ /* analyze.c */ int diff_2_files PARAMS((struct file_data[], int)); /* context.c */ void print_context_header PARAMS((struct file_data[], int)); void print_context_script PARAMS((struct change *, int)); /* diff.c */ int excluded_filename PARAMS((char const *)); /* dir.c */ int diff_dirs PARAMS((struct file_data const[], int (*) PARAMS((char const *, char const *, char const *, char const *, int)), int)); /* ed.c */ void print_ed_script PARAMS((struct change *)); void pr_forward_ed_script PARAMS((struct change *)); /* ifdef.c */ void print_ifdef_script PARAMS((struct change *)); /* io.c */ int read_files PARAMS((struct file_data[], int)); int sip PARAMS((struct file_data *, int)); void slurp PARAMS((struct file_data *)); /* normal.c */ void print_normal_script PARAMS((struct change *)); /* rcs.c */ void print_rcs_script PARAMS((struct change *)); /* side.c */ void print_sdiff_script PARAMS((struct change *)); /* util.c */ VOID *xmalloc PARAMS((size_t)); VOID *xrealloc PARAMS((VOID *, size_t)); char *concat PARAMS((char const *, char const *, char const *)); char *dir_file_pathname PARAMS((char const *, char const *)); int change_letter PARAMS((int, int)); int line_cmp PARAMS((char const *, size_t, char const *, size_t)); int translate_line_number PARAMS((struct file_data const *, int)); struct change *find_change PARAMS((struct change *)); struct change *find_reverse_change PARAMS((struct change *)); void analyze_hunk PARAMS((struct change *, int *, int *, int *, int *, int *, int *)); void begin_output PARAMS((void)); void debug_script PARAMS((struct change *)); void error PARAMS((char const *, char const *, char const *)); void fatal PARAMS((char const *)); void finish_output PARAMS((void)); void message PARAMS((char const *, char const *, char const *)); void message5 PARAMS((char const *, char const *, char const *, char const *, char const *)); void output_1_line PARAMS((char const *, char const *, char const *, char const *)); void perror_with_name PARAMS((char const *)); void pfatal_with_name PARAMS((char const *)); void print_1_line PARAMS((char const *, char const * const *)); void print_message_queue PARAMS((void)); void print_number_range PARAMS((int, struct file_data *, int, int)); void print_script PARAMS((struct change *, struct change * (*) PARAMS((struct change *)), void (*) PARAMS((struct change *)))); void setup_output PARAMS((char const *, char const *, int)); void translate_range PARAMS((struct file_data const *, int, int, int *, int *)); /* version.c */ extern char const version_string[]; diffutils-2.4/regex.c100666 13437 1 511352 5407710174 13326 0ustar jimbdaemon/* Extended regular expression matching and search library, version 0.12. (Implements POSIX draft P10003.2/D11.2, except for internationalization features.) Copyright (C) 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* AIX requires this to be the first thing in the file. */ #if defined (_AIX) && !defined (REGEX_MALLOC) #pragma alloca #endif #define _GNU_SOURCE /* We need this for `regex.h', and perhaps for the Emacs include files. */ #include #ifdef HAVE_CONFIG_H #include "config.h" #endif /* The `emacs' switch turns on certain matching commands that make sense only in Emacs. */ #ifdef emacs #include "lisp.h" #include "buffer.h" #include "syntax.h" /* Emacs uses `NULL' as a predicate. */ #undef NULL #else /* not emacs */ #ifdef STDC_HEADERS #include #else char *malloc (); char *realloc (); #endif /* We used to test for `BSTRING' here, but only GCC and Emacs define `BSTRING', as far as I know, and neither of them use this code. */ #if HAVE_STRING_H || STDC_HEADERS #include #ifndef bcmp #define bcmp(s1, s2, n) memcmp ((s1), (s2), (n)) #endif #ifndef bcopy #define bcopy(s, d, n) memcpy ((d), (s), (n)) #endif #ifndef bzero #define bzero(s, n) memset ((s), 0, (n)) #endif #else #include #endif /* Define the syntax stuff for \<, \>, etc. */ /* This must be nonzero for the wordchar and notwordchar pattern commands in re_match_2. */ #ifndef Sword #define Sword 1 #endif #ifdef SYNTAX_TABLE extern char *re_syntax_table; #else /* not SYNTAX_TABLE */ /* How many characters in the character set. */ #define CHAR_SET_SIZE 256 static char re_syntax_table[CHAR_SET_SIZE]; static void init_syntax_once () { register int c; static int done = 0; if (done) return; bzero (re_syntax_table, sizeof re_syntax_table); for (c = 'a'; c <= 'z'; c++) re_syntax_table[c] = Sword; for (c = 'A'; c <= 'Z'; c++) re_syntax_table[c] = Sword; for (c = '0'; c <= '9'; c++) re_syntax_table[c] = Sword; re_syntax_table['_'] = Sword; done = 1; } #endif /* not SYNTAX_TABLE */ #define SYNTAX(c) re_syntax_table[c] #endif /* not emacs */ /* Get the interface, including the syntax bits. */ #include "regex.h" /* isalpha etc. are used for the character classes. */ #include /* Jim Meyering writes: "... Some ctype macros are valid only for character codes that isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when using /bin/cc or gcc but without giving an ansi option). So, all ctype uses should be through macros like ISPRINT... If STDC_HEADERS is defined, then autoconf has verified that the ctype macros don't need to be guarded with references to isascii. ... Defining isascii to 1 should let any compiler worth its salt eliminate the && through constant folding." */ #if ! defined (isascii) || defined (STDC_HEADERS) #undef isascii #define isascii(c) 1 #endif #ifdef isblank #define ISBLANK(c) (isascii (c) && isblank (c)) #else #define ISBLANK(c) ((c) == ' ' || (c) == '\t') #endif #ifdef isgraph #define ISGRAPH(c) (isascii (c) && isgraph (c)) #else #define ISGRAPH(c) (isascii (c) && isprint (c) && !isspace (c)) #endif #define ISPRINT(c) (isascii (c) && isprint (c)) #define ISDIGIT(c) (isascii (c) && isdigit (c)) #define ISALNUM(c) (isascii (c) && isalnum (c)) #define ISALPHA(c) (isascii (c) && isalpha (c)) #define ISCNTRL(c) (isascii (c) && iscntrl (c)) #define ISLOWER(c) (isascii (c) && islower (c)) #define ISPUNCT(c) (isascii (c) && ispunct (c)) #define ISSPACE(c) (isascii (c) && isspace (c)) #define ISUPPER(c) (isascii (c) && isupper (c)) #define ISXDIGIT(c) (isascii (c) && isxdigit (c)) #ifndef NULL #define NULL 0 #endif /* We remove any previous definition of `SIGN_EXTEND_CHAR', since ours (we hope) works properly with all combinations of machines, compilers, `char' and `unsigned char' argument types. (Per Bothner suggested the basic approach.) */ #undef SIGN_EXTEND_CHAR #if __STDC__ #define SIGN_EXTEND_CHAR(c) ((signed char) (c)) #else /* not __STDC__ */ /* As in Harbison and Steele. */ #define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128) #endif /* Should we use malloc or alloca? If REGEX_MALLOC is not defined, we use `alloca' instead of `malloc'. This is because using malloc in re_search* or re_match* could cause memory leaks when C-g is used in Emacs; also, malloc is slower and causes storage fragmentation. On the other hand, malloc is more portable, and easier to debug. Because we sometimes use alloca, some routines have to be macros, not functions -- `alloca'-allocated space disappears at the end of the function it is called in. */ #ifdef REGEX_MALLOC #define REGEX_ALLOCATE malloc #define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize) #else /* not REGEX_MALLOC */ /* Emacs already defines alloca, sometimes. */ #ifndef alloca /* Make alloca work the best possible way. */ #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not __GNUC__ */ #if HAVE_ALLOCA_H #include #else /* not __GNUC__ or HAVE_ALLOCA_H */ #ifndef _AIX /* Already did AIX, up at the top. */ char *alloca (); #endif /* not _AIX */ #endif /* not HAVE_ALLOCA_H */ #endif /* not __GNUC__ */ #endif /* not alloca */ #define REGEX_ALLOCATE alloca /* Assumes a `char *destination' variable. */ #define REGEX_REALLOCATE(source, osize, nsize) \ (destination = (char *) alloca (nsize), \ bcopy (source, destination, osize), \ destination) #endif /* not REGEX_MALLOC */ /* True if `size1' is non-NULL and PTR is pointing anywhere inside `string1' or just past its end. This works if PTR is NULL, which is a good thing. */ #define FIRST_STRING_P(ptr) \ (size1 && string1 <= (ptr) && (ptr) <= string1 + size1) /* (Re)Allocate N items of type T using malloc, or fail. */ #define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t))) #define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t))) #define RETALLOC_IF(addr, n, t) \ if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t) #define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t))) #define BYTEWIDTH 8 /* In bits. */ #define STREQ(s1, s2) ((strcmp (s1, s2) == 0)) #define MAX(a, b) ((a) > (b) ? (a) : (b)) #define MIN(a, b) ((a) < (b) ? (a) : (b)) typedef char boolean; #define false 0 #define true 1 /* These are the command codes that appear in compiled regular expressions. Some opcodes are followed by argument bytes. A command code can specify any interpretation whatsoever for its arguments. Zero bytes may appear in the compiled regular expression. The value of `exactn' is needed in search.c (search_buffer) in Emacs. So regex.h defines a symbol `RE_EXACTN_VALUE' to be 1; the value of `exactn' we use here must also be 1. */ typedef enum { no_op = 0, /* Followed by one byte giving n, then by n literal bytes. */ exactn = 1, /* Matches any (more or less) character. */ anychar, /* Matches any one char belonging to specified set. First following byte is number of bitmap bytes. Then come bytes for a bitmap saying which chars are in. Bits in each byte are ordered low-bit-first. A character is in the set if its bit is 1. A character too large to have a bit in the map is automatically not in the set. */ charset, /* Same parameters as charset, but match any character that is not one of those specified. */ charset_not, /* Start remembering the text that is matched, for storing in a register. Followed by one byte with the register number, in the range 0 to one less than the pattern buffer's re_nsub field. Then followed by one byte with the number of groups inner to this one. (This last has to be part of the start_memory only because we need it in the on_failure_jump of re_match_2.) */ start_memory, /* Stop remembering the text that is matched and store it in a memory register. Followed by one byte with the register number, in the range 0 to one less than `re_nsub' in the pattern buffer, and one byte with the number of inner groups, just like `start_memory'. (We need the number of inner groups here because we don't have any easy way of finding the corresponding start_memory when we're at a stop_memory.) */ stop_memory, /* Match a duplicate of something remembered. Followed by one byte containing the register number. */ duplicate, /* Fail unless at beginning of line. */ begline, /* Fail unless at end of line. */ endline, /* Succeeds if at beginning of buffer (if emacs) or at beginning of string to be matched (if not). */ begbuf, /* Analogously, for end of buffer/string. */ endbuf, /* Followed by two byte relative address to which to jump. */ jump, /* Same as jump, but marks the end of an alternative. */ jump_past_alt, /* Followed by two-byte relative address of place to resume at in case of failure. */ on_failure_jump, /* Like on_failure_jump, but pushes a placeholder instead of the current string position when executed. */ on_failure_keep_string_jump, /* Throw away latest failure point and then jump to following two-byte relative address. */ pop_failure_jump, /* Change to pop_failure_jump if know won't have to backtrack to match; otherwise change to jump. This is used to jump back to the beginning of a repeat. If what follows this jump clearly won't match what the repeat does, such that we can be sure that there is no use backtracking out of repetitions already matched, then we change it to a pop_failure_jump. Followed by two-byte address. */ maybe_pop_jump, /* Jump to following two-byte address, and push a dummy failure point. This failure point will be thrown away if an attempt is made to use it for a failure. A `+' construct makes this before the first repeat. Also used as an intermediary kind of jump when compiling an alternative. */ dummy_failure_jump, /* Push a dummy failure point and continue. Used at the end of alternatives. */ push_dummy_failure, /* Followed by two-byte relative address and two-byte number n. After matching N times, jump to the address upon failure. */ succeed_n, /* Followed by two-byte relative address, and two-byte number n. Jump to the address N times, then fail. */ jump_n, /* Set the following two-byte relative address to the subsequent two-byte number. The address *includes* the two bytes of number. */ set_number_at, wordchar, /* Matches any word-constituent character. */ notwordchar, /* Matches any char that is not a word-constituent. */ wordbeg, /* Succeeds if at word beginning. */ wordend, /* Succeeds if at word end. */ wordbound, /* Succeeds if at a word boundary. */ notwordbound /* Succeeds if not at a word boundary. */ #ifdef emacs ,before_dot, /* Succeeds if before point. */ at_dot, /* Succeeds if at point. */ after_dot, /* Succeeds if after point. */ /* Matches any character whose syntax is specified. Followed by a byte which contains a syntax code, e.g., Sword. */ syntaxspec, /* Matches any character whose syntax is not that specified. */ notsyntaxspec #endif /* emacs */ } re_opcode_t; /* Common operations on the compiled pattern. */ /* Store NUMBER in two contiguous bytes starting at DESTINATION. */ #define STORE_NUMBER(destination, number) \ do { \ (destination)[0] = (number) & 0377; \ (destination)[1] = (number) >> 8; \ } while (0) /* Same as STORE_NUMBER, except increment DESTINATION to the byte after where the number is stored. Therefore, DESTINATION must be an lvalue. */ #define STORE_NUMBER_AND_INCR(destination, number) \ do { \ STORE_NUMBER (destination, number); \ (destination) += 2; \ } while (0) /* Put into DESTINATION a number stored in two contiguous bytes starting at SOURCE. */ #define EXTRACT_NUMBER(destination, source) \ do { \ (destination) = *(source) & 0377; \ (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \ } while (0) #ifdef DEBUG static void extract_number (dest, source) int *dest; unsigned char *source; { int temp = SIGN_EXTEND_CHAR (*(source + 1)); *dest = *source & 0377; *dest += temp << 8; } #ifndef EXTRACT_MACROS /* To debug the macros. */ #undef EXTRACT_NUMBER #define EXTRACT_NUMBER(dest, src) extract_number (&dest, src) #endif /* not EXTRACT_MACROS */ #endif /* DEBUG */ /* Same as EXTRACT_NUMBER, except increment SOURCE to after the number. SOURCE must be an lvalue. */ #define EXTRACT_NUMBER_AND_INCR(destination, source) \ do { \ EXTRACT_NUMBER (destination, source); \ (source) += 2; \ } while (0) #ifdef DEBUG static void extract_number_and_incr (destination, source) int *destination; unsigned char **source; { extract_number (destination, *source); *source += 2; } #ifndef EXTRACT_MACROS #undef EXTRACT_NUMBER_AND_INCR #define EXTRACT_NUMBER_AND_INCR(dest, src) \ extract_number_and_incr (&dest, &src) #endif /* not EXTRACT_MACROS */ #endif /* DEBUG */ /* If DEBUG is defined, Regex prints many voluminous messages about what it is doing (if the variable `debug' is nonzero). If linked with the main program in `iregex.c', you can enter patterns and strings interactively. And if linked with the main program in `main.c' and the other test files, you can run the already-written tests. */ #ifdef DEBUG /* We use standard I/O for debugging. */ #include /* It is useful to test things that ``must'' be true when debugging. */ #include static int debug = 0; #define DEBUG_STATEMENT(e) e #define DEBUG_PRINT1(x) if (debug) printf (x) #define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2) #define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3) #define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4) #define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \ if (debug) print_partial_compiled_pattern (s, e) #define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \ if (debug) print_double_string (w, s1, sz1, s2, sz2) extern void printchar (); /* Print the fastmap in human-readable form. */ void print_fastmap (fastmap) char *fastmap; { unsigned was_a_range = 0; unsigned i = 0; while (i < (1 << BYTEWIDTH)) { if (fastmap[i++]) { was_a_range = 0; printchar (i - 1); while (i < (1 << BYTEWIDTH) && fastmap[i]) { was_a_range = 1; i++; } if (was_a_range) { printf ("-"); printchar (i - 1); } } } putchar ('\n'); } /* Print a compiled pattern string in human-readable form, starting at the START pointer into it and ending just before the pointer END. */ void print_partial_compiled_pattern (start, end) unsigned char *start; unsigned char *end; { int mcnt, mcnt2; unsigned char *p = start; unsigned char *pend = end; if (start == NULL) { printf ("(null)\n"); return; } /* Loop over pattern commands. */ while (p < pend) { printf ("%d:\t", p - start); switch ((re_opcode_t) *p++) { case no_op: printf ("/no_op"); break; case exactn: mcnt = *p++; printf ("/exactn/%d", mcnt); do { putchar ('/'); printchar (*p++); } while (--mcnt); break; case start_memory: mcnt = *p++; printf ("/start_memory/%d/%d", mcnt, *p++); break; case stop_memory: mcnt = *p++; printf ("/stop_memory/%d/%d", mcnt, *p++); break; case duplicate: printf ("/duplicate/%d", *p++); break; case anychar: printf ("/anychar"); break; case charset: case charset_not: { register int c, last = -100; register int in_range = 0; printf ("/charset [%s", (re_opcode_t) *(p - 1) == charset_not ? "^" : ""); assert (p + *p < pend); for (c = 0; c < 256; c++) if (c / 8 < *p && (p[1 + (c/8)] & (1 << (c % 8)))) { /* Are we starting a range? */ if (last + 1 == c && ! in_range) { putchar ('-'); in_range = 1; } /* Have we broken a range? */ else if (last + 1 != c && in_range) { printchar (last); in_range = 0; } if (! in_range) printchar (c); last = c; } if (in_range) printchar (last); putchar (']'); p += 1 + *p; } break; case begline: printf ("/begline"); break; case endline: printf ("/endline"); break; case on_failure_jump: extract_number_and_incr (&mcnt, &p); printf ("/on_failure_jump to %d", p + mcnt - start); break; case on_failure_keep_string_jump: extract_number_and_incr (&mcnt, &p); printf ("/on_failure_keep_string_jump to %d", p + mcnt - start); break; case dummy_failure_jump: extract_number_and_incr (&mcnt, &p); printf ("/dummy_failure_jump to %d", p + mcnt - start); break; case push_dummy_failure: printf ("/push_dummy_failure"); break; case maybe_pop_jump: extract_number_and_incr (&mcnt, &p); printf ("/maybe_pop_jump to %d", p + mcnt - start); break; case pop_failure_jump: extract_number_and_incr (&mcnt, &p); printf ("/pop_failure_jump to %d", p + mcnt - start); break; case jump_past_alt: extract_number_and_incr (&mcnt, &p); printf ("/jump_past_alt to %d", p + mcnt - start); break; case jump: extract_number_and_incr (&mcnt, &p); printf ("/jump to %d", p + mcnt - start); break; case succeed_n: extract_number_and_incr (&mcnt, &p); extract_number_and_incr (&mcnt2, &p); printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2); break; case jump_n: extract_number_and_incr (&mcnt, &p); extract_number_and_incr (&mcnt2, &p); printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2); break; case set_number_at: extract_number_and_incr (&mcnt, &p); extract_number_and_incr (&mcnt2, &p); printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2); break; case wordbound: printf ("/wordbound"); break; case notwordbound: printf ("/notwordbound"); break; case wordbeg: printf ("/wordbeg"); break; case wordend: printf ("/wordend"); #ifdef emacs case before_dot: printf ("/before_dot"); break; case at_dot: printf ("/at_dot"); break; case after_dot: printf ("/after_dot"); break; case syntaxspec: printf ("/syntaxspec"); mcnt = *p++; printf ("/%d", mcnt); break; case notsyntaxspec: printf ("/notsyntaxspec"); mcnt = *p++; printf ("/%d", mcnt); break; #endif /* emacs */ case wordchar: printf ("/wordchar"); break; case notwordchar: printf ("/notwordchar"); break; case begbuf: printf ("/begbuf"); break; case endbuf: printf ("/endbuf"); break; default: printf ("?%d", *(p-1)); } putchar ('\n'); } printf ("%d:\tend of pattern.\n", p - start); } void print_compiled_pattern (bufp) struct re_pattern_buffer *bufp; { unsigned char *buffer = bufp->buffer; print_partial_compiled_pattern (buffer, buffer + bufp->used); printf ("%d bytes used/%d bytes allocated.\n", bufp->used, bufp->allocated); if (bufp->fastmap_accurate && bufp->fastmap) { printf ("fastmap: "); print_fastmap (bufp->fastmap); } printf ("re_nsub: %d\t", bufp->re_nsub); printf ("regs_alloc: %d\t", bufp->regs_allocated); printf ("can_be_null: %d\t", bufp->can_be_null); printf ("newline_anchor: %d\n", bufp->newline_anchor); printf ("no_sub: %d\t", bufp->no_sub); printf ("not_bol: %d\t", bufp->not_bol); printf ("not_eol: %d\t", bufp->not_eol); printf ("syntax: %d\n", bufp->syntax); /* Perhaps we should print the translate table? */ } void print_double_string (where, string1, size1, string2, size2) const char *where; const char *string1; const char *string2; int size1; int size2; { unsigned this_char; if (where == NULL) printf ("(null)"); else { if (FIRST_STRING_P (where)) { for (this_char = where - string1; this_char < size1; this_char++) printchar (string1[this_char]); where = string2; } for (this_char = where - string2; this_char < size2; this_char++) printchar (string2[this_char]); } } #else /* not DEBUG */ #undef assert #define assert(e) #define DEBUG_STATEMENT(e) #define DEBUG_PRINT1(x) #define DEBUG_PRINT2(x1, x2) #define DEBUG_PRINT3(x1, x2, x3) #define DEBUG_PRINT4(x1, x2, x3, x4) #define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) #define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) #endif /* not DEBUG */ /* Set by `re_set_syntax' to the current regexp syntax to recognize. Can also be assigned to arbitrarily: each pattern buffer stores its own syntax, so it can be changed between regex compilations. */ reg_syntax_t re_syntax_options = RE_SYNTAX_EMACS; /* Specify the precise syntax of regexps for compilation. This provides for compatibility for various utilities which historically have different, incompatible syntaxes. The argument SYNTAX is a bit mask comprised of the various bits defined in regex.h. We return the old syntax. */ reg_syntax_t re_set_syntax (syntax) reg_syntax_t syntax; { reg_syntax_t ret = re_syntax_options; re_syntax_options = syntax; return ret; } /* This table gives an error message for each of the error codes listed in regex.h. Obviously the order here has to be same as there. */ static const char *re_error_msg[] = { NULL, /* REG_NOERROR */ "No match", /* REG_NOMATCH */ "Invalid regular expression", /* REG_BADPAT */ "Invalid collation character", /* REG_ECOLLATE */ "Invalid character class name", /* REG_ECTYPE */ "Trailing backslash", /* REG_EESCAPE */ "Invalid back reference", /* REG_ESUBREG */ "Unmatched [ or [^", /* REG_EBRACK */ "Unmatched ( or \\(", /* REG_EPAREN */ "Unmatched \\{", /* REG_EBRACE */ "Invalid content of \\{\\}", /* REG_BADBR */ "Invalid range end", /* REG_ERANGE */ "Memory exhausted", /* REG_ESPACE */ "Invalid preceding regular expression", /* REG_BADRPT */ "Premature end of regular expression", /* REG_EEND */ "Regular expression too big", /* REG_ESIZE */ "Unmatched ) or \\)", /* REG_ERPAREN */ }; /* Avoiding alloca during matching, to placate r_alloc. */ /* Define MATCH_MAY_ALLOCATE if we need to make sure that the searching and matching functions should not call alloca. On some systems, alloca is implemented in terms of malloc, and if we're using the relocating allocator routines, then malloc could cause a relocation, which might (if the strings being searched are in the ralloc heap) shift the data out from underneath the regexp routines. Here's another reason to avoid allocation: Emacs insists on processing input from X in a signal handler; processing X input may call malloc; if input arrives while a matching routine is calling malloc, then we're scrod. But Emacs can't just block input while calling matching routines; then we don't notice interrupts when they come in. So, Emacs blocks input around all regexp calls except the matching calls, which it leaves unprotected, in the faith that they will not malloc. */ /* Normally, this is fine. */ #define MATCH_MAY_ALLOCATE /* But under some circumstances, it's not. */ #if defined (emacs) || (defined (REL_ALLOC) && defined (C_ALLOCA)) #undef MATCH_MAY_ALLOCATE #endif /* Failure stack declarations and macros; both re_compile_fastmap and re_match_2 use a failure stack. These have to be macros because of REGEX_ALLOCATE. */ /* Number of failure points for which to initially allocate space when matching. If this number is exceeded, we allocate more space, so it is not a hard limit. */ #ifndef INIT_FAILURE_ALLOC #define INIT_FAILURE_ALLOC 5 #endif /* Roughly the maximum number of failure points on the stack. Would be exactly that if always used MAX_FAILURE_SPACE each time we failed. This is a variable only so users of regex can assign to it; we never change it ourselves. */ int re_max_failures = 2000; typedef const unsigned char *fail_stack_elt_t; typedef struct { fail_stack_elt_t *stack; unsigned size; unsigned avail; /* Offset of next open position. */ } fail_stack_type; #define FAIL_STACK_EMPTY() (fail_stack.avail == 0) #define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0) #define FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size) #define FAIL_STACK_TOP() (fail_stack.stack[fail_stack.avail]) /* Initialize `fail_stack'. Do `return -2' if the alloc fails. */ #ifdef MATCH_MAY_ALLOCATE #define INIT_FAIL_STACK() \ do { \ fail_stack.stack = (fail_stack_elt_t *) \ REGEX_ALLOCATE (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t)); \ \ if (fail_stack.stack == NULL) \ return -2; \ \ fail_stack.size = INIT_FAILURE_ALLOC; \ fail_stack.avail = 0; \ } while (0) #else #define INIT_FAIL_STACK() \ do { \ fail_stack.avail = 0; \ } while (0) #endif /* Double the size of FAIL_STACK, up to approximately `re_max_failures' items. Return 1 if succeeds, and 0 if either ran out of memory allocating space for it or it was already too large. REGEX_REALLOCATE requires `destination' be declared. */ #define DOUBLE_FAIL_STACK(fail_stack) \ ((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS \ ? 0 \ : ((fail_stack).stack = (fail_stack_elt_t *) \ REGEX_REALLOCATE ((fail_stack).stack, \ (fail_stack).size * sizeof (fail_stack_elt_t), \ ((fail_stack).size << 1) * sizeof (fail_stack_elt_t)), \ \ (fail_stack).stack == NULL \ ? 0 \ : ((fail_stack).size <<= 1, \ 1))) /* Push PATTERN_OP on FAIL_STACK. Return 1 if was able to do so and 0 if ran out of memory allocating space to do so. */ #define PUSH_PATTERN_OP(pattern_op, fail_stack) \ ((FAIL_STACK_FULL () \ && !DOUBLE_FAIL_STACK (fail_stack)) \ ? 0 \ : ((fail_stack).stack[(fail_stack).avail++] = pattern_op, \ 1)) /* This pushes an item onto the failure stack. Must be a four-byte value. Assumes the variable `fail_stack'. Probably should only be called from within `PUSH_FAILURE_POINT'. */ #define PUSH_FAILURE_ITEM(item) \ fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item /* The complement operation. Assumes `fail_stack' is nonempty. */ #define POP_FAILURE_ITEM() fail_stack.stack[--fail_stack.avail] /* Used to omit pushing failure point id's when we're not debugging. */ #ifdef DEBUG #define DEBUG_PUSH PUSH_FAILURE_ITEM #define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_ITEM () #else #define DEBUG_PUSH(item) #define DEBUG_POP(item_addr) #endif /* Push the information about the state we will need if we ever fail back to it. Requires variables fail_stack, regstart, regend, reg_info, and num_regs be declared. DOUBLE_FAIL_STACK requires `destination' be declared. Does `return FAILURE_CODE' if runs out of memory. */ #define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) \ do { \ char *destination; \ /* Must be int, so when we don't save any registers, the arithmetic \ of 0 + -1 isn't done as unsigned. */ \ int this_reg; \ \ DEBUG_STATEMENT (failure_id++); \ DEBUG_STATEMENT (nfailure_points_pushed++); \ DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id); \ DEBUG_PRINT2 (" Before push, next avail: %d\n", (fail_stack).avail);\ DEBUG_PRINT2 (" size: %d\n", (fail_stack).size);\ \ DEBUG_PRINT2 (" slots needed: %d\n", NUM_FAILURE_ITEMS); \ DEBUG_PRINT2 (" available: %d\n", REMAINING_AVAIL_SLOTS); \ \ /* Ensure we have enough space allocated for what we will push. */ \ while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS) \ { \ if (!DOUBLE_FAIL_STACK (fail_stack)) \ return failure_code; \ \ DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \ (fail_stack).size); \ DEBUG_PRINT2 (" slots available: %d\n", REMAINING_AVAIL_SLOTS);\ } \ \ /* Push the info, starting with the registers. */ \ DEBUG_PRINT1 ("\n"); \ \ for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \ this_reg++) \ { \ DEBUG_PRINT2 (" Pushing reg: %d\n", this_reg); \ DEBUG_STATEMENT (num_regs_pushed++); \ \ DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ PUSH_FAILURE_ITEM (regstart[this_reg]); \ \ DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ PUSH_FAILURE_ITEM (regend[this_reg]); \ \ DEBUG_PRINT2 (" info: 0x%x\n ", reg_info[this_reg]); \ DEBUG_PRINT2 (" match_null=%d", \ REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \ DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \ DEBUG_PRINT2 (" matched_something=%d", \ MATCHED_SOMETHING (reg_info[this_reg])); \ DEBUG_PRINT2 (" ever_matched=%d", \ EVER_MATCHED_SOMETHING (reg_info[this_reg])); \ DEBUG_PRINT1 ("\n"); \ PUSH_FAILURE_ITEM (reg_info[this_reg].word); \ } \ \ DEBUG_PRINT2 (" Pushing low active reg: %d\n", lowest_active_reg);\ PUSH_FAILURE_ITEM (lowest_active_reg); \ \ DEBUG_PRINT2 (" Pushing high active reg: %d\n", highest_active_reg);\ PUSH_FAILURE_ITEM (highest_active_reg); \ \ DEBUG_PRINT2 (" Pushing pattern 0x%x: ", pattern_place); \ DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \ PUSH_FAILURE_ITEM (pattern_place); \ \ DEBUG_PRINT2 (" Pushing string 0x%x: `", string_place); \ DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \ size2); \ DEBUG_PRINT1 ("'\n"); \ PUSH_FAILURE_ITEM (string_place); \ \ DEBUG_PRINT2 (" Pushing failure id: %u\n", failure_id); \ DEBUG_PUSH (failure_id); \ } while (0) /* This is the number of items that are pushed and popped on the stack for each register. */ #define NUM_REG_ITEMS 3 /* Individual items aside from the registers. */ #ifdef DEBUG #define NUM_NONREG_ITEMS 5 /* Includes failure point id. */ #else #define NUM_NONREG_ITEMS 4 #endif /* We push at most this many items on the stack. */ #define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS) /* We actually push this many items. */ #define NUM_FAILURE_ITEMS \ ((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS \ + NUM_NONREG_ITEMS) /* How many items can still be added to the stack without overflowing it. */ #define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail) /* Pops what PUSH_FAIL_STACK pushes. We restore into the parameters, all of which should be lvalues: STR -- the saved data position. PAT -- the saved pattern position. LOW_REG, HIGH_REG -- the highest and lowest active registers. REGSTART, REGEND -- arrays of string positions. REG_INFO -- array of information about each subexpression. Also assumes the variables `fail_stack' and (if debugging), `bufp', `pend', `string1', `size1', `string2', and `size2'. */ #define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\ { \ DEBUG_STATEMENT (fail_stack_elt_t failure_id;) \ int this_reg; \ const unsigned char *string_temp; \ \ assert (!FAIL_STACK_EMPTY ()); \ \ /* Remove failure points and point to how many regs pushed. */ \ DEBUG_PRINT1 ("POP_FAILURE_POINT:\n"); \ DEBUG_PRINT2 (" Before pop, next avail: %d\n", fail_stack.avail); \ DEBUG_PRINT2 (" size: %d\n", fail_stack.size); \ \ assert (fail_stack.avail >= NUM_NONREG_ITEMS); \ \ DEBUG_POP (&failure_id); \ DEBUG_PRINT2 (" Popping failure id: %u\n", failure_id); \ \ /* If the saved string location is NULL, it came from an \ on_failure_keep_string_jump opcode, and we want to throw away the \ saved NULL, thus retaining our current position in the string. */ \ string_temp = POP_FAILURE_ITEM (); \ if (string_temp != NULL) \ str = (const char *) string_temp; \ \ DEBUG_PRINT2 (" Popping string 0x%x: `", str); \ DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \ DEBUG_PRINT1 ("'\n"); \ \ pat = (unsigned char *) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" Popping pattern 0x%x: ", pat); \ DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \ \ /* Restore register info. */ \ high_reg = (unsigned) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" Popping high active reg: %d\n", high_reg); \ \ low_reg = (unsigned) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" Popping low active reg: %d\n", low_reg); \ \ for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \ { \ DEBUG_PRINT2 (" Popping reg: %d\n", this_reg); \ \ reg_info[this_reg].word = POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" info: 0x%x\n", reg_info[this_reg]); \ \ regend[this_reg] = (const char *) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ \ regstart[this_reg] = (const char *) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ } \ \ DEBUG_STATEMENT (nfailure_points_popped++); \ } /* POP_FAILURE_POINT */ /* Structure for per-register (a.k.a. per-group) information. This must not be longer than one word, because we push this value onto the failure stack. Other register information, such as the starting and ending positions (which are addresses), and the list of inner groups (which is a bits list) are maintained in separate variables. We are making a (strictly speaking) nonportable assumption here: that the compiler will pack our bit fields into something that fits into the type of `word', i.e., is something that fits into one item on the failure stack. */ typedef union { fail_stack_elt_t word; struct { /* This field is one if this group can match the empty string, zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */ #define MATCH_NULL_UNSET_VALUE 3 unsigned match_null_string_p : 2; unsigned is_active : 1; unsigned matched_something : 1; unsigned ever_matched_something : 1; } bits; } register_info_type; #define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p) #define IS_ACTIVE(R) ((R).bits.is_active) #define MATCHED_SOMETHING(R) ((R).bits.matched_something) #define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something) /* Call this when have matched a real character; it sets `matched' flags for the subexpressions which we are currently inside. Also records that those subexprs have matched. */ #define SET_REGS_MATCHED() \ do \ { \ unsigned r; \ for (r = lowest_active_reg; r <= highest_active_reg; r++) \ { \ MATCHED_SOMETHING (reg_info[r]) \ = EVER_MATCHED_SOMETHING (reg_info[r]) \ = 1; \ } \ } \ while (0) /* Registers are set to a sentinel when they haven't yet matched. */ #define REG_UNSET_VALUE ((char *) -1) #define REG_UNSET(e) ((e) == REG_UNSET_VALUE) /* How do we implement a missing MATCH_MAY_ALLOCATE? We make the fail stack a global thing, and then grow it to re_max_failures when we compile. */ #ifndef MATCH_MAY_ALLOCATE static fail_stack_type fail_stack; static const char ** regstart, ** regend; static const char ** old_regstart, ** old_regend; static const char **best_regstart, **best_regend; static register_info_type *reg_info; static const char **reg_dummy; static register_info_type *reg_info_dummy; #endif /* Subroutine declarations and macros for regex_compile. */ static void store_op1 (), store_op2 (); static void insert_op1 (), insert_op2 (); static boolean at_begline_loc_p (), at_endline_loc_p (); static boolean group_in_compile_stack (); static reg_errcode_t compile_range (); /* Fetch the next character in the uncompiled pattern---translating it if necessary. Also cast from a signed character in the constant string passed to us by the user to an unsigned char that we can use as an array index (in, e.g., `translate'). */ #define PATFETCH(c) \ do {if (p == pend) return REG_EEND; \ c = (unsigned char) *p++; \ if (translate) c = translate[c]; \ } while (0) /* Fetch the next character in the uncompiled pattern, with no translation. */ #define PATFETCH_RAW(c) \ do {if (p == pend) return REG_EEND; \ c = (unsigned char) *p++; \ } while (0) /* Go backwards one character in the pattern. */ #define PATUNFETCH p-- /* If `translate' is non-null, return translate[D], else just D. We cast the subscript to translate because some data is declared as `char *', to avoid warnings when a string constant is passed. But when we use a character as a subscript we must make it unsigned. */ #define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d)) /* Macros for outputting the compiled pattern into `buffer'. */ /* If the buffer isn't allocated when it comes in, use this. */ #define INIT_BUF_SIZE 32 /* Make sure we have at least N more bytes of space in buffer. */ #define GET_BUFFER_SPACE(n) \ while (b - bufp->buffer + (n) > bufp->allocated) \ EXTEND_BUFFER () /* Make sure we have one more byte of buffer space and then add C to it. */ #define BUF_PUSH(c) \ do { \ GET_BUFFER_SPACE (1); \ *b++ = (unsigned char) (c); \ } while (0) /* Ensure we have two more bytes of buffer space and then append C1 and C2. */ #define BUF_PUSH_2(c1, c2) \ do { \ GET_BUFFER_SPACE (2); \ *b++ = (unsigned char) (c1); \ *b++ = (unsigned char) (c2); \ } while (0) /* As with BUF_PUSH_2, except for three bytes. */ #define BUF_PUSH_3(c1, c2, c3) \ do { \ GET_BUFFER_SPACE (3); \ *b++ = (unsigned char) (c1); \ *b++ = (unsigned char) (c2); \ *b++ = (unsigned char) (c3); \ } while (0) /* Store a jump with opcode OP at LOC to location TO. We store a relative address offset by the three bytes the jump itself occupies. */ #define STORE_JUMP(op, loc, to) \ store_op1 (op, loc, (to) - (loc) - 3) /* Likewise, for a two-argument jump. */ #define STORE_JUMP2(op, loc, to, arg) \ store_op2 (op, loc, (to) - (loc) - 3, arg) /* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */ #define INSERT_JUMP(op, loc, to) \ insert_op1 (op, loc, (to) - (loc) - 3, b) /* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */ #define INSERT_JUMP2(op, loc, to, arg) \ insert_op2 (op, loc, (to) - (loc) - 3, arg, b) /* This is not an arbitrary limit: the arguments which represent offsets into the pattern are two bytes long. So if 2^16 bytes turns out to be too small, many things would have to change. */ #define MAX_BUF_SIZE (1L << 16) /* Extend the buffer by twice its current size via realloc and reset the pointers that pointed into the old block to point to the correct places in the new one. If extending the buffer results in it being larger than MAX_BUF_SIZE, then flag memory exhausted. */ #define EXTEND_BUFFER() \ do { \ unsigned char *old_buffer = bufp->buffer; \ if (bufp->allocated == MAX_BUF_SIZE) \ return REG_ESIZE; \ bufp->allocated <<= 1; \ if (bufp->allocated > MAX_BUF_SIZE) \ bufp->allocated = MAX_BUF_SIZE; \ bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\ if (bufp->buffer == NULL) \ return REG_ESPACE; \ /* If the buffer moved, move all the pointers into it. */ \ if (old_buffer != bufp->buffer) \ { \ b = (b - old_buffer) + bufp->buffer; \ begalt = (begalt - old_buffer) + bufp->buffer; \ if (fixup_alt_jump) \ fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\ if (laststart) \ laststart = (laststart - old_buffer) + bufp->buffer; \ if (pending_exact) \ pending_exact = (pending_exact - old_buffer) + bufp->buffer; \ } \ } while (0) /* Since we have one byte reserved for the register number argument to {start,stop}_memory, the maximum number of groups we can report things about is what fits in that byte. */ #define MAX_REGNUM 255 /* But patterns can have more than `MAX_REGNUM' registers. We just ignore the excess. */ typedef unsigned regnum_t; /* Macros for the compile stack. */ /* Since offsets can go either forwards or backwards, this type needs to be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */ typedef int pattern_offset_t; typedef struct { pattern_offset_t begalt_offset; pattern_offset_t fixup_alt_jump; pattern_offset_t inner_group_offset; pattern_offset_t laststart_offset; regnum_t regnum; } compile_stack_elt_t; typedef struct { compile_stack_elt_t *stack; unsigned size; unsigned avail; /* Offset of next open position. */ } compile_stack_type; #define INIT_COMPILE_STACK_SIZE 32 #define COMPILE_STACK_EMPTY (compile_stack.avail == 0) #define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size) /* The next available element. */ #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail]) /* Set the bit for character C in a list. */ #define SET_LIST_BIT(c) \ (b[((unsigned char) (c)) / BYTEWIDTH] \ |= 1 << (((unsigned char) c) % BYTEWIDTH)) /* Get the next unsigned number in the uncompiled pattern. */ #define GET_UNSIGNED_NUMBER(num) \ { if (p != pend) \ { \ PATFETCH (c); \ while (ISDIGIT (c)) \ { \ if (num < 0) \ num = 0; \ num = num * 10 + c - '0'; \ if (p == pend) \ break; \ PATFETCH (c); \ } \ } \ } #define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */ #define IS_CHAR_CLASS(string) \ (STREQ (string, "alpha") || STREQ (string, "upper") \ || STREQ (string, "lower") || STREQ (string, "digit") \ || STREQ (string, "alnum") || STREQ (string, "xdigit") \ || STREQ (string, "space") || STREQ (string, "print") \ || STREQ (string, "punct") || STREQ (string, "graph") \ || STREQ (string, "cntrl") || STREQ (string, "blank")) /* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX. Returns one of error codes defined in `regex.h', or zero for success. Assumes the `allocated' (and perhaps `buffer') and `translate' fields are set in BUFP on entry. If it succeeds, results are put in BUFP (if it returns an error, the contents of BUFP are undefined): `buffer' is the compiled pattern; `syntax' is set to SYNTAX; `used' is set to the length of the compiled pattern; `fastmap_accurate' is zero; `re_nsub' is the number of subexpressions in PATTERN; `not_bol' and `not_eol' are zero; The `fastmap' and `newline_anchor' fields are neither examined nor set. */ static reg_errcode_t regex_compile (pattern, size, syntax, bufp) const char *pattern; int size; reg_syntax_t syntax; struct re_pattern_buffer *bufp; { /* We fetch characters from PATTERN here. Even though PATTERN is `char *' (i.e., signed), we declare these variables as unsigned, so they can be reliably used as array indices. */ register unsigned char c, c1; /* A random tempory spot in PATTERN. */ const char *p1; /* Points to the end of the buffer, where we should append. */ register unsigned char *b; /* Keeps track of unclosed groups. */ compile_stack_type compile_stack; /* Points to the current (ending) position in the pattern. */ const char *p = pattern; const char *pend = pattern + size; /* How to translate the characters in the pattern. */ char *translate = bufp->translate; /* Address of the count-byte of the most recently inserted `exactn' command. This makes it possible to tell if a new exact-match character can be added to that command or if the character requires a new `exactn' command. */ unsigned char *pending_exact = 0; /* Address of start of the most recently finished expression. This tells, e.g., postfix * where to find the start of its operand. Reset at the beginning of groups and alternatives. */ unsigned char *laststart = 0; /* Address of beginning of regexp, or inside of last group. */ unsigned char *begalt; /* Place in the uncompiled pattern (i.e., the {) to which to go back if the interval is invalid. */ const char *beg_interval; /* Address of the place where a forward jump should go to the end of the containing expression. Each alternative of an `or' -- except the last -- ends with a forward jump of this sort. */ unsigned char *fixup_alt_jump = 0; /* Counts open-groups as they are encountered. Remembered for the matching close-group on the compile stack, so the same register number is put in the stop_memory as the start_memory. */ regnum_t regnum = 0; #ifdef DEBUG DEBUG_PRINT1 ("\nCompiling pattern: "); if (debug) { unsigned debug_count; for (debug_count = 0; debug_count < size; debug_count++) printchar (pattern[debug_count]); putchar ('\n'); } #endif /* DEBUG */ /* Initialize the compile stack. */ compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t); if (compile_stack.stack == NULL) return REG_ESPACE; compile_stack.size = INIT_COMPILE_STACK_SIZE; compile_stack.avail = 0; /* Initialize the pattern buffer. */ bufp->syntax = syntax; bufp->fastmap_accurate = 0; bufp->not_bol = bufp->not_eol = 0; /* Set `used' to zero, so that if we return an error, the pattern printer (for debugging) will think there's no pattern. We reset it at the end. */ bufp->used = 0; /* Always count groups, whether or not bufp->no_sub is set. */ bufp->re_nsub = 0; #if !defined (emacs) && !defined (SYNTAX_TABLE) /* Initialize the syntax table. */ init_syntax_once (); #endif if (bufp->allocated == 0) { if (bufp->buffer) { /* If zero allocated, but buffer is non-null, try to realloc enough space. This loses if buffer's address is bogus, but that is the user's responsibility. */ RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char); } else { /* Caller did not allocate a buffer. Do it for them. */ bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char); } if (!bufp->buffer) return REG_ESPACE; bufp->allocated = INIT_BUF_SIZE; } begalt = b = bufp->buffer; /* Loop through the uncompiled pattern until we're at the end. */ while (p != pend) { PATFETCH (c); switch (c) { case '^': { if ( /* If at start of pattern, it's an operator. */ p == pattern + 1 /* If context independent, it's an operator. */ || syntax & RE_CONTEXT_INDEP_ANCHORS /* Otherwise, depends on what's come before. */ || at_begline_loc_p (pattern, p, syntax)) BUF_PUSH (begline); else goto normal_char; } break; case '$': { if ( /* If at end of pattern, it's an operator. */ p == pend /* If context independent, it's an operator. */ || syntax & RE_CONTEXT_INDEP_ANCHORS /* Otherwise, depends on what's next. */ || at_endline_loc_p (p, pend, syntax)) BUF_PUSH (endline); else goto normal_char; } break; case '+': case '?': if ((syntax & RE_BK_PLUS_QM) || (syntax & RE_LIMITED_OPS)) goto normal_char; handle_plus: case '*': /* If there is no previous pattern... */ if (!laststart) { if (syntax & RE_CONTEXT_INVALID_OPS) return REG_BADRPT; else if (!(syntax & RE_CONTEXT_INDEP_OPS)) goto normal_char; } { /* Are we optimizing this jump? */ boolean keep_string_p = false; /* 1 means zero (many) matches is allowed. */ char zero_times_ok = 0, many_times_ok = 0; /* If there is a sequence of repetition chars, collapse it down to just one (the right one). We can't combine interval operators with these because of, e.g., `a{2}*', which should only match an even number of `a's. */ for (;;) { zero_times_ok |= c != '+'; many_times_ok |= c != '?'; if (p == pend) break; PATFETCH (c); if (c == '*' || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?'))) ; else if (syntax & RE_BK_PLUS_QM && c == '\\') { if (p == pend) return REG_EESCAPE; PATFETCH (c1); if (!(c1 == '+' || c1 == '?')) { PATUNFETCH; PATUNFETCH; break; } c = c1; } else { PATUNFETCH; break; } /* If we get here, we found another repeat character. */ } /* Star, etc. applied to an empty pattern is equivalent to an empty pattern. */ if (!laststart) break; /* Now we know whether or not zero matches is allowed and also whether or not two or more matches is allowed. */ if (many_times_ok) { /* More than one repetition is allowed, so put in at the end a backward relative jump from `b' to before the next jump we're going to put in below (which jumps from laststart to after this jump). But if we are at the `*' in the exact sequence `.*\n', insert an unconditional jump backwards to the ., instead of the beginning of the loop. This way we only push a failure point once, instead of every time through the loop. */ assert (p - 1 > pattern); /* Allocate the space for the jump. */ GET_BUFFER_SPACE (3); /* We know we are not at the first character of the pattern, because laststart was nonzero. And we've already incremented `p', by the way, to be the character after the `*'. Do we have to do something analogous here for null bytes, because of RE_DOT_NOT_NULL? */ if (TRANSLATE (*(p - 2)) == TRANSLATE ('.') && zero_times_ok && p < pend && TRANSLATE (*p) == TRANSLATE ('\n') && !(syntax & RE_DOT_NEWLINE)) { /* We have .*\n. */ STORE_JUMP (jump, b, laststart); keep_string_p = true; } else /* Anything else. */ STORE_JUMP (maybe_pop_jump, b, laststart - 3); /* We've added more stuff to the buffer. */ b += 3; } /* On failure, jump from laststart to b + 3, which will be the end of the buffer after this jump is inserted. */ GET_BUFFER_SPACE (3); INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump : on_failure_jump, laststart, b + 3); pending_exact = 0; b += 3; if (!zero_times_ok) { /* At least one repetition is required, so insert a `dummy_failure_jump' before the initial `on_failure_jump' instruction of the loop. This effects a skip over that instruction the first time we hit that loop. */ GET_BUFFER_SPACE (3); INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6); b += 3; } } break; case '.': laststart = b; BUF_PUSH (anychar); break; case '[': { boolean had_char_class = false; if (p == pend) return REG_EBRACK; /* Ensure that we have enough space to push a charset: the opcode, the length count, and the bitset; 34 bytes in all. */ GET_BUFFER_SPACE (34); laststart = b; /* We test `*p == '^' twice, instead of using an if statement, so we only need one BUF_PUSH. */ BUF_PUSH (*p == '^' ? charset_not : charset); if (*p == '^') p++; /* Remember the first position in the bracket expression. */ p1 = p; /* Push the number of bytes in the bitmap. */ BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH); /* Clear the whole map. */ bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH); /* charset_not matches newline according to a syntax bit. */ if ((re_opcode_t) b[-2] == charset_not && (syntax & RE_HAT_LISTS_NOT_NEWLINE)) SET_LIST_BIT ('\n'); /* Read in characters and ranges, setting map bits. */ for (;;) { if (p == pend) return REG_EBRACK; PATFETCH (c); /* \ might escape characters inside [...] and [^...]. */ if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\') { if (p == pend) return REG_EESCAPE; PATFETCH (c1); SET_LIST_BIT (c1); continue; } /* Could be the end of the bracket expression. If it's not (i.e., when the bracket expression is `[]' so far), the ']' character bit gets set way below. */ if (c == ']' && p != p1 + 1) break; /* Look ahead to see if it's a range when the last thing was a character class. */ if (had_char_class && c == '-' && *p != ']') return REG_ERANGE; /* Look ahead to see if it's a range when the last thing was a character: if this is a hyphen not at the beginning or the end of a list, then it's the range operator. */ if (c == '-' && !(p - 2 >= pattern && p[-2] == '[') && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^') && *p != ']') { reg_errcode_t ret = compile_range (&p, pend, translate, syntax, b); if (ret != REG_NOERROR) return ret; } else if (p[0] == '-' && p[1] != ']') { /* This handles ranges made up of characters only. */ reg_errcode_t ret; /* Move past the `-'. */ PATFETCH (c1); ret = compile_range (&p, pend, translate, syntax, b); if (ret != REG_NOERROR) return ret; } /* See if we're at the beginning of a possible character class. */ else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':') { /* Leave room for the null. */ char str[CHAR_CLASS_MAX_LENGTH + 1]; PATFETCH (c); c1 = 0; /* If pattern is `[[:'. */ if (p == pend) return REG_EBRACK; for (;;) { PATFETCH (c); if (c == ':' || c == ']' || p == pend || c1 == CHAR_CLASS_MAX_LENGTH) break; str[c1++] = c; } str[c1] = '\0'; /* If isn't a word bracketed by `[:' and:`]': undo the ending character, the letters, and leave the leading `:' and `[' (but set bits for them). */ if (c == ':' && *p == ']') { int ch; boolean is_alnum = STREQ (str, "alnum"); boolean is_alpha = STREQ (str, "alpha"); boolean is_blank = STREQ (str, "blank"); boolean is_cntrl = STREQ (str, "cntrl"); boolean is_digit = STREQ (str, "digit"); boolean is_graph = STREQ (str, "graph"); boolean is_lower = STREQ (str, "lower"); boolean is_print = STREQ (str, "print"); boolean is_punct = STREQ (str, "punct"); boolean is_space = STREQ (str, "space"); boolean is_upper = STREQ (str, "upper"); boolean is_xdigit = STREQ (str, "xdigit"); if (!IS_CHAR_CLASS (str)) return REG_ECTYPE; /* Throw away the ] at the end of the character class. */ PATFETCH (c); if (p == pend) return REG_EBRACK; for (ch = 0; ch < 1 << BYTEWIDTH; ch++) { if ( (is_alnum && ISALNUM (ch)) || (is_alpha && ISALPHA (ch)) || (is_blank && ISBLANK (ch)) || (is_cntrl && ISCNTRL (ch)) || (is_digit && ISDIGIT (ch)) || (is_graph && ISGRAPH (ch)) || (is_lower && ISLOWER (ch)) || (is_print && ISPRINT (ch)) || (is_punct && ISPUNCT (ch)) || (is_space && ISSPACE (ch)) || (is_upper && ISUPPER (ch)) || (is_xdigit && ISXDIGIT (ch))) SET_LIST_BIT (ch); } had_char_class = true; } else { c1++; while (c1--) PATUNFETCH; SET_LIST_BIT ('['); SET_LIST_BIT (':'); had_char_class = false; } } else { had_char_class = false; SET_LIST_BIT (c); } } /* Discard any (non)matching list bytes that are all 0 at the end of the map. Decrease the map-length byte too. */ while ((int) b[-1] > 0 && b[b[-1] - 1] == 0) b[-1]--; b += b[-1]; } break; case '(': if (syntax & RE_NO_BK_PARENS) goto handle_open; else goto normal_char; case ')': if (syntax & RE_NO_BK_PARENS) goto handle_close; else goto normal_char; case '\n': if (syntax & RE_NEWLINE_ALT) goto handle_alt; else goto normal_char; case '|': if (syntax & RE_NO_BK_VBAR) goto handle_alt; else goto normal_char; case '{': if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES) goto handle_interval; else goto normal_char; case '\\': if (p == pend) return REG_EESCAPE; /* Do not translate the character after the \, so that we can distinguish, e.g., \B from \b, even if we normally would translate, e.g., B to b. */ PATFETCH_RAW (c); switch (c) { case '(': if (syntax & RE_NO_BK_PARENS) goto normal_backslash; handle_open: bufp->re_nsub++; regnum++; if (COMPILE_STACK_FULL) { RETALLOC (compile_stack.stack, compile_stack.size << 1, compile_stack_elt_t); if (compile_stack.stack == NULL) return REG_ESPACE; compile_stack.size <<= 1; } /* These are the values to restore when we hit end of this group. They are all relative offsets, so that if the whole pattern moves because of realloc, they will still be valid. */ COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer; COMPILE_STACK_TOP.fixup_alt_jump = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0; COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer; COMPILE_STACK_TOP.regnum = regnum; /* We will eventually replace the 0 with the number of groups inner to this one. But do not push a start_memory for groups beyond the last one we can represent in the compiled pattern. */ if (regnum <= MAX_REGNUM) { COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2; BUF_PUSH_3 (start_memory, regnum, 0); } compile_stack.avail++; fixup_alt_jump = 0; laststart = 0; begalt = b; /* If we've reached MAX_REGNUM groups, then this open won't actually generate any code, so we'll have to clear pending_exact explicitly. */ pending_exact = 0; break; case ')': if (syntax & RE_NO_BK_PARENS) goto normal_backslash; if (COMPILE_STACK_EMPTY) if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) goto normal_backslash; else return REG_ERPAREN; handle_close: if (fixup_alt_jump) { /* Push a dummy failure point at the end of the alternative for a possible future `pop_failure_jump' to pop. See comments at `push_dummy_failure' in `re_match_2'. */ BUF_PUSH (push_dummy_failure); /* We allocated space for this jump when we assigned to `fixup_alt_jump', in the `handle_alt' case below. */ STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1); } /* See similar code for backslashed left paren above. */ if (COMPILE_STACK_EMPTY) if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) goto normal_char; else return REG_ERPAREN; /* Since we just checked for an empty stack above, this ``can't happen''. */ assert (compile_stack.avail != 0); { /* We don't just want to restore into `regnum', because later groups should continue to be numbered higher, as in `(ab)c(de)' -- the second group is #2. */ regnum_t this_group_regnum; compile_stack.avail--; begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset; fixup_alt_jump = COMPILE_STACK_TOP.fixup_alt_jump ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1 : 0; laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset; this_group_regnum = COMPILE_STACK_TOP.regnum; /* If we've reached MAX_REGNUM groups, then this open won't actually generate any code, so we'll have to clear pending_exact explicitly. */ pending_exact = 0; /* We're at the end of the group, so now we know how many groups were inside this one. */ if (this_group_regnum <= MAX_REGNUM) { unsigned char *inner_group_loc = bufp->buffer + COMPILE_STACK_TOP.inner_group_offset; *inner_group_loc = regnum - this_group_regnum; BUF_PUSH_3 (stop_memory, this_group_regnum, regnum - this_group_regnum); } } break; case '|': /* `\|'. */ if (syntax & RE_LIMITED_OPS || syntax & RE_NO_BK_VBAR) goto normal_backslash; handle_alt: if (syntax & RE_LIMITED_OPS) goto normal_char; /* Insert before the previous alternative a jump which jumps to this alternative if the former fails. */ GET_BUFFER_SPACE (3); INSERT_JUMP (on_failure_jump, begalt, b + 6); pending_exact = 0; b += 3; /* The alternative before this one has a jump after it which gets executed if it gets matched. Adjust that jump so it will jump to this alternative's analogous jump (put in below, which in turn will jump to the next (if any) alternative's such jump, etc.). The last such jump jumps to the correct final destination. A picture: _____ _____ | | | | | v | v a | b | c If we are at `b', then fixup_alt_jump right now points to a three-byte space after `a'. We'll put in the jump, set fixup_alt_jump to right after `b', and leave behind three bytes which we'll fill in when we get to after `c'. */ if (fixup_alt_jump) STORE_JUMP (jump_past_alt, fixup_alt_jump, b); /* Mark and leave space for a jump after this alternative, to be filled in later either by next alternative or when know we're at the end of a series of alternatives. */ fixup_alt_jump = b; GET_BUFFER_SPACE (3); b += 3; laststart = 0; begalt = b; break; case '{': /* If \{ is a literal. */ if (!(syntax & RE_INTERVALS) /* If we're at `\{' and it's not the open-interval operator. */ || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES)) || (p - 2 == pattern && p == pend)) goto normal_backslash; handle_interval: { /* If got here, then the syntax allows intervals. */ /* At least (most) this many matches must be made. */ int lower_bound = -1, upper_bound = -1; beg_interval = p - 1; if (p == pend) { if (syntax & RE_NO_BK_BRACES) goto unfetch_interval; else return REG_EBRACE; } GET_UNSIGNED_NUMBER (lower_bound); if (c == ',') { GET_UNSIGNED_NUMBER (upper_bound); if (upper_bound < 0) upper_bound = RE_DUP_MAX; } else /* Interval such as `{1}' => match exactly once. */ upper_bound = lower_bound; if (lower_bound < 0 || upper_bound > RE_DUP_MAX || lower_bound > upper_bound) { if (syntax & RE_NO_BK_BRACES) goto unfetch_interval; else return REG_BADBR; } if (!(syntax & RE_NO_BK_BRACES)) { if (c != '\\') return REG_EBRACE; PATFETCH (c); } if (c != '}') { if (syntax & RE_NO_BK_BRACES) goto unfetch_interval; else return REG_BADBR; } /* We just parsed a valid interval. */ /* If it's invalid to have no preceding re. */ if (!laststart) { if (syntax & RE_CONTEXT_INVALID_OPS) return REG_BADRPT; else if (syntax & RE_CONTEXT_INDEP_OPS) laststart = b; else goto unfetch_interval; } /* If the upper bound is zero, don't want to succeed at all; jump from `laststart' to `b + 3', which will be the end of the buffer after we insert the jump. */ if (upper_bound == 0) { GET_BUFFER_SPACE (3); INSERT_JUMP (jump, laststart, b + 3); b += 3; } /* Otherwise, we have a nontrivial interval. When we're all done, the pattern will look like: set_number_at set_number_at succeed_n jump_n (The upper bound and `jump_n' are omitted if `upper_bound' is 1, though.) */ else { /* If the upper bound is > 1, we need to insert more at the end of the loop. */ unsigned nbytes = 10 + (upper_bound > 1) * 10; GET_BUFFER_SPACE (nbytes); /* Initialize lower bound of the `succeed_n', even though it will be set during matching by its attendant `set_number_at' (inserted next), because `re_compile_fastmap' needs to know. Jump to the `jump_n' we might insert below. */ INSERT_JUMP2 (succeed_n, laststart, b + 5 + (upper_bound > 1) * 5, lower_bound); b += 5; /* Code to initialize the lower bound. Insert before the `succeed_n'. The `5' is the last two bytes of this `set_number_at', plus 3 bytes of the following `succeed_n'. */ insert_op2 (set_number_at, laststart, 5, lower_bound, b); b += 5; if (upper_bound > 1) { /* More than one repetition is allowed, so append a backward jump to the `succeed_n' that starts this interval. When we've reached this during matching, we'll have matched the interval once, so jump back only `upper_bound - 1' times. */ STORE_JUMP2 (jump_n, b, laststart + 5, upper_bound - 1); b += 5; /* The location we want to set is the second parameter of the `jump_n'; that is `b-2' as an absolute address. `laststart' will be the `set_number_at' we're about to insert; `laststart+3' the number to set, the source for the relative address. But we are inserting into the middle of the pattern -- so everything is getting moved up by 5. Conclusion: (b - 2) - (laststart + 3) + 5, i.e., b - laststart. We insert this at the beginning of the loop so that if we fail during matching, we'll reinitialize the bounds. */ insert_op2 (set_number_at, laststart, b - laststart, upper_bound - 1, b); b += 5; } } pending_exact = 0; beg_interval = NULL; } break; unfetch_interval: /* If an invalid interval, match the characters as literals. */ assert (beg_interval); p = beg_interval; beg_interval = NULL; /* normal_char and normal_backslash need `c'. */ PATFETCH (c); if (!(syntax & RE_NO_BK_BRACES)) { if (p > pattern && p[-1] == '\\') goto normal_backslash; } goto normal_char; #ifdef emacs /* There is no way to specify the before_dot and after_dot operators. rms says this is ok. --karl */ case '=': BUF_PUSH (at_dot); break; case 's': laststart = b; PATFETCH (c); BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]); break; case 'S': laststart = b; PATFETCH (c); BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]); break; #endif /* emacs */ case 'w': laststart = b; BUF_PUSH (wordchar); break; case 'W': laststart = b; BUF_PUSH (notwordchar); break; case '<': BUF_PUSH (wordbeg); break; case '>': BUF_PUSH (wordend); break; case 'b': BUF_PUSH (wordbound); break; case 'B': BUF_PUSH (notwordbound); break; case '`': BUF_PUSH (begbuf); break; case '\'': BUF_PUSH (endbuf); break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (syntax & RE_NO_BK_REFS) goto normal_char; c1 = c - '0'; if (c1 > regnum) return REG_ESUBREG; /* Can't back reference to a subexpression if inside of it. */ if (group_in_compile_stack (compile_stack, c1)) goto normal_char; laststart = b; BUF_PUSH_2 (duplicate, c1); break; case '+': case '?': if (syntax & RE_BK_PLUS_QM) goto handle_plus; else goto normal_backslash; default: normal_backslash: /* You might think it would be useful for \ to mean not to translate; but if we don't translate it it will never match anything. */ c = TRANSLATE (c); goto normal_char; } break; default: /* Expects the character in `c'. */ normal_char: /* If no exactn currently being built. */ if (!pending_exact /* If last exactn not at current position. */ || pending_exact + *pending_exact + 1 != b /* We have only one byte following the exactn for the count. */ || *pending_exact == (1 << BYTEWIDTH) - 1 /* If followed by a repetition operator. */ || *p == '*' || *p == '^' || ((syntax & RE_BK_PLUS_QM) ? *p == '\\' && (p[1] == '+' || p[1] == '?') : (*p == '+' || *p == '?')) || ((syntax & RE_INTERVALS) && ((syntax & RE_NO_BK_BRACES) ? *p == '{' : (p[0] == '\\' && p[1] == '{')))) { /* Start building a new exactn. */ laststart = b; BUF_PUSH_2 (exactn, 0); pending_exact = b - 1; } BUF_PUSH (c); (*pending_exact)++; break; } /* switch (c) */ } /* while p != pend */ /* Through the pattern now. */ if (fixup_alt_jump) STORE_JUMP (jump_past_alt, fixup_alt_jump, b); if (!COMPILE_STACK_EMPTY) return REG_EPAREN; free (compile_stack.stack); /* We have succeeded; set the length of the buffer. */ bufp->used = b - bufp->buffer; #ifdef DEBUG if (debug) { DEBUG_PRINT1 ("\nCompiled pattern: \n"); print_compiled_pattern (bufp); } #endif /* DEBUG */ #ifndef MATCH_MAY_ALLOCATE /* Initialize the failure stack to the largest possible stack. This isn't necessary unless we're trying to avoid calling alloca in the search and match routines. */ { int num_regs = bufp->re_nsub + 1; /* Since DOUBLE_FAIL_STACK refuses to double only if the current size is strictly greater than re_max_failures, the largest possible stack is 2 * re_max_failures failure points. */ fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS); if (fail_stack.stack) fail_stack.stack = (fail_stack_elt_t *) realloc (fail_stack.stack, (fail_stack.size * sizeof (fail_stack_elt_t))); else fail_stack.stack = (fail_stack_elt_t *) malloc (fail_stack.size * sizeof (fail_stack_elt_t)); /* Initialize some other variables the matcher uses. */ RETALLOC_IF (regstart, num_regs, const char *); RETALLOC_IF (regend, num_regs, const char *); RETALLOC_IF (old_regstart, num_regs, const char *); RETALLOC_IF (old_regend, num_regs, const char *); RETALLOC_IF (best_regstart, num_regs, const char *); RETALLOC_IF (best_regend, num_regs, const char *); RETALLOC_IF (reg_info, num_regs, register_info_type); RETALLOC_IF (reg_dummy, num_regs, const char *); RETALLOC_IF (reg_info_dummy, num_regs, register_info_type); } #endif return REG_NOERROR; } /* regex_compile */ /* Subroutines for `regex_compile'. */ /* Store OP at LOC followed by two-byte integer parameter ARG. */ static void store_op1 (op, loc, arg) re_opcode_t op; unsigned char *loc; int arg; { *loc = (unsigned char) op; STORE_NUMBER (loc + 1, arg); } /* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */ static void store_op2 (op, loc, arg1, arg2) re_opcode_t op; unsigned char *loc; int arg1, arg2; { *loc = (unsigned char) op; STORE_NUMBER (loc + 1, arg1); STORE_NUMBER (loc + 3, arg2); } /* Copy the bytes from LOC to END to open up three bytes of space at LOC for OP followed by two-byte integer parameter ARG. */ static void insert_op1 (op, loc, arg, end) re_opcode_t op; unsigned char *loc; int arg; unsigned char *end; { register unsigned char *pfrom = end; register unsigned char *pto = end + 3; while (pfrom != loc) *--pto = *--pfrom; store_op1 (op, loc, arg); } /* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */ static void insert_op2 (op, loc, arg1, arg2, end) re_opcode_t op; unsigned char *loc; int arg1, arg2; unsigned char *end; { register unsigned char *pfrom = end; register unsigned char *pto = end + 5; while (pfrom != loc) *--pto = *--pfrom; store_op2 (op, loc, arg1, arg2); } /* P points to just after a ^ in PATTERN. Return true if that ^ comes after an alternative or a begin-subexpression. We assume there is at least one character before the ^. */ static boolean at_begline_loc_p (pattern, p, syntax) const char *pattern, *p; reg_syntax_t syntax; { const char *prev = p - 2; boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\'; return /* After a subexpression? */ (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash)) /* After an alternative? */ || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash)); } /* The dual of at_begline_loc_p. This one is for $. We assume there is at least one character after the $, i.e., `P < PEND'. */ static boolean at_endline_loc_p (p, pend, syntax) const char *p, *pend; int syntax; { const char *next = p; boolean next_backslash = *next == '\\'; const char *next_next = p + 1 < pend ? p + 1 : NULL; return /* Before a subexpression? */ (syntax & RE_NO_BK_PARENS ? *next == ')' : next_backslash && next_next && *next_next == ')') /* Before an alternative? */ || (syntax & RE_NO_BK_VBAR ? *next == '|' : next_backslash && next_next && *next_next == '|'); } /* Returns true if REGNUM is in one of COMPILE_STACK's elements and false if it's not. */ static boolean group_in_compile_stack (compile_stack, regnum) compile_stack_type compile_stack; regnum_t regnum; { int this_element; for (this_element = compile_stack.avail - 1; this_element >= 0; this_element--) if (compile_stack.stack[this_element].regnum == regnum) return true; return false; } /* Read the ending character of a range (in a bracket expression) from the uncompiled pattern *P_PTR (which ends at PEND). We assume the starting character is in `P[-2]'. (`P[-1]' is the character `-'.) Then we set the translation of all bits between the starting and ending characters (inclusive) in the compiled pattern B. Return an error code. We use these short variable names so we can use the same macros as `regex_compile' itself. */ static reg_errcode_t compile_range (p_ptr, pend, translate, syntax, b) const char **p_ptr, *pend; char *translate; reg_syntax_t syntax; unsigned char *b; { unsigned this_char; const char *p = *p_ptr; int range_start, range_end; if (p == pend) return REG_ERANGE; /* Even though the pattern is a signed `char *', we need to fetch with unsigned char *'s; if the high bit of the pattern character is set, the range endpoints will be negative if we fetch using a signed char *. We also want to fetch the endpoints without translating them; the appropriate translation is done in the bit-setting loop below. */ range_start = ((unsigned char *) p)[-2]; range_end = ((unsigned char *) p)[0]; /* Have to increment the pointer into the pattern string, so the caller isn't still at the ending character. */ (*p_ptr)++; /* If the start is after the end, the range is empty. */ if (range_start > range_end) return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR; /* Here we see why `this_char' has to be larger than an `unsigned char' -- the range is inclusive, so if `range_end' == 0xff (assuming 8-bit characters), we would otherwise go into an infinite loop, since all characters <= 0xff. */ for (this_char = range_start; this_char <= range_end; this_char++) { SET_LIST_BIT (TRANSLATE (this_char)); } return REG_NOERROR; } /* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible characters can start a string that matches the pattern. This fastmap is used by re_search to skip quickly over impossible starting points. The caller must supply the address of a (1 << BYTEWIDTH)-byte data area as BUFP->fastmap. We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in the pattern buffer. Returns 0 if we succeed, -2 if an internal error. */ int re_compile_fastmap (bufp) struct re_pattern_buffer *bufp; { int j, k; #ifdef MATCH_MAY_ALLOCATE fail_stack_type fail_stack; #endif #ifndef REGEX_MALLOC char *destination; #endif /* We don't push any register information onto the failure stack. */ unsigned num_regs = 0; register char *fastmap = bufp->fastmap; unsigned char *pattern = bufp->buffer; unsigned long size = bufp->used; const unsigned char *p = pattern; register unsigned char *pend = pattern + size; /* Assume that each path through the pattern can be null until proven otherwise. We set this false at the bottom of switch statement, to which we get only if a particular path doesn't match the empty string. */ boolean path_can_be_null = true; /* We aren't doing a `succeed_n' to begin with. */ boolean succeed_n_p = false; assert (fastmap != NULL && p != NULL); INIT_FAIL_STACK (); bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */ bufp->fastmap_accurate = 1; /* It will be when we're done. */ bufp->can_be_null = 0; while (p != pend || !FAIL_STACK_EMPTY ()) { if (p == pend) { bufp->can_be_null |= path_can_be_null; /* Reset for next path. */ path_can_be_null = true; p = fail_stack.stack[--fail_stack.avail]; } /* We should never be about to go beyond the end of the pattern. */ assert (p < pend); #ifdef SWITCH_ENUM_BUG switch ((int) ((re_opcode_t) *p++)) #else switch ((re_opcode_t) *p++) #endif { /* I guess the idea here is to simply not bother with a fastmap if a backreference is used, since it's too hard to figure out the fastmap for the corresponding group. Setting `can_be_null' stops `re_search_2' from using the fastmap, so that is all we do. */ case duplicate: bufp->can_be_null = 1; return 0; /* Following are the cases which match a character. These end with `break'. */ case exactn: fastmap[p[1]] = 1; break; case charset: for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))) fastmap[j] = 1; break; case charset_not: /* Chars beyond end of map must be allowed. */ for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++) fastmap[j] = 1; for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))) fastmap[j] = 1; break; case wordchar: for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) == Sword) fastmap[j] = 1; break; case notwordchar: for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) != Sword) fastmap[j] = 1; break; case anychar: /* `.' matches anything ... */ for (j = 0; j < (1 << BYTEWIDTH); j++) fastmap[j] = 1; /* ... except perhaps newline. */ if (!(bufp->syntax & RE_DOT_NEWLINE)) fastmap['\n'] = 0; /* Return if we have already set `can_be_null'; if we have, then the fastmap is irrelevant. Something's wrong here. */ else if (bufp->can_be_null) return 0; /* Otherwise, have to check alternative paths. */ break; #ifdef emacs case syntaxspec: k = *p++; for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) == (enum syntaxcode) k) fastmap[j] = 1; break; case notsyntaxspec: k = *p++; for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) != (enum syntaxcode) k) fastmap[j] = 1; break; /* All cases after this match the empty string. These end with `continue'. */ case before_dot: case at_dot: case after_dot: continue; #endif /* not emacs */ case no_op: case begline: case endline: case begbuf: case endbuf: case wordbound: case notwordbound: case wordbeg: case wordend: case push_dummy_failure: continue; case jump_n: case pop_failure_jump: case maybe_pop_jump: case jump: case jump_past_alt: case dummy_failure_jump: EXTRACT_NUMBER_AND_INCR (j, p); p += j; if (j > 0) continue; /* Jump backward implies we just went through the body of a loop and matched nothing. Opcode jumped to should be `on_failure_jump' or `succeed_n'. Just treat it like an ordinary jump. For a * loop, it has pushed its failure point already; if so, discard that as redundant. */ if ((re_opcode_t) *p != on_failure_jump && (re_opcode_t) *p != succeed_n) continue; p++; EXTRACT_NUMBER_AND_INCR (j, p); p += j; /* If what's on the stack is where we are now, pop it. */ if (!FAIL_STACK_EMPTY () && fail_stack.stack[fail_stack.avail - 1] == p) fail_stack.avail--; continue; case on_failure_jump: case on_failure_keep_string_jump: handle_on_failure_jump: EXTRACT_NUMBER_AND_INCR (j, p); /* For some patterns, e.g., `(a?)?', `p+j' here points to the end of the pattern. We don't want to push such a point, since when we restore it above, entering the switch will increment `p' past the end of the pattern. We don't need to push such a point since we obviously won't find any more fastmap entries beyond `pend'. Such a pattern can match the null string, though. */ if (p + j < pend) { if (!PUSH_PATTERN_OP (p + j, fail_stack)) return -2; } else bufp->can_be_null = 1; if (succeed_n_p) { EXTRACT_NUMBER_AND_INCR (k, p); /* Skip the n. */ succeed_n_p = false; } continue; case succeed_n: /* Get to the number of times to succeed. */ p += 2; /* Increment p past the n for when k != 0. */ EXTRACT_NUMBER_AND_INCR (k, p); if (k == 0) { p -= 4; succeed_n_p = true; /* Spaghetti code alert. */ goto handle_on_failure_jump; } continue; case set_number_at: p += 4; continue; case start_memory: case stop_memory: p += 2; continue; default: abort (); /* We have listed all the cases. */ } /* switch *p++ */ /* Getting here means we have found the possible starting characters for one path of the pattern -- and that the empty string does not match. We need not follow this path further. Instead, look at the next alternative (remembered on the stack), or quit if no more. The test at the top of the loop does these things. */ path_can_be_null = false; p = pend; } /* while p */ /* Set `can_be_null' for the last path (also the first path, if the pattern is empty). */ bufp->can_be_null |= path_can_be_null; return 0; } /* re_compile_fastmap */ /* Set REGS to hold NUM_REGS registers, storing them in STARTS and ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use this memory for recording register information. STARTS and ENDS must be allocated using the malloc library routine, and must each be at least NUM_REGS * sizeof (regoff_t) bytes long. If NUM_REGS == 0, then subsequent matches should allocate their own register data. Unless this function is called, the first search or match using PATTERN_BUFFER will allocate its own register data, without freeing the old data. */ void re_set_registers (bufp, regs, num_regs, starts, ends) struct re_pattern_buffer *bufp; struct re_registers *regs; unsigned num_regs; regoff_t *starts, *ends; { if (num_regs) { bufp->regs_allocated = REGS_REALLOCATE; regs->num_regs = num_regs; regs->start = starts; regs->end = ends; } else { bufp->regs_allocated = REGS_UNALLOCATED; regs->num_regs = 0; regs->start = regs->end = (regoff_t) 0; } } /* Searching routines. */ /* Like re_search_2, below, but only one string is specified, and doesn't let you say where to stop matching. */ int re_search (bufp, string, size, startpos, range, regs) struct re_pattern_buffer *bufp; const char *string; int size, startpos, range; struct re_registers *regs; { return re_search_2 (bufp, NULL, 0, string, size, startpos, range, regs, size); } /* Using the compiled pattern in BUFP->buffer, first tries to match the virtual concatenation of STRING1 and STRING2, starting first at index STARTPOS, then at STARTPOS + 1, and so on. STRING1 and STRING2 have length SIZE1 and SIZE2, respectively. RANGE is how far to scan while trying to match. RANGE = 0 means try only at STARTPOS; in general, the last start tried is STARTPOS + RANGE. In REGS, return the indices of the virtual concatenation of STRING1 and STRING2 that matched the entire BUFP->buffer and its contained subexpressions. Do not consider matching one past the index STOP in the virtual concatenation of STRING1 and STRING2. We return either the position in the strings at which the match was found, -1 if no match, or -2 if error (such as failure stack overflow). */ int re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop) struct re_pattern_buffer *bufp; const char *string1, *string2; int size1, size2; int startpos; int range; struct re_registers *regs; int stop; { int val; register char *fastmap = bufp->fastmap; register char *translate = bufp->translate; int total_size = size1 + size2; int endpos = startpos + range; /* Check for out-of-range STARTPOS. */ if (startpos < 0 || startpos > total_size) return -1; /* Fix up RANGE if it might eventually take us outside the virtual concatenation of STRING1 and STRING2. */ if (endpos < -1) range = -1 - startpos; else if (endpos > total_size) range = total_size - startpos; /* If the search isn't to be a backwards one, don't waste time in a search for a pattern that must be anchored. */ if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0) { if (startpos > 0) return -1; else range = 1; } /* Update the fastmap now if not correct already. */ if (fastmap && !bufp->fastmap_accurate) if (re_compile_fastmap (bufp) == -2) return -2; /* Loop through the string, looking for a place to start matching. */ for (;;) { /* If a fastmap is supplied, skip quickly over characters that cannot be the start of a match. If the pattern can match the null string, however, we don't need to skip characters; we want the first null string. */ if (fastmap && startpos < total_size && !bufp->can_be_null) { if (range > 0) /* Searching forwards. */ { register const char *d; register int lim = 0; int irange = range; if (startpos < size1 && startpos + range >= size1) lim = range - (size1 - startpos); d = (startpos >= size1 ? string2 - size1 : string1) + startpos; /* Written out as an if-else to avoid testing `translate' inside the loop. */ if (translate) while (range > lim && !fastmap[(unsigned char) translate[(unsigned char) *d++]]) range--; else while (range > lim && !fastmap[(unsigned char) *d++]) range--; startpos += irange - range; } else /* Searching backwards. */ { register char c = (size1 == 0 || startpos >= size1 ? string2[startpos - size1] : string1[startpos]); if (!fastmap[(unsigned char) TRANSLATE (c)]) goto advance; } } /* If can't match the null string, and that's all we have left, fail. */ if (range >= 0 && startpos == total_size && fastmap && !bufp->can_be_null) return -1; val = re_match_2 (bufp, string1, size1, string2, size2, startpos, regs, stop); if (val >= 0) return startpos; if (val == -2) return -2; advance: if (!range) break; else if (range > 0) { range--; startpos++; } else { range++; startpos--; } } return -1; } /* re_search_2 */ /* Declarations and macros for re_match_2. */ static int bcmp_translate (); static boolean alt_match_null_string_p (), common_op_match_null_string_p (), group_match_null_string_p (); /* This converts PTR, a pointer into one of the search strings `string1' and `string2' into an offset from the beginning of that string. */ #define POINTER_TO_OFFSET(ptr) \ (FIRST_STRING_P (ptr) ? (ptr) - string1 : (ptr) - string2 + size1) /* Macros for dealing with the split strings in re_match_2. */ #define MATCHING_IN_FIRST_STRING (dend == end_match_1) /* Call before fetching a character with *d. This switches over to string2 if necessary. */ #define PREFETCH() \ while (d == dend) \ { \ /* End of string2 => fail. */ \ if (dend == end_match_2) \ goto fail; \ /* End of string1 => advance to string2. */ \ d = string2; \ dend = end_match_2; \ } /* Test if at very beginning or at very end of the virtual concatenation of `string1' and `string2'. If only one string, it's `string2'. */ #define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2) #define AT_STRINGS_END(d) ((d) == end2) /* Test if D points to a character which is word-constituent. We have two special cases to check for: if past the end of string1, look at the first character in string2; and if before the beginning of string2, look at the last character in string1. */ #define WORDCHAR_P(d) \ (SYNTAX ((d) == end1 ? *string2 \ : (d) == string2 - 1 ? *(end1 - 1) : *(d)) \ == Sword) /* Test if the character before D and the one at D differ with respect to being word-constituent. */ #define AT_WORD_BOUNDARY(d) \ (AT_STRINGS_BEG (d) || AT_STRINGS_END (d) \ || WORDCHAR_P (d - 1) != WORDCHAR_P (d)) /* Free everything we malloc. */ #ifdef MATCH_MAY_ALLOCATE #ifdef REGEX_MALLOC #define FREE_VAR(var) if (var) free (var); var = NULL #define FREE_VARIABLES() \ do { \ FREE_VAR (fail_stack.stack); \ FREE_VAR (regstart); \ FREE_VAR (regend); \ FREE_VAR (old_regstart); \ FREE_VAR (old_regend); \ FREE_VAR (best_regstart); \ FREE_VAR (best_regend); \ FREE_VAR (reg_info); \ FREE_VAR (reg_dummy); \ FREE_VAR (reg_info_dummy); \ } while (0) #else /* not REGEX_MALLOC */ /* Some MIPS systems (at least) want this to free alloca'd storage. */ #define FREE_VARIABLES() alloca (0) #endif /* not REGEX_MALLOC */ #else #define FREE_VARIABLES() /* Do nothing! */ #endif /* not MATCH_MAY_ALLOCATE */ /* These values must meet several constraints. They must not be valid register values; since we have a limit of 255 registers (because we use only one byte in the pattern for the register number), we can use numbers larger than 255. They must differ by 1, because of NUM_FAILURE_ITEMS above. And the value for the lowest register must be larger than the value for the highest register, so we do not try to actually save any registers when none are active. */ #define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH) #define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1) /* Matching routines. */ #ifndef emacs /* Emacs never uses this. */ /* re_match is like re_match_2 except it takes only a single string. */ int re_match (bufp, string, size, pos, regs) struct re_pattern_buffer *bufp; const char *string; int size, pos; struct re_registers *regs; { return re_match_2 (bufp, NULL, 0, string, size, pos, regs, size); } #endif /* not emacs */ /* re_match_2 matches the compiled pattern in BUFP against the the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1 and SIZE2, respectively). We start matching at POS, and stop matching at STOP. If REGS is non-null and the `no_sub' field of BUFP is nonzero, we store offsets for the substring each group matched in REGS. See the documentation for exactly how many groups we fill. We return -1 if no match, -2 if an internal error (such as the failure stack overflowing). Otherwise, we return the length of the matched substring. */ int re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop) struct re_pattern_buffer *bufp; const char *string1, *string2; int size1, size2; int pos; struct re_registers *regs; int stop; { /* General temporaries. */ int mcnt; unsigned char *p1; /* Just past the end of the corresponding string. */ const char *end1, *end2; /* Pointers into string1 and string2, just past the last characters in each to consider matching. */ const char *end_match_1, *end_match_2; /* Where we are in the data, and the end of the current string. */ const char *d, *dend; /* Where we are in the pattern, and the end of the pattern. */ unsigned char *p = bufp->buffer; register unsigned char *pend = p + bufp->used; /* We use this to map every character in the string. */ char *translate = bufp->translate; /* Failure point stack. Each place that can handle a failure further down the line pushes a failure point on this stack. It consists of restart, regend, and reg_info for all registers corresponding to the subexpressions we're currently inside, plus the number of such registers, and, finally, two char *'s. The first char * is where to resume scanning the pattern; the second one is where to resume scanning the strings. If the latter is zero, the failure point is a ``dummy''; if a failure happens and the failure point is a dummy, it gets discarded and the next next one is tried. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ fail_stack_type fail_stack; #endif #ifdef DEBUG static unsigned failure_id = 0; unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0; #endif /* We fill all the registers internally, independent of what we return, for use in backreferences. The number here includes an element for register zero. */ unsigned num_regs = bufp->re_nsub + 1; /* The currently active registers. */ unsigned lowest_active_reg = NO_LOWEST_ACTIVE_REG; unsigned highest_active_reg = NO_HIGHEST_ACTIVE_REG; /* Information on the contents of registers. These are pointers into the input strings; they record just what was matched (on this attempt) by a subexpression part of the pattern, that is, the regnum-th regstart pointer points to where in the pattern we began matching and the regnum-th regend points to right after where we stopped matching the regnum-th subexpression. (The zeroth register keeps track of what the whole pattern matches.) */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **regstart, **regend; #endif /* If a group that's operated upon by a repetition operator fails to match anything, then the register for its start will need to be restored because it will have been set to wherever in the string we are when we last see its open-group operator. Similarly for a register's end. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **old_regstart, **old_regend; #endif /* The is_active field of reg_info helps us keep track of which (possibly nested) subexpressions we are currently in. The matched_something field of reg_info[reg_num] helps us tell whether or not we have matched any of the pattern so far this time through the reg_num-th subexpression. These two fields get reset each time through any loop their register is in. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ register_info_type *reg_info; #endif /* The following record the register info as found in the above variables when we find a match better than any we've seen before. This happens as we backtrack through the failure points, which in turn happens only if we have not yet matched the entire string. */ unsigned best_regs_set = false; #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **best_regstart, **best_regend; #endif /* Logically, this is `best_regend[0]'. But we don't want to have to allocate space for that if we're not allocating space for anything else (see below). Also, we never need info about register 0 for any of the other register vectors, and it seems rather a kludge to treat `best_regend' differently than the rest. So we keep track of the end of the best match so far in a separate variable. We initialize this to NULL so that when we backtrack the first time and need to test it, it's not garbage. */ const char *match_end = NULL; /* Used when we pop values we don't care about. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **reg_dummy; register_info_type *reg_info_dummy; #endif #ifdef DEBUG /* Counts the total number of registers pushed. */ unsigned num_regs_pushed = 0; #endif DEBUG_PRINT1 ("\n\nEntering re_match_2.\n"); INIT_FAIL_STACK (); #ifdef MATCH_MAY_ALLOCATE /* Do not bother to initialize all the register variables if there are no groups in the pattern, as it takes a fair amount of time. If there are groups, we include space for register 0 (the whole pattern), even though we never use it, since it simplifies the array indexing. We should fix this. */ if (bufp->re_nsub) { regstart = REGEX_TALLOC (num_regs, const char *); regend = REGEX_TALLOC (num_regs, const char *); old_regstart = REGEX_TALLOC (num_regs, const char *); old_regend = REGEX_TALLOC (num_regs, const char *); best_regstart = REGEX_TALLOC (num_regs, const char *); best_regend = REGEX_TALLOC (num_regs, const char *); reg_info = REGEX_TALLOC (num_regs, register_info_type); reg_dummy = REGEX_TALLOC (num_regs, const char *); reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type); if (!(regstart && regend && old_regstart && old_regend && reg_info && best_regstart && best_regend && reg_dummy && reg_info_dummy)) { FREE_VARIABLES (); return -2; } } #if defined (REGEX_MALLOC) else { /* We must initialize all our variables to NULL, so that `FREE_VARIABLES' doesn't try to free them. */ regstart = regend = old_regstart = old_regend = best_regstart = best_regend = reg_dummy = NULL; reg_info = reg_info_dummy = (register_info_type *) NULL; } #endif /* REGEX_MALLOC */ #endif /* MATCH_MAY_ALLOCATE */ /* The starting position is bogus. */ if (pos < 0 || pos > size1 + size2) { FREE_VARIABLES (); return -1; } /* Initialize subexpression text positions to -1 to mark ones that no start_memory/stop_memory has been seen for. Also initialize the register information struct. */ for (mcnt = 1; mcnt < num_regs; mcnt++) { regstart[mcnt] = regend[mcnt] = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE; REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE; IS_ACTIVE (reg_info[mcnt]) = 0; MATCHED_SOMETHING (reg_info[mcnt]) = 0; EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0; } /* We move `string1' into `string2' if the latter's empty -- but not if `string1' is null. */ if (size2 == 0 && string1 != NULL) { string2 = string1; size2 = size1; string1 = 0; size1 = 0; } end1 = string1 + size1; end2 = string2 + size2; /* Compute where to stop matching, within the two strings. */ if (stop <= size1) { end_match_1 = string1 + stop; end_match_2 = string2; } else { end_match_1 = end1; end_match_2 = string2 + stop - size1; } /* `p' scans through the pattern as `d' scans through the data. `dend' is the end of the input string that `d' points within. `d' is advanced into the following input string whenever necessary, but this happens before fetching; therefore, at the beginning of the loop, `d' can be pointing at the end of a string, but it cannot equal `string2'. */ if (size1 > 0 && pos <= size1) { d = string1 + pos; dend = end_match_1; } else { d = string2 + pos - size1; dend = end_match_2; } DEBUG_PRINT1 ("The compiled pattern is: "); DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend); DEBUG_PRINT1 ("The string to match is: `"); DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2); DEBUG_PRINT1 ("'\n"); /* This loops over pattern commands. It exits by returning from the function if the match is complete, or it drops through if the match fails at this starting point in the input data. */ for (;;) { DEBUG_PRINT2 ("\n0x%x: ", p); if (p == pend) { /* End of pattern means we might have succeeded. */ DEBUG_PRINT1 ("end of pattern ... "); /* If we haven't matched the entire string, and we want the longest match, try backtracking. */ if (d != end_match_2) { DEBUG_PRINT1 ("backtracking.\n"); if (!FAIL_STACK_EMPTY ()) { /* More failure points to try. */ boolean same_str_p = (FIRST_STRING_P (match_end) == MATCHING_IN_FIRST_STRING); /* If exceeds best match so far, save it. */ if (!best_regs_set || (same_str_p && d > match_end) || (!same_str_p && !MATCHING_IN_FIRST_STRING)) { best_regs_set = true; match_end = d; DEBUG_PRINT1 ("\nSAVING match as best so far.\n"); for (mcnt = 1; mcnt < num_regs; mcnt++) { best_regstart[mcnt] = regstart[mcnt]; best_regend[mcnt] = regend[mcnt]; } } goto fail; } /* If no failure points, don't restore garbage. */ else if (best_regs_set) { restore_best_regs: /* Restore best match. It may happen that `dend == end_match_1' while the restored d is in string2. For example, the pattern `x.*y.*z' against the strings `x-' and `y-z-', if the two strings are not consecutive in memory. */ DEBUG_PRINT1 ("Restoring best registers.\n"); d = match_end; dend = ((d >= string1 && d <= end1) ? end_match_1 : end_match_2); for (mcnt = 1; mcnt < num_regs; mcnt++) { regstart[mcnt] = best_regstart[mcnt]; regend[mcnt] = best_regend[mcnt]; } } } /* d != end_match_2 */ DEBUG_PRINT1 ("Accepting match.\n"); /* If caller wants register contents data back, do it. */ if (regs && !bufp->no_sub) { /* Have the register data arrays been allocated? */ if (bufp->regs_allocated == REGS_UNALLOCATED) { /* No. So allocate them with malloc. We need one extra element beyond `num_regs' for the `-1' marker GNU code uses. */ regs->num_regs = MAX (RE_NREGS, num_regs + 1); regs->start = TALLOC (regs->num_regs, regoff_t); regs->end = TALLOC (regs->num_regs, regoff_t); if (regs->start == NULL || regs->end == NULL) return -2; bufp->regs_allocated = REGS_REALLOCATE; } else if (bufp->regs_allocated == REGS_REALLOCATE) { /* Yes. If we need more elements than were already allocated, reallocate them. If we need fewer, just leave it alone. */ if (regs->num_regs < num_regs + 1) { regs->num_regs = num_regs + 1; RETALLOC (regs->start, regs->num_regs, regoff_t); RETALLOC (regs->end, regs->num_regs, regoff_t); if (regs->start == NULL || regs->end == NULL) return -2; } } else { /* These braces fend off a "empty body in an else-statement" warning under GCC when assert expands to nothing. */ assert (bufp->regs_allocated == REGS_FIXED); } /* Convert the pointer data in `regstart' and `regend' to indices. Register zero has to be set differently, since we haven't kept track of any info for it. */ if (regs->num_regs > 0) { regs->start[0] = pos; regs->end[0] = (MATCHING_IN_FIRST_STRING ? d - string1 : d - string2 + size1); } /* Go through the first `min (num_regs, regs->num_regs)' registers, since that is all we initialized. */ for (mcnt = 1; mcnt < MIN (num_regs, regs->num_regs); mcnt++) { if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt])) regs->start[mcnt] = regs->end[mcnt] = -1; else { regs->start[mcnt] = POINTER_TO_OFFSET (regstart[mcnt]); regs->end[mcnt] = POINTER_TO_OFFSET (regend[mcnt]); } } /* If the regs structure we return has more elements than were in the pattern, set the extra elements to -1. If we (re)allocated the registers, this is the case, because we always allocate enough to have at least one -1 at the end. */ for (mcnt = num_regs; mcnt < regs->num_regs; mcnt++) regs->start[mcnt] = regs->end[mcnt] = -1; } /* regs && !bufp->no_sub */ FREE_VARIABLES (); DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n", nfailure_points_pushed, nfailure_points_popped, nfailure_points_pushed - nfailure_points_popped); DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed); mcnt = d - pos - (MATCHING_IN_FIRST_STRING ? string1 : string2 - size1); DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt); return mcnt; } /* Otherwise match next pattern command. */ #ifdef SWITCH_ENUM_BUG switch ((int) ((re_opcode_t) *p++)) #else switch ((re_opcode_t) *p++) #endif { /* Ignore these. Used to ignore the n of succeed_n's which currently have n == 0. */ case no_op: DEBUG_PRINT1 ("EXECUTING no_op.\n"); break; /* Match the next n pattern characters exactly. The following byte in the pattern defines n, and the n bytes after that are the characters to match. */ case exactn: mcnt = *p++; DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt); /* This is written out as an if-else so we don't waste time testing `translate' inside the loop. */ if (translate) { do { PREFETCH (); if (translate[(unsigned char) *d++] != (char) *p++) goto fail; } while (--mcnt); } else { do { PREFETCH (); if (*d++ != (char) *p++) goto fail; } while (--mcnt); } SET_REGS_MATCHED (); break; /* Match any character except possibly a newline or a null. */ case anychar: DEBUG_PRINT1 ("EXECUTING anychar.\n"); PREFETCH (); if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n') || (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000')) goto fail; SET_REGS_MATCHED (); DEBUG_PRINT2 (" Matched `%d'.\n", *d); d++; break; case charset: case charset_not: { register unsigned char c; boolean not = (re_opcode_t) *(p - 1) == charset_not; DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : ""); PREFETCH (); c = TRANSLATE (*d); /* The character to match. */ /* Cast to `unsigned' instead of `unsigned char' in case the bit list is a full 32 bytes long. */ if (c < (unsigned) (*p * BYTEWIDTH) && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) not = !not; p += 1 + *p; if (!not) goto fail; SET_REGS_MATCHED (); d++; break; } /* The beginning of a group is represented by start_memory. The arguments are the register number in the next byte, and the number of groups inner to this one in the next. The text matched within the group is recorded (in the internal registers data structure) under the register number. */ case start_memory: DEBUG_PRINT3 ("EXECUTING start_memory %d (%d):\n", *p, p[1]); /* Find out if this group can match the empty string. */ p1 = p; /* To send to group_match_null_string_p. */ if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE) REG_MATCH_NULL_STRING_P (reg_info[*p]) = group_match_null_string_p (&p1, pend, reg_info); /* Save the position in the string where we were the last time we were at this open-group operator in case the group is operated upon by a repetition operator, e.g., with `(a*)*b' against `ab'; then we want to ignore where we are now in the string in case this attempt to match fails. */ old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) ? REG_UNSET (regstart[*p]) ? d : regstart[*p] : regstart[*p]; DEBUG_PRINT2 (" old_regstart: %d\n", POINTER_TO_OFFSET (old_regstart[*p])); regstart[*p] = d; DEBUG_PRINT2 (" regstart: %d\n", POINTER_TO_OFFSET (regstart[*p])); IS_ACTIVE (reg_info[*p]) = 1; MATCHED_SOMETHING (reg_info[*p]) = 0; /* This is the new highest active register. */ highest_active_reg = *p; /* If nothing was active before, this is the new lowest active register. */ if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) lowest_active_reg = *p; /* Move past the register number and inner group count. */ p += 2; break; /* The stop_memory opcode represents the end of a group. Its arguments are the same as start_memory's: the register number, and the number of inner groups. */ case stop_memory: DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]); /* We need to save the string position the last time we were at this close-group operator in case the group is operated upon by a repetition operator, e.g., with `((a*)*(b*)*)*' against `aba'; then we want to ignore where we are now in the string in case this attempt to match fails. */ old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) ? REG_UNSET (regend[*p]) ? d : regend[*p] : regend[*p]; DEBUG_PRINT2 (" old_regend: %d\n", POINTER_TO_OFFSET (old_regend[*p])); regend[*p] = d; DEBUG_PRINT2 (" regend: %d\n", POINTER_TO_OFFSET (regend[*p])); /* This register isn't active anymore. */ IS_ACTIVE (reg_info[*p]) = 0; /* If this was the only register active, nothing is active anymore. */ if (lowest_active_reg == highest_active_reg) { lowest_active_reg = NO_LOWEST_ACTIVE_REG; highest_active_reg = NO_HIGHEST_ACTIVE_REG; } else { /* We must scan for the new highest active register, since it isn't necessarily one less than now: consider (a(b)c(d(e)f)g). When group 3 ends, after the f), the new highest active register is 1. */ unsigned char r = *p - 1; while (r > 0 && !IS_ACTIVE (reg_info[r])) r--; /* If we end up at register zero, that means that we saved the registers as the result of an `on_failure_jump', not a `start_memory', and we jumped to past the innermost `stop_memory'. For example, in ((.)*) we save registers 1 and 2 as a result of the *, but when we pop back to the second ), we are at the stop_memory 1. Thus, nothing is active. */ if (r == 0) { lowest_active_reg = NO_LOWEST_ACTIVE_REG; highest_active_reg = NO_HIGHEST_ACTIVE_REG; } else highest_active_reg = r; } /* If just failed to match something this time around with a group that's operated on by a repetition operator, try to force exit from the ``loop'', and restore the register information for this group that we had before trying this last match. */ if ((!MATCHED_SOMETHING (reg_info[*p]) || (re_opcode_t) p[-3] == start_memory) && (p + 2) < pend) { boolean is_a_jump_n = false; p1 = p + 2; mcnt = 0; switch ((re_opcode_t) *p1++) { case jump_n: is_a_jump_n = true; case pop_failure_jump: case maybe_pop_jump: case jump: case dummy_failure_jump: EXTRACT_NUMBER_AND_INCR (mcnt, p1); if (is_a_jump_n) p1 += 2; break; default: /* do nothing */ ; } p1 += mcnt; /* If the next operation is a jump backwards in the pattern to an on_failure_jump right before the start_memory corresponding to this stop_memory, exit from the loop by forcing a failure after pushing on the stack the on_failure_jump's jump in the pattern, and d. */ if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump && (re_opcode_t) p1[3] == start_memory && p1[4] == *p) { /* If this group ever matched anything, then restore what its registers were before trying this last failed match, e.g., with `(a*)*b' against `ab' for regstart[1], and, e.g., with `((a*)*(b*)*)*' against `aba' for regend[3]. Also restore the registers for inner groups for, e.g., `((a*)(b*))*' against `aba' (register 3 would otherwise get trashed). */ if (EVER_MATCHED_SOMETHING (reg_info[*p])) { unsigned r; EVER_MATCHED_SOMETHING (reg_info[*p]) = 0; /* Restore this and inner groups' (if any) registers. */ for (r = *p; r < *p + *(p + 1); r++) { regstart[r] = old_regstart[r]; /* xx why this test? */ if ((int) old_regend[r] >= (int) regstart[r]) regend[r] = old_regend[r]; } } p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); PUSH_FAILURE_POINT (p1 + mcnt, d, -2); goto fail; } } /* Move past the register number and the inner group count. */ p += 2; break; /* \ has been turned into a `duplicate' command which is followed by the numeric value of as the register number. */ case duplicate: { register const char *d2, *dend2; int regno = *p++; /* Get which register to match against. */ DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno); /* Can't back reference a group which we've never matched. */ if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno])) goto fail; /* Where in input to try to start matching. */ d2 = regstart[regno]; /* Where to stop matching; if both the place to start and the place to stop matching are in the same string, then set to the place to stop, otherwise, for now have to use the end of the first string. */ dend2 = ((FIRST_STRING_P (regstart[regno]) == FIRST_STRING_P (regend[regno])) ? regend[regno] : end_match_1); for (;;) { /* If necessary, advance to next segment in register contents. */ while (d2 == dend2) { if (dend2 == end_match_2) break; if (dend2 == regend[regno]) break; /* End of string1 => advance to string2. */ d2 = string2; dend2 = regend[regno]; } /* At end of register contents => success */ if (d2 == dend2) break; /* If necessary, advance to next segment in data. */ PREFETCH (); /* How many characters left in this segment to match. */ mcnt = dend - d; /* Want how many consecutive characters we can match in one shot, so, if necessary, adjust the count. */ if (mcnt > dend2 - d2) mcnt = dend2 - d2; /* Compare that many; failure if mismatch, else move past them. */ if (translate ? bcmp_translate (d, d2, mcnt, translate) : bcmp (d, d2, mcnt)) goto fail; d += mcnt, d2 += mcnt; } } break; /* begline matches the empty string at the beginning of the string (unless `not_bol' is set in `bufp'), and, if `newline_anchor' is set, after newlines. */ case begline: DEBUG_PRINT1 ("EXECUTING begline.\n"); if (AT_STRINGS_BEG (d)) { if (!bufp->not_bol) break; } else if (d[-1] == '\n' && bufp->newline_anchor) { break; } /* In all other cases, we fail. */ goto fail; /* endline is the dual of begline. */ case endline: DEBUG_PRINT1 ("EXECUTING endline.\n"); if (AT_STRINGS_END (d)) { if (!bufp->not_eol) break; } /* We have to ``prefetch'' the next character. */ else if ((d == end1 ? *string2 : *d) == '\n' && bufp->newline_anchor) { break; } goto fail; /* Match at the very beginning of the data. */ case begbuf: DEBUG_PRINT1 ("EXECUTING begbuf.\n"); if (AT_STRINGS_BEG (d)) break; goto fail; /* Match at the very end of the data. */ case endbuf: DEBUG_PRINT1 ("EXECUTING endbuf.\n"); if (AT_STRINGS_END (d)) break; goto fail; /* on_failure_keep_string_jump is used to optimize `.*\n'. It pushes NULL as the value for the string on the stack. Then `pop_failure_point' will keep the current value for the string, instead of restoring it. To see why, consider matching `foo\nbar' against `.*\n'. The .* matches the foo; then the . fails against the \n. But the next thing we want to do is match the \n against the \n; if we restored the string value, we would be back at the foo. Because this is used only in specific cases, we don't need to check all the things that `on_failure_jump' does, to make sure the right things get saved on the stack. Hence we don't share its code. The only reason to push anything on the stack at all is that otherwise we would have to change `anychar's code to do something besides goto fail in this case; that seems worse than this. */ case on_failure_keep_string_jump: DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump"); EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt); PUSH_FAILURE_POINT (p + mcnt, NULL, -2); break; /* Uses of on_failure_jump: Each alternative starts with an on_failure_jump that points to the beginning of the next alternative. Each alternative except the last ends with a jump that in effect jumps past the rest of the alternatives. (They really jump to the ending jump of the following alternative, because tensioning these jumps is a hassle.) Repeats start with an on_failure_jump that points past both the repetition text and either the following jump or pop_failure_jump back to this on_failure_jump. */ case on_failure_jump: on_failure: DEBUG_PRINT1 ("EXECUTING on_failure_jump"); EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt); /* If this on_failure_jump comes right before a group (i.e., the original * applied to a group), save the information for that group and all inner ones, so that if we fail back to this point, the group's information will be correct. For example, in \(a*\)*\1, we need the preceding group, and in \(\(a*\)b*\)\2, we need the inner group. */ /* We can't use `p' to check ahead because we push a failure point to `p + mcnt' after we do this. */ p1 = p; /* We need to skip no_op's before we look for the start_memory in case this on_failure_jump is happening as the result of a completed succeed_n, as in \(a\)\{1,3\}b\1 against aba. */ while (p1 < pend && (re_opcode_t) *p1 == no_op) p1++; if (p1 < pend && (re_opcode_t) *p1 == start_memory) { /* We have a new highest active register now. This will get reset at the start_memory we are about to get to, but we will have saved all the registers relevant to this repetition op, as described above. */ highest_active_reg = *(p1 + 1) + *(p1 + 2); if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) lowest_active_reg = *(p1 + 1); } DEBUG_PRINT1 (":\n"); PUSH_FAILURE_POINT (p + mcnt, d, -2); break; /* A smart repeat ends with `maybe_pop_jump'. We change it to either `pop_failure_jump' or `jump'. */ case maybe_pop_jump: EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt); { register unsigned char *p2 = p; /* Compare the beginning of the repeat with what in the pattern follows its end. If we can establish that there is nothing that they would both match, i.e., that we would have to backtrack because of (as in, e.g., `a*a') then we can change to pop_failure_jump, because we'll never have to backtrack. This is not true in the case of alternatives: in `(a|ab)*' we do need to backtrack to the `ab' alternative (e.g., if the string was `ab'). But instead of trying to detect that here, the alternative has put on a dummy failure point which is what we will end up popping. */ /* Skip over open/close-group commands. If what follows this loop is a ...+ construct, look at what begins its body, since we will have to match at least one of that. */ while (1) { if (p2 + 2 < pend && ((re_opcode_t) *p2 == stop_memory || (re_opcode_t) *p2 == start_memory)) p2 += 3; else if (p2 + 6 < pend && (re_opcode_t) *p2 == dummy_failure_jump) p2 += 6; else break; } p1 = p + mcnt; /* p1[0] ... p1[2] are the `on_failure_jump' corresponding to the `maybe_finalize_jump' of this case. Examine what follows. */ /* If we're at the end of the pattern, we can change. */ if (p2 == pend) { /* Consider what happens when matching ":\(.*\)" against ":/". I don't really understand this code yet. */ p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" End of pattern: change to `pop_failure_jump'.\n"); } else if ((re_opcode_t) *p2 == exactn || (bufp->newline_anchor && (re_opcode_t) *p2 == endline)) { register unsigned char c = *p2 == (unsigned char) endline ? '\n' : p2[2]; if ((re_opcode_t) p1[3] == exactn && p1[5] != c) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", c, p1[5]); } else if ((re_opcode_t) p1[3] == charset || (re_opcode_t) p1[3] == charset_not) { int not = (re_opcode_t) p1[3] == charset_not; if (c < (unsigned char) (p1[4] * BYTEWIDTH) && p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) not = !not; /* `not' is equal to 1 if c would match, which means that we can't change to pop_failure_jump. */ if (!not) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); } } } else if ((re_opcode_t) *p2 == charset) { register unsigned char c = *p2 == (unsigned char) endline ? '\n' : p2[2]; if ((re_opcode_t) p1[3] == exactn && ! (p2[1] * BYTEWIDTH > p1[4] && (p2[1 + p1[4] / BYTEWIDTH] & (1 << (p1[4] % BYTEWIDTH))))) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", c, p1[5]); } else if ((re_opcode_t) p1[3] == charset_not) { int idx; /* We win if the charset_not inside the loop lists every character listed in the charset after. */ for (idx = 0; idx < p2[1]; idx++) if (! (p2[2 + idx] == 0 || (idx < p1[4] && ((p2[2 + idx] & ~ p1[5 + idx]) == 0)))) break; if (idx == p2[1]) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); } } else if ((re_opcode_t) p1[3] == charset) { int idx; /* We win if the charset inside the loop has no overlap with the one after the loop. */ for (idx = 0; idx < p2[1] && idx < p1[4]; idx++) if ((p2[2 + idx] & p1[5 + idx]) != 0) break; if (idx == p2[1] || idx == p1[4]) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); } } } } p -= 2; /* Point at relative address again. */ if ((re_opcode_t) p[-1] != pop_failure_jump) { p[-1] = (unsigned char) jump; DEBUG_PRINT1 (" Match => jump.\n"); goto unconditional_jump; } /* Note fall through. */ /* The end of a simple repeat has a pop_failure_jump back to its matching on_failure_jump, where the latter will push a failure point. The pop_failure_jump takes off failure points put on by this pop_failure_jump's matching on_failure_jump; we got through the pattern to here from the matching on_failure_jump, so didn't fail. */ case pop_failure_jump: { /* We need to pass separate storage for the lowest and highest registers, even though we don't care about the actual values. Otherwise, we will restore only one register from the stack, since lowest will == highest in `pop_failure_point'. */ unsigned dummy_low_reg, dummy_high_reg; unsigned char *pdummy; const char *sdummy; DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n"); POP_FAILURE_POINT (sdummy, pdummy, dummy_low_reg, dummy_high_reg, reg_dummy, reg_dummy, reg_info_dummy); } /* Note fall through. */ /* Unconditionally jump (without popping any failure points). */ case jump: unconditional_jump: EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */ DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt); p += mcnt; /* Do the jump. */ DEBUG_PRINT2 ("(to 0x%x).\n", p); break; /* We need this opcode so we can detect where alternatives end in `group_match_null_string_p' et al. */ case jump_past_alt: DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n"); goto unconditional_jump; /* Normally, the on_failure_jump pushes a failure point, which then gets popped at pop_failure_jump. We will end up at pop_failure_jump, also, and with a pattern of, say, `a+', we are skipping over the on_failure_jump, so we have to push something meaningless for pop_failure_jump to pop. */ case dummy_failure_jump: DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n"); /* It doesn't matter what we push for the string here. What the code at `fail' tests is the value for the pattern. */ PUSH_FAILURE_POINT (0, 0, -2); goto unconditional_jump; /* At the end of an alternative, we need to push a dummy failure point in case we are followed by a `pop_failure_jump', because we don't want the failure point for the alternative to be popped. For example, matching `(a|ab)*' against `aab' requires that we match the `ab' alternative. */ case push_dummy_failure: DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n"); /* See comments just above at `dummy_failure_jump' about the two zeroes. */ PUSH_FAILURE_POINT (0, 0, -2); break; /* Have to succeed matching what follows at least n times. After that, handle like `on_failure_jump'. */ case succeed_n: EXTRACT_NUMBER (mcnt, p + 2); DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt); assert (mcnt >= 0); /* Originally, this is how many times we HAVE to succeed. */ if (mcnt > 0) { mcnt--; p += 2; STORE_NUMBER_AND_INCR (p, mcnt); DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p, mcnt); } else if (mcnt == 0) { DEBUG_PRINT2 (" Setting two bytes from 0x%x to no_op.\n", p+2); p[2] = (unsigned char) no_op; p[3] = (unsigned char) no_op; goto on_failure; } break; case jump_n: EXTRACT_NUMBER (mcnt, p + 2); DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt); /* Originally, this is how many times we CAN jump. */ if (mcnt) { mcnt--; STORE_NUMBER (p + 2, mcnt); goto unconditional_jump; } /* If don't have to jump any more, skip over the rest of command. */ else p += 4; break; case set_number_at: { DEBUG_PRINT1 ("EXECUTING set_number_at.\n"); EXTRACT_NUMBER_AND_INCR (mcnt, p); p1 = p + mcnt; EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p1, mcnt); STORE_NUMBER (p1, mcnt); break; } case wordbound: DEBUG_PRINT1 ("EXECUTING wordbound.\n"); if (AT_WORD_BOUNDARY (d)) break; goto fail; case notwordbound: DEBUG_PRINT1 ("EXECUTING notwordbound.\n"); if (AT_WORD_BOUNDARY (d)) goto fail; break; case wordbeg: DEBUG_PRINT1 ("EXECUTING wordbeg.\n"); if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1))) break; goto fail; case wordend: DEBUG_PRINT1 ("EXECUTING wordend.\n"); if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1) && (!WORDCHAR_P (d) || AT_STRINGS_END (d))) break; goto fail; #ifdef emacs #ifdef emacs19 case before_dot: DEBUG_PRINT1 ("EXECUTING before_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) >= point) goto fail; break; case at_dot: DEBUG_PRINT1 ("EXECUTING at_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) != point) goto fail; break; case after_dot: DEBUG_PRINT1 ("EXECUTING after_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) <= point) goto fail; break; #else /* not emacs19 */ case at_dot: DEBUG_PRINT1 ("EXECUTING at_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) + 1 != point) goto fail; break; #endif /* not emacs19 */ case syntaxspec: DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt); mcnt = *p++; goto matchsyntax; case wordchar: DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n"); mcnt = (int) Sword; matchsyntax: PREFETCH (); if (SYNTAX (*d++) != (enum syntaxcode) mcnt) goto fail; SET_REGS_MATCHED (); break; case notsyntaxspec: DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt); mcnt = *p++; goto matchnotsyntax; case notwordchar: DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n"); mcnt = (int) Sword; matchnotsyntax: PREFETCH (); if (SYNTAX (*d++) == (enum syntaxcode) mcnt) goto fail; SET_REGS_MATCHED (); break; #else /* not emacs */ case wordchar: DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n"); PREFETCH (); if (!WORDCHAR_P (d)) goto fail; SET_REGS_MATCHED (); d++; break; case notwordchar: DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n"); PREFETCH (); if (WORDCHAR_P (d)) goto fail; SET_REGS_MATCHED (); d++; break; #endif /* not emacs */ default: abort (); } continue; /* Successfully executed one pattern command; keep going. */ /* We goto here if a matching operation fails. */ fail: if (!FAIL_STACK_EMPTY ()) { /* A restart point is known. Restore to that state. */ DEBUG_PRINT1 ("\nFAIL:\n"); POP_FAILURE_POINT (d, p, lowest_active_reg, highest_active_reg, regstart, regend, reg_info); /* If this failure point is a dummy, try the next one. */ if (!p) goto fail; /* If we failed to the end of the pattern, don't examine *p. */ assert (p <= pend); if (p < pend) { boolean is_a_jump_n = false; /* If failed to a backwards jump that's part of a repetition loop, need to pop this failure point and use the next one. */ switch ((re_opcode_t) *p) { case jump_n: is_a_jump_n = true; case maybe_pop_jump: case pop_failure_jump: case jump: p1 = p + 1; EXTRACT_NUMBER_AND_INCR (mcnt, p1); p1 += mcnt; if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n) || (!is_a_jump_n && (re_opcode_t) *p1 == on_failure_jump)) goto fail; break; default: /* do nothing */ ; } } if (d >= string1 && d <= end1) dend = end_match_1; } else break; /* Matching at this starting point really fails. */ } /* for (;;) */ if (best_regs_set) goto restore_best_regs; FREE_VARIABLES (); return -1; /* Failure to match. */ } /* re_match_2 */ /* Subroutine definitions for re_match_2. */ /* We are passed P pointing to a register number after a start_memory. Return true if the pattern up to the corresponding stop_memory can match the empty string, and false otherwise. If we find the matching stop_memory, sets P to point to one past its number. Otherwise, sets P to an undefined byte less than or equal to END. We don't handle duplicates properly (yet). */ static boolean group_match_null_string_p (p, end, reg_info) unsigned char **p, *end; register_info_type *reg_info; { int mcnt; /* Point to after the args to the start_memory. */ unsigned char *p1 = *p + 2; while (p1 < end) { /* Skip over opcodes that can match nothing, and return true or false, as appropriate, when we get to one that can't, or to the matching stop_memory. */ switch ((re_opcode_t) *p1) { /* Could be either a loop or a series of alternatives. */ case on_failure_jump: p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); /* If the next operation is not a jump backwards in the pattern. */ if (mcnt >= 0) { /* Go through the on_failure_jumps of the alternatives, seeing if any of the alternatives cannot match nothing. The last alternative starts with only a jump, whereas the rest start with on_failure_jump and end with a jump, e.g., here is the pattern for `a|b|c': /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6 /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3 /exactn/1/c So, we have to first go through the first (n-1) alternatives and then deal with the last one separately. */ /* Deal with the first (n-1) alternatives, which start with an on_failure_jump (see above) that jumps to right past a jump_past_alt. */ while ((re_opcode_t) p1[mcnt-3] == jump_past_alt) { /* `mcnt' holds how many bytes long the alternative is, including the ending `jump_past_alt' and its number. */ if (!alt_match_null_string_p (p1, p1 + mcnt - 3, reg_info)) return false; /* Move to right after this alternative, including the jump_past_alt. */ p1 += mcnt; /* Break if it's the beginning of an n-th alternative that doesn't begin with an on_failure_jump. */ if ((re_opcode_t) *p1 != on_failure_jump) break; /* Still have to check that it's not an n-th alternative that starts with an on_failure_jump. */ p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); if ((re_opcode_t) p1[mcnt-3] != jump_past_alt) { /* Get to the beginning of the n-th alternative. */ p1 -= 3; break; } } /* Deal with the last alternative: go back and get number of the `jump_past_alt' just before it. `mcnt' contains the length of the alternative. */ EXTRACT_NUMBER (mcnt, p1 - 2); if (!alt_match_null_string_p (p1, p1 + mcnt, reg_info)) return false; p1 += mcnt; /* Get past the n-th alternative. */ } /* if mcnt > 0 */ break; case stop_memory: assert (p1[1] == **p); *p = p1 + 2; return true; default: if (!common_op_match_null_string_p (&p1, end, reg_info)) return false; } } /* while p1 < end */ return false; } /* group_match_null_string_p */ /* Similar to group_match_null_string_p, but doesn't deal with alternatives: It expects P to be the first byte of a single alternative and END one byte past the last. The alternative can contain groups. */ static boolean alt_match_null_string_p (p, end, reg_info) unsigned char *p, *end; register_info_type *reg_info; { int mcnt; unsigned char *p1 = p; while (p1 < end) { /* Skip over opcodes that can match nothing, and break when we get to one that can't. */ switch ((re_opcode_t) *p1) { /* It's a loop. */ case on_failure_jump: p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); p1 += mcnt; break; default: if (!common_op_match_null_string_p (&p1, end, reg_info)) return false; } } /* while p1 < end */ return true; } /* alt_match_null_string_p */ /* Deals with the ops common to group_match_null_string_p and alt_match_null_string_p. Sets P to one after the op and its arguments, if any. */ static boolean common_op_match_null_string_p (p, end, reg_info) unsigned char **p, *end; register_info_type *reg_info; { int mcnt; boolean ret; int reg_no; unsigned char *p1 = *p; switch ((re_opcode_t) *p1++) { case no_op: case begline: case endline: case begbuf: case endbuf: case wordbeg: case wordend: case wordbound: case notwordbound: #ifdef emacs case before_dot: case at_dot: case after_dot: #endif break; case start_memory: reg_no = *p1; assert (reg_no > 0 && reg_no <= MAX_REGNUM); ret = group_match_null_string_p (&p1, end, reg_info); /* Have to set this here in case we're checking a group which contains a group and a back reference to it. */ if (REG_MATCH_NULL_STRING_P (reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE) REG_MATCH_NULL_STRING_P (reg_info[reg_no]) = ret; if (!ret) return false; break; /* If this is an optimized succeed_n for zero times, make the jump. */ case jump: EXTRACT_NUMBER_AND_INCR (mcnt, p1); if (mcnt >= 0) p1 += mcnt; else return false; break; case succeed_n: /* Get to the number of times to succeed. */ p1 += 2; EXTRACT_NUMBER_AND_INCR (mcnt, p1); if (mcnt == 0) { p1 -= 4; EXTRACT_NUMBER_AND_INCR (mcnt, p1); p1 += mcnt; } else return false; break; case duplicate: if (!REG_MATCH_NULL_STRING_P (reg_info[*p1])) return false; break; case set_number_at: p1 += 4; default: /* All other opcodes mean we cannot match the empty string. */ return false; } *p = p1; return true; } /* common_op_match_null_string_p */ /* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN bytes; nonzero otherwise. */ static int bcmp_translate (s1, s2, len, translate) unsigned char *s1, *s2; register int len; char *translate; { register unsigned char *p1 = s1, *p2 = s2; while (len) { if (translate[*p1++] != translate[*p2++]) return 1; len--; } return 0; } /* Entry points for GNU code. */ /* re_compile_pattern is the GNU regular expression compiler: it compiles PATTERN (of length SIZE) and puts the result in BUFP. Returns 0 if the pattern was valid, otherwise an error string. Assumes the `allocated' (and perhaps `buffer') and `translate' fields are set in BUFP on entry. We call regex_compile to do the actual compilation. */ const char * re_compile_pattern (pattern, length, bufp) const char *pattern; int length; struct re_pattern_buffer *bufp; { reg_errcode_t ret; /* GNU code is written to assume at least RE_NREGS registers will be set (and at least one extra will be -1). */ bufp->regs_allocated = REGS_UNALLOCATED; /* And GNU code determines whether or not to get register information by passing null for the REGS argument to re_match, etc., not by setting no_sub. */ bufp->no_sub = 0; /* Match anchors at newline. */ bufp->newline_anchor = 1; ret = regex_compile (pattern, length, re_syntax_options, bufp); return re_error_msg[(int) ret]; } /* Entry points compatible with 4.2 BSD regex library. We don't define them if this is an Emacs or POSIX compilation. */ #if !defined (emacs) && !defined (_POSIX_SOURCE) /* BSD has one and only one pattern buffer. */ static struct re_pattern_buffer re_comp_buf; char * re_comp (s) const char *s; { reg_errcode_t ret; if (!s) { if (!re_comp_buf.buffer) return "No previous regular expression"; return 0; } if (!re_comp_buf.buffer) { re_comp_buf.buffer = (unsigned char *) malloc (200); if (re_comp_buf.buffer == NULL) return "Memory exhausted"; re_comp_buf.allocated = 200; re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH); if (re_comp_buf.fastmap == NULL) return "Memory exhausted"; } /* Since `re_exec' always passes NULL for the `regs' argument, we don't need to initialize the pattern buffer fields which affect it. */ /* Match anchors at newlines. */ re_comp_buf.newline_anchor = 1; ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf); /* Yes, we're discarding `const' here. */ return (char *) re_error_msg[(int) ret]; } int re_exec (s) const char *s; { const int len = strlen (s); return 0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0); } #endif /* not emacs and not _POSIX_SOURCE */ /* POSIX.2 functions. Don't define these for Emacs. */ #ifndef emacs /* regcomp takes a regular expression as a string and compiles it. PREG is a regex_t *. We do not expect any fields to be initialized, since POSIX says we shouldn't. Thus, we set `buffer' to the compiled pattern; `used' to the length of the compiled pattern; `syntax' to RE_SYNTAX_POSIX_EXTENDED if the REG_EXTENDED bit in CFLAGS is set; otherwise, to RE_SYNTAX_POSIX_BASIC; `newline_anchor' to REG_NEWLINE being set in CFLAGS; `fastmap' and `fastmap_accurate' to zero; `re_nsub' to the number of subexpressions in PATTERN. PATTERN is the address of the pattern string. CFLAGS is a series of bits which affect compilation. If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we use POSIX basic syntax. If REG_NEWLINE is set, then . and [^...] don't match newline. Also, regexec will try a match beginning after every newline. If REG_ICASE is set, then we considers upper- and lowercase versions of letters to be equivalent when matching. If REG_NOSUB is set, then when PREG is passed to regexec, that routine will report only success or failure, and nothing about the registers. It returns 0 if it succeeds, nonzero if it doesn't. (See regex.h for the return codes and their meanings.) */ int regcomp (preg, pattern, cflags) regex_t *preg; const char *pattern; int cflags; { reg_errcode_t ret; unsigned syntax = (cflags & REG_EXTENDED) ? RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC; /* regex_compile will allocate the space for the compiled pattern. */ preg->buffer = 0; preg->allocated = 0; preg->used = 0; /* Don't bother to use a fastmap when searching. This simplifies the REG_NEWLINE case: if we used a fastmap, we'd have to put all the characters after newlines into the fastmap. This way, we just try every character. */ preg->fastmap = 0; if (cflags & REG_ICASE) { unsigned i; preg->translate = (char *) malloc (CHAR_SET_SIZE); if (preg->translate == NULL) return (int) REG_ESPACE; /* Map uppercase characters to corresponding lowercase ones. */ for (i = 0; i < CHAR_SET_SIZE; i++) preg->translate[i] = ISUPPER (i) ? tolower (i) : i; } else preg->translate = NULL; /* If REG_NEWLINE is set, newlines are treated differently. */ if (cflags & REG_NEWLINE) { /* REG_NEWLINE implies neither . nor [^...] match newline. */ syntax &= ~RE_DOT_NEWLINE; syntax |= RE_HAT_LISTS_NOT_NEWLINE; /* It also changes the matching behavior. */ preg->newline_anchor = 1; } else preg->newline_anchor = 0; preg->no_sub = !!(cflags & REG_NOSUB); /* POSIX says a null character in the pattern terminates it, so we can use strlen here in compiling the pattern. */ ret = regex_compile (pattern, strlen (pattern), syntax, preg); /* POSIX doesn't distinguish between an unmatched open-group and an unmatched close-group: both are REG_EPAREN. */ if (ret == REG_ERPAREN) ret = REG_EPAREN; return (int) ret; } /* regexec searches for a given pattern, specified by PREG, in the string STRING. If NMATCH is zero or REG_NOSUB was set in the cflags argument to `regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at least NMATCH elements, and we set them to the offsets of the corresponding matched substrings. EFLAGS specifies `execution flags' which affect matching: if REG_NOTBOL is set, then ^ does not match at the beginning of the string; if REG_NOTEOL is set, then $ does not match at the end. We return 0 if we find a match and REG_NOMATCH if not. */ int regexec (preg, string, nmatch, pmatch, eflags) const regex_t *preg; const char *string; size_t nmatch; regmatch_t pmatch[]; int eflags; { int ret; struct re_registers regs; regex_t private_preg; int len = strlen (string); boolean want_reg_info = !preg->no_sub && nmatch > 0; private_preg = *preg; private_preg.not_bol = !!(eflags & REG_NOTBOL); private_preg.not_eol = !!(eflags & REG_NOTEOL); /* The user has told us exactly how many registers to return information about, via `nmatch'. We have to pass that on to the matching routines. */ private_preg.regs_allocated = REGS_FIXED; if (want_reg_info) { regs.num_regs = nmatch; regs.start = TALLOC (nmatch, regoff_t); regs.end = TALLOC (nmatch, regoff_t); if (regs.start == NULL || regs.end == NULL) return (int) REG_NOMATCH; } /* Perform the searching operation. */ ret = re_search (&private_preg, string, len, /* start: */ 0, /* range: */ len, want_reg_info ? ®s : (struct re_registers *) 0); /* Copy the register information to the POSIX structure. */ if (want_reg_info) { if (ret >= 0) { unsigned r; for (r = 0; r < nmatch; r++) { pmatch[r].rm_so = regs.start[r]; pmatch[r].rm_eo = regs.end[r]; } } /* If we needed the temporary register info, free the space now. */ free (regs.start); free (regs.end); } /* We want zero return to mean success, unlike `re_search'. */ return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH; } /* Returns a message corresponding to an error code, ERRCODE, returned from either regcomp or regexec. We don't use PREG here. */ size_t regerror (errcode, preg, errbuf, errbuf_size) int errcode; const regex_t *preg; char *errbuf; size_t errbuf_size; { const char *msg; size_t msg_size; if (errcode < 0 || errcode >= (sizeof (re_error_msg) / sizeof (re_error_msg[0]))) /* Only error codes returned by the rest of the code should be passed to this routine. If we are given anything else, or if other regex code generates an invalid error code, then the program has a bug. Dump core so we can fix it. */ abort (); msg = re_error_msg[errcode]; /* POSIX doesn't require that we do anything in this case, but why not be nice. */ if (! msg) msg = "Success"; msg_size = strlen (msg) + 1; /* Includes the null. */ if (errbuf_size != 0) { if (msg_size > errbuf_size) { strncpy (errbuf, msg, errbuf_size - 1); errbuf[errbuf_size - 1] = 0; } else strcpy (errbuf, msg); } return msg_size; } /* Free dynamically allocated space used by PREG. */ void regfree (preg) regex_t *preg; { if (preg->buffer != NULL) free (preg->buffer); preg->buffer = NULL; preg->allocated = 0; preg->used = 0; if (preg->fastmap != NULL) free (preg->fastmap); preg->fastmap = NULL; preg->fastmap_accurate = 0; if (preg->translate != NULL) free (preg->translate); preg->translate = NULL; } #endif /* not emacs */ /* Local variables: make-backup-files: t version-control: t trim-versions-without-asking: nil End: */ diffutils-2.4/regex.h100666 12241 1 44406 5401254205 13632 0ustar rolanddaemon/* Definitions for data structures and routines for the regular expression library, version 0.12. Copyright (C) 1985, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __REGEXP_LIBRARY_H__ #define __REGEXP_LIBRARY_H__ /* POSIX says that must be included (by the caller) before . */ #ifdef VMS /* VMS doesn't have `size_t' in , even though POSIX says it should be there. */ #include #endif /* The following bits are used to determine the regexp syntax we recognize. The set/not-set meanings are chosen so that Emacs syntax remains the value 0. The bits are given in alphabetical order, and the definitions shifted by one from the previous bit; thus, when we add or remove a bit, only one other definition need change. */ typedef unsigned reg_syntax_t; /* If this bit is not set, then \ inside a bracket expression is literal. If set, then such a \ quotes the following character. */ #define RE_BACKSLASH_ESCAPE_IN_LISTS (1) /* If this bit is not set, then + and ? are operators, and \+ and \? are literals. If set, then \+ and \? are operators and + and ? are literals. */ #define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1) /* If this bit is set, then character classes are supported. They are: [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:], [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:]. If not set, then character classes are not supported. */ #define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1) /* If this bit is set, then ^ and $ are always anchors (outside bracket expressions, of course). If this bit is not set, then it depends: ^ is an anchor if it is at the beginning of a regular expression or after an open-group or an alternation operator; $ is an anchor if it is at the end of a regular expression, or before a close-group or an alternation operator. This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because POSIX draft 11.2 says that * etc. in leading positions is undefined. We already implemented a previous draft which made those constructs invalid, though, so we haven't changed the code back. */ #define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1) /* If this bit is set, then special characters are always special regardless of where they are in the pattern. If this bit is not set, then special characters are special only in some contexts; otherwise they are ordinary. Specifically, * + ? and intervals are only special when not after the beginning, open-group, or alternation operator. */ #define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1) /* If this bit is set, then *, +, ?, and { cannot be first in an re or immediately after an alternation or begin-group operator. */ #define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1) /* If this bit is set, then . matches newline. If not set, then it doesn't. */ #define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1) /* If this bit is set, then . doesn't match NUL. If not set, then it does. */ #define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1) /* If this bit is set, nonmatching lists [^...] do not match newline. If not set, they do. */ #define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1) /* If this bit is set, either \{...\} or {...} defines an interval, depending on RE_NO_BK_BRACES. If not set, \{, \}, {, and } are literals. */ #define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1) /* If this bit is set, +, ? and | aren't recognized as operators. If not set, they are. */ #define RE_LIMITED_OPS (RE_INTERVALS << 1) /* If this bit is set, newline is an alternation operator. If not set, newline is literal. */ #define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1) /* If this bit is set, then `{...}' defines an interval, and \{ and \} are literals. If not set, then `\{...\}' defines an interval. */ #define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1) /* If this bit is set, (...) defines a group, and \( and \) are literals. If not set, \(...\) defines a group, and ( and ) are literals. */ #define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1) /* If this bit is set, then \ matches . If not set, then \ is a back-reference. */ #define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1) /* If this bit is set, then | is an alternation operator, and \| is literal. If not set, then \| is an alternation operator, and | is literal. */ #define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1) /* If this bit is set, then an ending range point collating higher than the starting range point, as in [z-a], is invalid. If not set, then when ending range point collates higher than the starting range point, the range is ignored. */ #define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1) /* If this bit is set, then an unmatched ) is ordinary. If not set, then an unmatched ) is invalid. */ #define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1) /* This global variable defines the particular regexp syntax to use (for some interfaces). When a regexp is compiled, the syntax used is stored in the pattern buffer, so changing this does not affect already-compiled regexps. */ extern reg_syntax_t re_syntax_options; /* Define combinations of the above bits for the standard possibilities. (The [[[ comments delimit what gets put into the Texinfo file, so don't delete them!) */ /* [[[begin syntaxes]]] */ #define RE_SYNTAX_EMACS 0 #define RE_SYNTAX_AWK \ (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \ | RE_NO_BK_PARENS | RE_NO_BK_REFS \ | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \ | RE_UNMATCHED_RIGHT_PAREN_ORD) #define RE_SYNTAX_POSIX_AWK \ (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS) #define RE_SYNTAX_GREP \ (RE_BK_PLUS_QM | RE_CHAR_CLASSES \ | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \ | RE_NEWLINE_ALT) #define RE_SYNTAX_EGREP \ (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \ | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \ | RE_NEWLINE_ALT | RE_NO_BK_PARENS \ | RE_NO_BK_VBAR) #define RE_SYNTAX_POSIX_EGREP \ (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES) /* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */ #define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC #define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC /* Syntax bits common to both basic and extended POSIX regex syntax. */ #define _RE_SYNTAX_POSIX_COMMON \ (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \ | RE_INTERVALS | RE_NO_EMPTY_RANGES) #define RE_SYNTAX_POSIX_BASIC \ (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM) /* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this isn't minimal, since other operators, such as \`, aren't disabled. */ #define RE_SYNTAX_POSIX_MINIMAL_BASIC \ (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS) #define RE_SYNTAX_POSIX_EXTENDED \ (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \ | RE_NO_BK_PARENS | RE_NO_BK_VBAR \ | RE_UNMATCHED_RIGHT_PAREN_ORD) /* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */ #define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \ (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \ | RE_NO_BK_PARENS | RE_NO_BK_REFS \ | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD) /* [[[end syntaxes]]] */ /* Maximum number of duplicates an interval can allow. Some systems (erroneously) define this in other header files, but we want our value, so remove any previous define. */ #ifdef RE_DUP_MAX #undef RE_DUP_MAX #endif #define RE_DUP_MAX ((1 << 15) - 1) /* POSIX `cflags' bits (i.e., information for `regcomp'). */ /* If this bit is set, then use extended regular expression syntax. If not set, then use basic regular expression syntax. */ #define REG_EXTENDED 1 /* If this bit is set, then ignore case when matching. If not set, then case is significant. */ #define REG_ICASE (REG_EXTENDED << 1) /* If this bit is set, then anchors do not match at newline characters in the string. If not set, then anchors do match at newlines. */ #define REG_NEWLINE (REG_ICASE << 1) /* If this bit is set, then report only success or fail in regexec. If not set, then returns differ between not matching and errors. */ #define REG_NOSUB (REG_NEWLINE << 1) /* POSIX `eflags' bits (i.e., information for regexec). */ /* If this bit is set, then the beginning-of-line operator doesn't match the beginning of the string (presumably because it's not the beginning of a line). If not set, then the beginning-of-line operator does match the beginning of the string. */ #define REG_NOTBOL 1 /* Like REG_NOTBOL, except for the end-of-line. */ #define REG_NOTEOL (1 << 1) /* If any error codes are removed, changed, or added, update the `re_error_msg' table in regex.c. */ typedef enum { REG_NOERROR = 0, /* Success. */ REG_NOMATCH, /* Didn't find a match (for regexec). */ /* POSIX regcomp return error codes. (In the order listed in the standard.) */ REG_BADPAT, /* Invalid pattern. */ REG_ECOLLATE, /* Not implemented. */ REG_ECTYPE, /* Invalid character class name. */ REG_EESCAPE, /* Trailing backslash. */ REG_ESUBREG, /* Invalid back reference. */ REG_EBRACK, /* Unmatched left bracket. */ REG_EPAREN, /* Parenthesis imbalance. */ REG_EBRACE, /* Unmatched \{. */ REG_BADBR, /* Invalid contents of \{\}. */ REG_ERANGE, /* Invalid range end. */ REG_ESPACE, /* Ran out of memory. */ REG_BADRPT, /* No preceding re for repetition op. */ /* Error codes we've added. */ REG_EEND, /* Premature end. */ REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */ REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */ } reg_errcode_t; /* This data structure represents a compiled pattern. Before calling the pattern compiler, the fields `buffer', `allocated', `fastmap', `translate', and `no_sub' can be set. After the pattern has been compiled, the `re_nsub' field is available. All other fields are private to the regex routines. */ struct re_pattern_buffer { /* [[[begin pattern_buffer]]] */ /* Space that holds the compiled pattern. It is declared as `unsigned char *' because its elements are sometimes used as array indexes. */ unsigned char *buffer; /* Number of bytes to which `buffer' points. */ unsigned long allocated; /* Number of bytes actually used in `buffer'. */ unsigned long used; /* Syntax setting with which the pattern was compiled. */ reg_syntax_t syntax; /* Pointer to a fastmap, if any, otherwise zero. re_search uses the fastmap, if there is one, to skip over impossible starting points for matches. */ char *fastmap; /* Either a translate table to apply to all characters before comparing them, or zero for no translation. The translation is applied to a pattern when it is compiled and to a string when it is matched. */ char *translate; /* Number of subexpressions found by the compiler. */ size_t re_nsub; /* Zero if this pattern cannot match the empty string, one else. Well, in truth it's used only in `re_search_2', to see whether or not we should use the fastmap, so we don't set this absolutely perfectly; see `re_compile_fastmap' (the `duplicate' case). */ unsigned can_be_null : 1; /* If REGS_UNALLOCATED, allocate space in the `regs' structure for `max (RE_NREGS, re_nsub + 1)' groups. If REGS_REALLOCATE, reallocate space if necessary. If REGS_FIXED, use what's there. */ #define REGS_UNALLOCATED 0 #define REGS_REALLOCATE 1 #define REGS_FIXED 2 unsigned regs_allocated : 2; /* Set to zero when `regex_compile' compiles a pattern; set to one by `re_compile_fastmap' if it updates the fastmap. */ unsigned fastmap_accurate : 1; /* If set, `re_match_2' does not return information about subexpressions. */ unsigned no_sub : 1; /* If set, a beginning-of-line anchor doesn't match at the beginning of the string. */ unsigned not_bol : 1; /* Similarly for an end-of-line anchor. */ unsigned not_eol : 1; /* If true, an anchor at a newline matches. */ unsigned newline_anchor : 1; /* [[[end pattern_buffer]]] */ }; typedef struct re_pattern_buffer regex_t; /* search.c (search_buffer) in Emacs needs this one opcode value. It is defined both in `regex.c' and here. */ #define RE_EXACTN_VALUE 1 /* Type for byte offsets within the string. POSIX mandates this. */ typedef int regoff_t; /* This is the structure we store register match data in. See regex.texinfo for a full description of what registers match. */ struct re_registers { unsigned num_regs; regoff_t *start; regoff_t *end; }; /* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer, `re_match_2' returns information about at least this many registers the first time a `regs' structure is passed. */ #ifndef RE_NREGS #define RE_NREGS 30 #endif /* POSIX specification for registers. Aside from the different names than `re_registers', POSIX uses an array of structures, instead of a structure of arrays. */ typedef struct { regoff_t rm_so; /* Byte offset from string's start to substring's start. */ regoff_t rm_eo; /* Byte offset from string's start to substring's end. */ } regmatch_t; /* Declarations for routines. */ /* To avoid duplicating every routine declaration -- once with a prototype (if we are ANSI), and once without (if we aren't) -- we use the following macro to declare argument types. This unfortunately clutters up the declarations a bit, but I think it's worth it. */ #if __STDC__ #define _RE_ARGS(args) args #else /* not __STDC__ */ #define _RE_ARGS(args) () #endif /* not __STDC__ */ /* Sets the current default syntax to SYNTAX, and return the old syntax. You can also simply assign to the `re_syntax_options' variable. */ extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax)); /* Compile the regular expression PATTERN, with length LENGTH and syntax given by the global `re_syntax_options', into the buffer BUFFER. Return NULL if successful, and an error string if not. */ extern const char *re_compile_pattern _RE_ARGS ((const char *pattern, int length, struct re_pattern_buffer *buffer)); /* Compile a fastmap for the compiled pattern in BUFFER; used to accelerate searches. Return 0 if successful and -2 if was an internal error. */ extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer)); /* Search in the string STRING (with length LENGTH) for the pattern compiled into BUFFER. Start searching at position START, for RANGE characters. Return the starting position of the match, -1 for no match, or -2 for an internal error. Also return register information in REGS (if REGS and BUFFER->no_sub are nonzero). */ extern int re_search _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, int length, int start, int range, struct re_registers *regs)); /* Like `re_search', but search in the concatenation of STRING1 and STRING2. Also, stop searching at index START + STOP. */ extern int re_search_2 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, int length1, const char *string2, int length2, int start, int range, struct re_registers *regs, int stop)); /* Like `re_search', but return how many characters in STRING the regexp in BUFFER matched, starting at position START. */ extern int re_match _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, int length, int start, struct re_registers *regs)); /* Relates to `re_match' as `re_search_2' relates to `re_search'. */ extern int re_match_2 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, int length1, const char *string2, int length2, int start, struct re_registers *regs, int stop)); /* Set REGS to hold NUM_REGS registers, storing them in STARTS and ENDS. Subsequent matches using BUFFER and REGS will use this memory for recording register information. STARTS and ENDS must be allocated with malloc, and must each be at least `NUM_REGS * sizeof (regoff_t)' bytes long. If NUM_REGS == 0, then subsequent matches should allocate their own register data. Unless this function is called, the first search or match using PATTERN_BUFFER will allocate its own register data, without freeing the old data. */ extern void re_set_registers _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs, unsigned num_regs, regoff_t *starts, regoff_t *ends)); /* 4.2 bsd compatibility. */ extern char *re_comp _RE_ARGS ((const char *)); extern int re_exec _RE_ARGS ((const char *)); /* POSIX compatibility. */ extern int regcomp _RE_ARGS ((regex_t *preg, const char *pattern, int cflags)); extern int regexec _RE_ARGS ((const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags)); extern size_t regerror _RE_ARGS ((int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)); extern void regfree _RE_ARGS ((regex_t *preg)); #endif /* not __REGEXP_LIBRARY_H__ */ /* Local variables: make-backup-files: t version-control: t trim-versions-without-asking: nil End: */ diffutils-2.4/side.c100444 74720 14 15546 5437442262 13367 0ustar eggertguest/* sdiff-format output routines for GNU DIFF. Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. No author or distributor accepts responsibility to anyone for the consequences of using it or for whether it serves any particular purpose or works at all, unless he says so in writing. Refer to the GNU DIFF General Public License for full details. Everyone is granted permission to copy, modify and redistribute GNU DIFF, but only under the conditions described in the GNU DIFF General Public License. A copy of this license is supposed to have been given to you along with GNU DIFF so you can know your rights and responsibilities. It should be in a file named COPYING. Among other things, the copyright notice and this notice must be preserved on all copies. */ #include "diff.h" static unsigned print_half_line PARAMS((char const * const *, unsigned, unsigned)); static unsigned tab_from_to PARAMS((unsigned, unsigned)); static void print_1sdiff_line PARAMS((char const * const *, int, char const * const *)); static void print_sdiff_common_lines PARAMS((int, int)); static void print_sdiff_hunk PARAMS((struct change *)); /* Next line number to be printed in the two input files. */ static int next0, next1; /* Print the edit-script SCRIPT as a sdiff style output. */ void print_sdiff_script (script) struct change *script; { begin_output (); next0 = next1 = - files[0].prefix_lines; print_script (script, find_change, print_sdiff_hunk); print_sdiff_common_lines (files[0].valid_lines, files[1].valid_lines); } /* Tab from column FROM to column TO, where FROM <= TO. Yield TO. */ static unsigned tab_from_to (from, to) unsigned from, to; { FILE *out = outfile; unsigned tab; if (! tab_expand_flag) for (tab = from + TAB_WIDTH - from % TAB_WIDTH; tab <= to; tab += TAB_WIDTH) { putc ('\t', out); from = tab; } while (from++ < to) putc (' ', out); return to; } /* * Print the text for half an sdiff line. This means truncate to width * observing tabs, and trim a trailing newline. Returns the last column * written (not the number of chars). */ static unsigned print_half_line (line, indent, out_bound) char const * const *line; unsigned indent, out_bound; { FILE *out = outfile; register unsigned in_position = 0, out_position = 0; register char const *text_pointer = line[0], *text_limit = line[1]; while (text_pointer < text_limit) { register unsigned char c = *text_pointer++; switch (c) { case '\t': { unsigned spaces = TAB_WIDTH - in_position % TAB_WIDTH; if (in_position == out_position) { unsigned tabstop = out_position + spaces; if (tab_expand_flag) { if (out_bound < tabstop) tabstop = out_bound; for (; out_position < tabstop; out_position++) putc (' ', out); } else if (tabstop < out_bound) { out_position = tabstop; putc (c, out); } } in_position += spaces; } break; case '\r': { putc (c, out); tab_from_to (0, indent); in_position = out_position = 0; } break; case '\b': if (in_position != 0 && --in_position < out_bound) if (out_position <= in_position) /* Add spaces to make up for suppressed tab past out_bound. */ for (; out_position < in_position; out_position++) putc (' ', out); else { out_position = in_position; putc (c, out); } break; case '\f': case '\v': control_char: if (in_position < out_bound) putc (c, out); break; default: if (! isgraph (c)) goto control_char; /* falls through */ case ' ': if (in_position++ < out_bound) { out_position = in_position; putc (c, out); } break; case '\n': return out_position; } } return out_position; } /* * Print side by side lines with a separator in the middle. * 0 parameters are taken to indicate white space text. * Blank lines that can easily be caught are reduced to a single newline. */ static void print_1sdiff_line (left, sep, right) char const * const *left; int sep; char const * const *right; { FILE *out = outfile; unsigned hw = sdiff_half_width, c2o = sdiff_column2_offset; unsigned col = 0; int put_newline = 0; if (left) { if (left[1][-1] == '\n') put_newline = 1; col = print_half_line (left, 0, hw); } if (sep != ' ') { col = tab_from_to (col, (hw + c2o - 1) / 2) + 1; if (sep == '|' && put_newline != (right[1][-1] == '\n')) sep = put_newline ? '/' : '\\'; putc (sep, out); } if (right) { if (right[1][-1] == '\n') put_newline = 1; if (**right != '\n') { col = tab_from_to (col, c2o); print_half_line (right, col, hw); } } if (put_newline) putc ('\n', out); } /* Print lines common to both files in side-by-side format. */ static void print_sdiff_common_lines (limit0, limit1) int limit0, limit1; { int i0 = next0, i1 = next1; if (! sdiff_skip_common_lines && (i0 != limit0 || i1 != limit1)) { if (sdiff_help_sdiff) fprintf (outfile, "i%d,%d\n", limit0 - i0, limit1 - i1); if (! sdiff_left_only) { while (i0 != limit0 && i1 != limit1) print_1sdiff_line (&files[0].linbuf[i0++], ' ', &files[1].linbuf[i1++]); while (i1 != limit1) print_1sdiff_line (0, ')', &files[1].linbuf[i1++]); } while (i0 != limit0) print_1sdiff_line (&files[0].linbuf[i0++], '(', 0); } next0 = limit0; next1 = limit1; } /* Print a hunk of an sdiff diff. This is a contiguous portion of a complete edit script, describing changes in consecutive lines. */ static void print_sdiff_hunk (hunk) struct change *hunk; { int first0, last0, first1, last1, deletes, inserts; register int i, j; /* Determine range of line numbers involved in each file. */ analyze_hunk (hunk, &first0, &last0, &first1, &last1, &deletes, &inserts); if (!deletes && !inserts) return; /* Print out lines up to this change. */ print_sdiff_common_lines (first0, first1); if (sdiff_help_sdiff) fprintf (outfile, "c%d,%d\n", last0 - first0 + 1, last1 - first1 + 1); /* Print ``xxx | xxx '' lines */ if (inserts && deletes) { for (i = first0, j = first1; i <= last0 && j <= last1; ++i, ++j) print_1sdiff_line (&files[0].linbuf[i], '|', &files[1].linbuf[j]); deletes = i <= last0; inserts = j <= last1; next0 = first0 = i; next1 = first1 = j; } /* Print `` > xxx '' lines */ if (inserts) { for (j = first1; j <= last1; ++j) print_1sdiff_line (0, '>', &files[1].linbuf[j]); next1 = j; } /* Print ``xxx < '' lines */ if (deletes) { for (i = first0; i <= last0; ++i) print_1sdiff_line (&files[0].linbuf[i], '<', 0); next0 = i; } } diffutils-2.4/system.h100444 74720 14 7114 5445445753 13753 0ustar eggertguest/* System dependent declarations. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #if __STDC__ #define PARAMS(args) args #define VOID void #else #define PARAMS(args) () #define VOID char #endif #ifndef S_ISDIR #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) #endif #ifndef S_ISREG #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) #endif #ifndef S_IXOTH #define S_IXOTH 1 #endif #ifndef S_IXGRP #define S_IXGRP (S_IXOTH << 3) #endif #ifndef S_IXUSR #define S_IXUSR (S_IXGRP << 3) #endif #if HAVE_UNISTD_H #include #endif #ifndef SEEK_SET #define SEEK_SET 0 #endif #ifndef SEEK_CUR #define SEEK_CUR 1 #endif #ifndef STDIN_FILENO #define STDIN_FILENO 0 #endif #ifndef STDOUT_FILENO #define STDOUT_FILENO 1 #endif #ifndef STDERR_FILENO #define STDERR_FILENO 2 #endif #if HAVE_TIME_H #include #else #include #endif #if HAVE_FCNTL_H #include #else #include #endif #if !HAVE_DUP2 #define dup2(f,t) (close (t), fcntl (f,F_DUPFD,t)) #endif #ifndef O_RDONLY #define O_RDONLY 0 #endif #if HAVE_SYS_WAIT_H #ifndef _POSIX_VERSION /* Prevent the NeXT prototype using union wait from causing problems. */ #define wait system_wait #endif #include #ifndef _POSIX_VERSION #undef wait #endif #endif /* HAVE_SYS_WAIT_H */ #ifndef WEXITSTATUS #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8) #undef WIFEXITED /* Avoid 4.3BSD incompatibility with Posix. */ #endif #ifndef WIFEXITED #define WIFEXITED(stat_val) (((stat_val) & 255) == 0) #endif #if HAVE_ST_BLKSIZE #define STAT_BLOCKSIZE(s) (s).st_blksize #else #define STAT_BLOCKSIZE(s) (8 * 1024) #endif #if DIRENT || defined (_POSIX_VERSION) #include #else /* ! (DIRENT || defined (_POSIX_VERSION)) */ #if SYSNDIR #include #else #if SYSDIR #include #else #include #endif #endif #ifdef dirent #undef dirent #endif #define dirent direct #endif /* ! (DIRENT || defined (_POSIX_VERSION)) */ #if HAVE_VFORK_H #include #endif #if HAVE_STDLIB_H #include #else char *getenv (); VOID *malloc (); VOID *realloc (); #endif #if HAVE_LIMITS_H #include #endif #ifndef INT_MAX #define INT_MAX 2147483647 #endif #ifndef CHAR_BIT #define CHAR_BIT 8 #endif #if HAVE_STRING_H #include #ifndef bzero #define bzero(s,n) memset (s,0,n) #endif #else /* !HAVE_STRING_H */ #include #ifndef strchr #define strchr index #endif #ifndef strrchr #define strrchr rindex #endif #ifndef memcpy #define memcpy(d,s,n) bcopy (s,d,n) #endif #ifndef memcmp #define memcmp(s1,s2,n) bcmp (s1,s2,n) #endif #endif /* !HAVE_STRING_H */ #if !HAVE_MEMCHR char *memchr (); #endif #include #if !STDC_HEADERS extern int errno; #endif #if !__STDC__ #ifndef volatile #define volatile #endif #endif #define min(a,b) ((a) <= (b) ? (a) : (b)) #define max(a,b) ((a) >= (b) ? (a) : (b)) diffutils-2.4/diff3.c100444 74720 14 134714 5444407526 13457 0ustar eggertguest/* Three way file comparison program (diff3) for Project GNU. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by Randy Smith */ #include #include #include "getopt.h" #include "system.h" extern char const version_string[]; /* * Internal data structures and macros for the diff3 program; includes * data structures for both diff3 diffs and normal diffs. */ /* Different files within a three way diff. */ #define FILE0 0 #define FILE1 1 #define FILE2 2 /* * A three way diff is built from two two-way diffs; the file which * the two two-way diffs share is: */ #define FILEC FILE2 /* * Different files within a two way diff. * FC is the common file, FO the other file. */ #define FO 0 #define FC 1 /* The ranges are indexed by */ #define START 0 #define END 1 enum diff_type { ERROR, /* Should not be used */ ADD, /* Two way diff add */ CHANGE, /* Two way diff change */ DELETE, /* Two way diff delete */ DIFF_ALL, /* All three are different */ DIFF_1ST, /* Only the first is different */ DIFF_2ND, /* Only the second */ DIFF_3RD /* Only the third */ }; /* Two way diff */ struct diff_block { int ranges[2][2]; /* Ranges are inclusive */ char **lines[2]; /* The actual lines (may contain nulls) */ size_t *lengths[2]; /* Line lengths (including newlines, if any) */ struct diff_block *next; }; /* Three way diff */ struct diff3_block { enum diff_type correspond; /* Type of diff */ int ranges[3][2]; /* Ranges are inclusive */ char **lines[3]; /* The actual lines (may contain nulls) */ size_t *lengths[3]; /* Line lengths (including newlines, if any) */ struct diff3_block *next; }; /* * Access the ranges on a diff block. */ #define D_LOWLINE(diff, filenum) \ ((diff)->ranges[filenum][START]) #define D_HIGHLINE(diff, filenum) \ ((diff)->ranges[filenum][END]) #define D_NUMLINES(diff, filenum) \ (D_HIGHLINE (diff, filenum) - D_LOWLINE (diff, filenum) + 1) /* * Access the line numbers in a file in a diff by relative line * numbers (i.e. line number within the diff itself). Note that these * are lvalues and can be used for assignment. */ #define D_RELNUM(diff, filenum, linenum) \ ((diff)->lines[filenum][linenum]) #define D_RELLEN(diff, filenum, linenum) \ ((diff)->lengths[filenum][linenum]) /* * And get at them directly, when that should be necessary. */ #define D_LINEARRAY(diff, filenum) \ ((diff)->lines[filenum]) #define D_LENARRAY(diff, filenum) \ ((diff)->lengths[filenum]) /* * Next block. */ #define D_NEXT(diff) ((diff)->next) /* * Access the type of a diff3 block. */ #define D3_TYPE(diff) ((diff)->correspond) /* * Line mappings based on diffs. The first maps off the top of the * diff, the second off of the bottom. */ #define D_HIGH_MAPLINE(diff, fromfile, tofile, lineno) \ ((lineno) \ - D_HIGHLINE ((diff), (fromfile)) \ + D_HIGHLINE ((diff), (tofile))) #define D_LOW_MAPLINE(diff, fromfile, tofile, lineno) \ ((lineno) \ - D_LOWLINE ((diff), (fromfile)) \ + D_LOWLINE ((diff), (tofile))) /* * General memory allocation function. */ #define ALLOCATE(number, type) \ (type *) xmalloc ((number) * sizeof (type)) /* Options variables for flags set on command line. */ /* If nonzero, treat all files as text files, never as binary. */ static int always_text; /* If nonzero, write out an ed script instead of the standard diff3 format. */ static int edscript; /* If nonzero, in the case of overlapping diffs (type DIFF_ALL), preserve the lines which would normally be deleted from file 1 with a special flagging mechanism. */ static int flagging; /* Number of lines to keep in identical prefix and suffix. */ static int horizon_lines = 10; /* Use a tab to align output lines (-T). */ static int tab_align_flag; /* If nonzero, do not output information for overlapping diffs. */ static int simple_only; /* If nonzero, do not output information for non-overlapping diffs. */ static int overlap_only; /* If nonzero, show information for DIFF_2ND diffs. */ static int show_2nd; /* If nonzero, include `:wq' at the end of the script to write out the file being edited. */ static int finalwrite; /* If nonzero, output a merged file. */ static int merge; static char *argv0; VOID *xmalloc PARAMS((size_t)); static VOID *xrealloc PARAMS((VOID *, size_t)); static char *read_diff PARAMS((char const *, char const *, char **)); static char *scan_diff_line PARAMS((char *, char **, size_t *, char *, int)); static enum diff_type process_diff_control PARAMS((char **, struct diff_block *)); static int compare_line_list PARAMS((char * const[], size_t const[], char * const[], size_t const[], int)); static int copy_stringlist PARAMS((char * const[], size_t const[], char *[], size_t[], int)); static int dotlines PARAMS((FILE *, struct diff3_block *, int)); static int output_diff3_edscript PARAMS((FILE *, struct diff3_block *, int const[3], int const[3], char const *, char const *, char const *)); static int output_diff3_merge PARAMS((FILE *, FILE *, struct diff3_block *, int const[3], int const[3], char const *, char const *, char const *)); static size_t myread PARAMS((int, char *, size_t)); static struct diff3_block *create_diff3_block PARAMS((int, int, int, int, int, int)); static struct diff3_block *make_3way_diff PARAMS((struct diff_block *, struct diff_block *)); static struct diff3_block *reverse_diff3_blocklist PARAMS((struct diff3_block *)); static struct diff3_block *using_to_diff3_block PARAMS((struct diff_block *[2], struct diff_block *[2], int, int, struct diff3_block const *)); static struct diff_block *process_diff PARAMS((char const *, char const *, struct diff_block **)); static void fatal PARAMS((char const *)); static void output_diff3 PARAMS((FILE *, struct diff3_block *, int const[3], int const[3])); static void perror_with_exit PARAMS((char const *)); static void undotlines PARAMS((FILE *, int, int, int)); static void usage PARAMS((void)); static char const diff_program[] = DIFF_PROGRAM; static struct option const longopts[] = { {"text", 0, 0, 'a'}, {"show-all", 0, 0, 'A'}, {"ed", 0, 0, 'e'}, {"show-overlap", 0, 0, 'E'}, {"label", 1, 0, 'L'}, {"merge", 0, 0, 'm'}, {"initial-tab", 0, 0, 'T'}, {"overlap-only", 0, 0, 'x'}, {"easy-only", 0, 0, '3'}, {"version", 0, 0, 'v'}, {0, 0, 0, 0} }; /* * Main program. Calls diff twice on two pairs of input files, * combines the two diffs, and outputs them. */ int main (argc, argv) int argc; char **argv; { int c, i; int mapping[3]; int rev_mapping[3]; int incompat; int conflicts_found; struct diff_block *thread0, *thread1, *last_block; struct diff3_block *diff3; int tag_count = 0; char *tag_strings[3]; char *commonname; char **file; struct stat statb; incompat = 0; argv0 = argv[0]; while ((c = getopt_long (argc, argv, "aeimvx3AEL:TX", longopts, 0)) != EOF) { switch (c) { case 'a': always_text = 1; break; case 'A': show_2nd = 1; flagging = 1; incompat++; break; case 'x': overlap_only = 1; incompat++; break; case '3': simple_only = 1; incompat++; break; case 'i': finalwrite = 1; break; case 'm': merge = 1; break; case 'X': overlap_only = 1; /* Falls through */ case 'E': flagging = 1; /* Falls through */ case 'e': incompat++; break; case 'T': tab_align_flag = 1; break; case 'v': fprintf (stderr, "GNU diff3 version %s\n", version_string); break; case 'L': /* Handle up to three -L options. */ if (tag_count < 3) { tag_strings[tag_count++] = optarg; break; } /* Falls through */ default: usage (); /* NOTREACHED */ } } edscript = incompat & ~merge; /* -AeExX3 without -m implies ed script. */ show_2nd |= ~incompat & merge; /* -m without -AeExX3 implies -A. */ flagging |= ~incompat & merge; if (incompat > 1 /* Ensure at most one of -AeExX3. */ || finalwrite & merge /* -i -m would rewrite input file. */ || (tag_count && ! flagging) /* -L requires one of -AEX. */ || argc - optind != 3) usage (); file = &argv[optind]; for (i = tag_count; i < 3; i++) tag_strings[i] = file[i]; /* Always compare file1 to file2, even if file2 is "-". This is needed for -mAeExX3. Using the file0 as the common file would produce wrong results, because if the file0-file1 diffs didn't line up with the file0-file2 diffs (which is entirely possible since we don't use diff's -n option), diff3 might report phantom changes from file1 to file2. */ if (strcmp (file[2], "-") == 0) { /* Sigh. We've got standard input as the last arg. We can't call diff twice on stdin. Use the middle arg as the common file instead. */ if (strcmp (file[0], "-") == 0 || strcmp (file[1], "-") == 0) fatal ("`-' specified for more than one input file"); mapping[0] = 0; mapping[1] = 2; mapping[2] = 1; } else { /* Normal, what you'd expect */ mapping[0] = 0; mapping[1] = 1; mapping[2] = 2; } for (i = 0; i < 3; i++) rev_mapping[mapping[i]] = i; for (i = 0; i < 3; i++) if (strcmp (file[i], "-") != 0) { if (stat (file[i], &statb) < 0) perror_with_exit (file[i]); else if (S_ISDIR(statb.st_mode)) { fprintf (stderr, "%s: %s: Is a directory\n", argv0, file[i]); exit (2); } } commonname = file[rev_mapping[FILEC]]; thread1 = process_diff (file[rev_mapping[FILE1]], commonname, &last_block); if (thread1) for (i = 0; i < 2; i++) { horizon_lines = max (horizon_lines, D_NUMLINES (thread1, i)); horizon_lines = max (horizon_lines, D_NUMLINES (last_block, i)); } thread0 = process_diff (file[rev_mapping[FILE0]], commonname, &last_block); diff3 = make_3way_diff (thread0, thread1); if (edscript) conflicts_found = output_diff3_edscript (stdout, diff3, mapping, rev_mapping, tag_strings[0], tag_strings[1], tag_strings[2]); else if (merge) { if (! freopen (file[rev_mapping[FILE0]], "r", stdin)) perror_with_exit (file[rev_mapping[FILE0]]); conflicts_found = output_diff3_merge (stdin, stdout, diff3, mapping, rev_mapping, tag_strings[0], tag_strings[1], tag_strings[2]); if (ferror (stdin)) fatal ("read error"); } else { output_diff3 (stdout, diff3, mapping, rev_mapping); conflicts_found = 0; } if (ferror (stdout) || fclose (stdout) != 0) fatal ("write error"); exit (conflicts_found); return conflicts_found; } /* * Explain, patiently and kindly, how to use this program. Then exit. */ static void usage () { fprintf (stderr, "\ Usage: %s [options] my-file older-file your-file\n\ Options:\n\ [-exAEX3aTv] [-i|-m] [-L label1 [-L label2 [-L label3]]]\n\ [--easy-only] [--ed] [--initial-tab]\n\ [--label=label1 [--label=label2 [--label=label3]]] [--merge]\n\ [--overlap-only] [--show-all] [--show-overlap] [--text] [--version]\n\ Only one of [exAEX3] is allowed\n", argv0); exit (2); } /* * Routines that combine the two diffs together into one. The * algorithm used follows: * * File2 is shared in common between the two diffs. * Diff02 is the diff between 0 and 2. * Diff12 is the diff between 1 and 2. * * 1) Find the range for the first block in File2. * a) Take the lowest of the two ranges (in File2) in the two * current blocks (one from each diff) as being the low * water mark. Assign the upper end of this block as * being the high water mark and move the current block up * one. Mark the block just moved over as to be used. * b) Check the next block in the diff that the high water * mark is *not* from. * * *If* the high water mark is above * the low end of the range in that block, * * mark that block as to be used and move the current * block up. Set the high water mark to the max of * the high end of this block and the current. Repeat b. * * 2) Find the corresponding ranges in File0 (from the blocks * in diff02; line per line outside of diffs) and in File1. * Create a diff3_block, reserving space as indicated by the ranges. * * 3) Copy all of the pointers for file2 in. At least for now, * do memcmp's between corresponding strings in the two diffs. * * 4) Copy all of the pointers for file0 and 1 in. Get what you * need from file2 (when there isn't a diff block, it's * identical to file2 within the range between diff blocks). * * 5) If the diff blocks you used came from only one of the two * strings of diffs, then that file (i.e. the one other than * the common file in that diff) is the odd person out. If you used * diff blocks from both sets, check to see if files 0 and 1 match: * * Same number of lines? If so, do a set of memcmp's (if a * memcmp matches; copy the pointer over; it'll be easier later * if you have to do any compares). If they match, 0 & 1 are * the same. If not, all three different. * * Then you do it again, until you run out of blocks. * */ /* * This routine makes a three way diff (chain of diff3_block's) from two * two way diffs (chains of diff_block's). It is assumed that each of * the two diffs passed are onto the same file (i.e. that each of the * diffs were made "to" the same file). The three way diff pointer * returned will have numbering FILE0--the other file in diff02, * FILE1--the other file in diff12, and FILEC--the common file. */ static struct diff3_block * make_3way_diff (thread0, thread1) struct diff_block *thread0, *thread1; { /* * This routine works on the two diffs passed to it as threads. * Thread number 0 is diff02, thread number 1 is diff12. The USING * array is set to the base of the list of blocks to be used to * construct each block of the three way diff; if no blocks from a * particular thread are to be used, that element of the using array * is set to 0. The elements LAST_USING array are set to the last * elements on each of the using lists. * * The HIGH_WATER_MARK is set to the highest line number in the common file * described in any of the diffs in either of the USING lists. The * HIGH_WATER_THREAD names the thread. Similarly the BASE_WATER_MARK * and BASE_WATER_THREAD describe the lowest line number in the common file * described in any of the diffs in either of the USING lists. The * HIGH_WATER_DIFF is the diff from which the HIGH_WATER_MARK was * taken. * * The HIGH_WATER_DIFF should always be equal to LAST_USING * [HIGH_WATER_THREAD]. The OTHER_DIFF is the next diff to check for * higher water, and should always be equal to * CURRENT[HIGH_WATER_THREAD ^ 0x1]. The OTHER_THREAD is the thread * in which the OTHER_DIFF is, and hence should always be equal to * HIGH_WATER_THREAD ^ 0x1. * * The variable LAST_DIFF is kept set to the last diff block produced * by this routine, for line correspondence purposes between that diff * and the one currently being worked on. It is initialized to * ZERO_DIFF before any blocks have been created. */ struct diff_block *using[2], *last_using[2], *current[2]; int high_water_mark; int high_water_thread, base_water_thread, other_thread; struct diff_block *high_water_diff, *other_diff; struct diff3_block *result, *tmpblock, **result_end; struct diff3_block const *last_diff3; static struct diff3_block const zero_diff3; /* Initialization */ result = 0; result_end = &result; current[0] = thread0; current[1] = thread1; last_diff3 = &zero_diff3; /* Sniff up the threads until we reach the end */ while (current[0] || current[1]) { using[0] = using[1] = last_using[0] = last_using[1] = 0; /* Setup low and high water threads, diffs, and marks. */ if (!current[0]) base_water_thread = 1; else if (!current[1]) base_water_thread = 0; else base_water_thread = (D_LOWLINE (current[0], FC) > D_LOWLINE (current[1], FC)); high_water_thread = base_water_thread; high_water_diff = current[high_water_thread]; #if 0 /* low and high waters start off same diff */ base_water_mark = D_LOWLINE (high_water_diff, FC); #endif high_water_mark = D_HIGHLINE (high_water_diff, FC); /* Make the diff you just got info from into the using class */ using[high_water_thread] = last_using[high_water_thread] = high_water_diff; current[high_water_thread] = high_water_diff->next; last_using[high_water_thread]->next = 0; /* And mark the other diff */ other_thread = high_water_thread ^ 0x1; other_diff = current[other_thread]; /* Shuffle up the ladder, checking the other diff to see if it needs to be incorporated. */ while (other_diff && D_LOWLINE (other_diff, FC) <= high_water_mark + 1) { /* Incorporate this diff into the using list. Note that this doesn't take it off the current list */ if (using[other_thread]) last_using[other_thread]->next = other_diff; else using[other_thread] = other_diff; last_using[other_thread] = other_diff; /* Take it off the current list. Note that this following code assumes that other_diff enters it equal to current[high_water_thread ^ 0x1] */ current[other_thread] = current[other_thread]->next; other_diff->next = 0; /* Set the high_water stuff If this comparison is equal, then this is the last pass through this loop; since diff blocks within a given thread cannot overlap, the high_water_mark will be *below* the range_start of either of the next diffs. */ if (high_water_mark < D_HIGHLINE (other_diff, FC)) { high_water_thread ^= 1; high_water_diff = other_diff; high_water_mark = D_HIGHLINE (other_diff, FC); } /* Set the other diff */ other_thread = high_water_thread ^ 0x1; other_diff = current[other_thread]; } /* The using lists contain a list of all of the blocks to be included in this diff3_block. Create it. */ tmpblock = using_to_diff3_block (using, last_using, base_water_thread, high_water_thread, last_diff3); if (!tmpblock) fatal ("internal error: screwup in format of diff blocks"); /* Put it on the list. */ *result_end = tmpblock; result_end = &tmpblock->next; /* Set up corresponding lines correctly. */ last_diff3 = tmpblock; } return result; } /* * using_to_diff3_block: * This routine takes two lists of blocks (from two separate diff * threads) and puts them together into one diff3 block. * It then returns a pointer to this diff3 block or 0 for failure. * * All arguments besides using are for the convenience of the routine; * they could be derived from the using array. * LAST_USING is a pair of pointers to the last blocks in the using * structure. * LOW_THREAD and HIGH_THREAD tell which threads contain the lowest * and highest line numbers for File0. * last_diff3 contains the last diff produced in the calling routine. * This is used for lines mappings which would still be identical to * the state that diff ended in. * * A distinction should be made in this routine between the two diffs * that are part of a normal two diff block, and the three diffs that * are part of a diff3_block. */ static struct diff3_block * using_to_diff3_block (using, last_using, low_thread, high_thread, last_diff3) struct diff_block *using[2], *last_using[2]; int low_thread, high_thread; struct diff3_block const *last_diff3; { int low[2], high[2]; struct diff3_block *result; struct diff_block *ptr; int d, i; /* Find the range in the common file. */ int lowc = D_LOWLINE (using[low_thread], FC); int highc = D_HIGHLINE (last_using[high_thread], FC); /* Find the ranges in the other files. If using[d] is null, that means that the file to which that diff refers is equivalent to the common file over this range. */ for (d = 0; d < 2; d++) if (using[d]) { low[d] = D_LOW_MAPLINE (using[d], FC, FO, lowc); high[d] = D_HIGH_MAPLINE (last_using[d], FC, FO, highc); } else { low[d] = D_HIGH_MAPLINE (last_diff3, FILEC, FILE0 + d, lowc); high[d] = D_HIGH_MAPLINE (last_diff3, FILEC, FILE0 + d, highc); } /* Create a block with the appropriate sizes */ result = create_diff3_block (low[0], high[0], low[1], high[1], lowc, highc); /* Copy information for the common file. Return with a zero if any of the compares failed. */ for (d = 0; d < 2; d++) for (ptr = using[d]; ptr; ptr = D_NEXT (ptr)) { int result_offset = D_LOWLINE (ptr, FC) - lowc; if (!copy_stringlist (D_LINEARRAY (ptr, FC), D_LENARRAY (ptr, FC), D_LINEARRAY (result, FILEC) + result_offset, D_LENARRAY (result, FILEC) + result_offset, D_NUMLINES (ptr, FC))) return 0; } /* Copy information for file d. First deal with anything that might be before the first diff. */ for (d = 0; d < 2; d++) { struct diff_block *u = using[d]; int lo = low[d], hi = high[d]; for (i = 0; i + lo < (u ? D_LOWLINE (u, FO) : hi + 1); i++) { D_RELNUM (result, FILE0 + d, i) = D_RELNUM (result, FILEC, i); D_RELLEN (result, FILE0 + d, i) = D_RELLEN (result, FILEC, i); } for (ptr = u; ptr; ptr = D_NEXT (ptr)) { int result_offset = D_LOWLINE (ptr, FO) - lo; int linec; if (!copy_stringlist (D_LINEARRAY (ptr, FO), D_LENARRAY (ptr, FO), D_LINEARRAY (result, FILE0 + d) + result_offset, D_LENARRAY (result, FILE0 + d) + result_offset, D_NUMLINES (ptr, FO))) return 0; /* Catch the lines between here and the next diff */ linec = D_HIGHLINE (ptr, FC) + 1 - lowc; for (i = D_HIGHLINE (ptr, FO) + 1 - lo; i < (D_NEXT (ptr) ? D_LOWLINE (D_NEXT (ptr), FO) : hi + 1) - lo; i++) { D_RELNUM (result, FILE0 + d, i) = D_RELNUM (result, FILEC, linec); D_RELLEN (result, FILE0 + d, i) = D_RELLEN (result, FILEC, linec); linec++; } } } /* Set correspond */ if (!using[0]) D3_TYPE (result) = DIFF_2ND; else if (!using[1]) D3_TYPE (result) = DIFF_1ST; else { int nl0 = D_NUMLINES (result, FILE0); int nl1 = D_NUMLINES (result, FILE1); if (nl0 != nl1 || !compare_line_list (D_LINEARRAY (result, FILE0), D_LENARRAY (result, FILE0), D_LINEARRAY (result, FILE1), D_LENARRAY (result, FILE1), nl0)) D3_TYPE (result) = DIFF_ALL; else D3_TYPE (result) = DIFF_3RD; } return result; } /* * This routine copies pointers from a list of strings to a different list * of strings. If a spot in the second list is already filled, it * makes sure that it is filled with the same string; if not it * returns 0, the copy incomplete. * Upon successful completion of the copy, it returns 1. */ static int copy_stringlist (fromptrs, fromlengths, toptrs, tolengths, copynum) char * const fromptrs[]; char *toptrs[]; size_t const fromlengths[]; size_t tolengths[]; int copynum; { register char * const *f = fromptrs; register char **t = toptrs; register size_t const *fl = fromlengths; register size_t *tl = tolengths; while (copynum--) { if (*t) { if (*fl != *tl || memcmp (*f, *t, *fl)) return 0; } else { *t = *f ; *tl = *fl; } t++; f++; tl++; fl++; } return 1; } /* * Create a diff3_block, with ranges as specified in the arguments. * Allocate the arrays for the various pointers (and zero them) based * on the arguments passed. Return the block as a result. */ static struct diff3_block * create_diff3_block (low0, high0, low1, high1, low2, high2) register int low0, high0, low1, high1, low2, high2; { struct diff3_block *result = ALLOCATE (1, struct diff3_block); int numlines; D3_TYPE (result) = ERROR; D_NEXT (result) = 0; /* Assign ranges */ D_LOWLINE (result, FILE0) = low0; D_HIGHLINE (result, FILE0) = high0; D_LOWLINE (result, FILE1) = low1; D_HIGHLINE (result, FILE1) = high1; D_LOWLINE (result, FILE2) = low2; D_HIGHLINE (result, FILE2) = high2; /* Allocate and zero space */ numlines = D_NUMLINES (result, FILE0); if (numlines) { D_LINEARRAY (result, FILE0) = ALLOCATE (numlines, char *); D_LENARRAY (result, FILE0) = ALLOCATE (numlines, size_t); bzero (D_LINEARRAY (result, FILE0), (numlines * sizeof (char *))); bzero (D_LENARRAY (result, FILE0), (numlines * sizeof (size_t))); } else { D_LINEARRAY (result, FILE0) = 0; D_LENARRAY (result, FILE0) = 0; } numlines = D_NUMLINES (result, FILE1); if (numlines) { D_LINEARRAY (result, FILE1) = ALLOCATE (numlines, char *); D_LENARRAY (result, FILE1) = ALLOCATE (numlines, size_t); bzero (D_LINEARRAY (result, FILE1), (numlines * sizeof (char *))); bzero (D_LENARRAY (result, FILE1), (numlines * sizeof (size_t))); } else { D_LINEARRAY (result, FILE1) = 0; D_LENARRAY (result, FILE1) = 0; } numlines = D_NUMLINES (result, FILE2); if (numlines) { D_LINEARRAY (result, FILE2) = ALLOCATE (numlines, char *); D_LENARRAY (result, FILE2) = ALLOCATE (numlines, size_t); bzero (D_LINEARRAY (result, FILE2), (numlines * sizeof (char *))); bzero (D_LENARRAY (result, FILE2), (numlines * sizeof (size_t))); } else { D_LINEARRAY (result, FILE2) = 0; D_LENARRAY (result, FILE2) = 0; } /* Return */ return result; } /* * Compare two lists of lines of text. * Return 1 if they are equivalent, 0 if not. */ static int compare_line_list (list1, lengths1, list2, lengths2, nl) char * const list1[], * const list2[]; size_t const lengths1[], lengths2[]; int nl; { char * const *l1 = list1, * const *l2 = list2; size_t const *lgths1 = lengths1, *lgths2 = lengths2; while (nl--) if (!*l1 || !*l2 || *lgths1 != *lgths2++ || memcmp (*l1++, *l2++, *lgths1++)) return 0; return 1; } /* * Routines to input and parse two way diffs. */ extern char **environ; #define DIFF_CHUNK_SIZE 10000 static struct diff_block * process_diff (filea, fileb, last_block) char const *filea, *fileb; struct diff_block **last_block; { char *diff_contents; char *diff_limit; char *scan_diff; enum diff_type dt; int i; struct diff_block *block_list, **block_list_end, *bptr; diff_limit = read_diff (filea, fileb, &diff_contents); scan_diff = diff_contents; block_list_end = &block_list; bptr = 0; /* Pacify `gcc -W'. */ while (scan_diff < diff_limit) { bptr = ALLOCATE (1, struct diff_block); bptr->lines[0] = bptr->lines[1] = 0; bptr->lengths[0] = bptr->lengths[1] = 0; dt = process_diff_control (&scan_diff, bptr); if (dt == ERROR || *scan_diff != '\n') { fprintf (stderr, "%s: diff error: ", argv0); do { putc (*scan_diff, stderr); } while (*scan_diff++ != '\n'); exit (2); } scan_diff++; /* Force appropriate ranges to be null, if necessary */ switch (dt) { case ADD: bptr->ranges[0][0]++; break; case DELETE: bptr->ranges[1][0]++; break; case CHANGE: break; default: fatal ("internal error: invalid diff type in process_diff"); break; } /* Allocate space for the pointers for the lines from filea, and parcel them out among these pointers */ if (dt != ADD) { int numlines = D_NUMLINES (bptr, 0); bptr->lines[0] = ALLOCATE (numlines, char *); bptr->lengths[0] = ALLOCATE (numlines, size_t); for (i = 0; i < numlines; i++) scan_diff = scan_diff_line (scan_diff, &(bptr->lines[0][i]), &(bptr->lengths[0][i]), diff_limit, '<'); } /* Get past the separator for changes */ if (dt == CHANGE) { if (strncmp (scan_diff, "---\n", 4)) fatal ("invalid diff format; invalid change separator"); scan_diff += 4; } /* Allocate space for the pointers for the lines from fileb, and parcel them out among these pointers */ if (dt != DELETE) { int numlines = D_NUMLINES (bptr, 1); bptr->lines[1] = ALLOCATE (numlines, char *); bptr->lengths[1] = ALLOCATE (numlines, size_t); for (i = 0; i < numlines; i++) scan_diff = scan_diff_line (scan_diff, &(bptr->lines[1][i]), &(bptr->lengths[1][i]), diff_limit, '>'); } /* Place this block on the blocklist. */ *block_list_end = bptr; block_list_end = &bptr->next; } *block_list_end = 0; *last_block = bptr; return block_list; } /* * This routine will parse a normal format diff control string. It * returns the type of the diff (ERROR if the format is bad). All of * the other important information is filled into to the structure * pointed to by db, and the string pointer (whose location is passed * to this routine) is updated to point beyond the end of the string * parsed. Note that only the ranges in the diff_block will be set by * this routine. * * If some specific pair of numbers has been reduced to a single * number, then both corresponding numbers in the diff block are set * to that number. In general these numbers are interpetted as ranges * inclusive, unless being used by the ADD or DELETE commands. It is * assumed that these will be special cased in a superior routine. */ static enum diff_type process_diff_control (string, db) char **string; struct diff_block *db; { char *s = *string; int holdnum; enum diff_type type; /* These macros are defined here because they can use variables defined in this function. Don't try this at home kids, we're trained professionals! Also note that SKIPWHITE only recognizes tabs and spaces, and that READNUM can only read positive, integral numbers */ #define SKIPWHITE(s) { while (*s == ' ' || *s == '\t') s++; } #define READNUM(s, num) \ { if (!isdigit (*s)) return ERROR; holdnum = 0; \ do { holdnum = (*s++ - '0' + holdnum * 10); } \ while (isdigit (*s)); (num) = holdnum; } /* Read first set of digits */ SKIPWHITE (s); READNUM (s, db->ranges[0][START]); /* Was that the only digit? */ SKIPWHITE (s); if (*s == ',') { /* Get the next digit */ s++; READNUM (s, db->ranges[0][END]); } else db->ranges[0][END] = db->ranges[0][START]; /* Get the letter */ SKIPWHITE (s); switch (*s) { case 'a': type = ADD; break; case 'c': type = CHANGE; break; case 'd': type = DELETE; break; default: return ERROR; /* Bad format */ } s++; /* Past letter */ /* Read second set of digits */ SKIPWHITE (s); READNUM (s, db->ranges[1][START]); /* Was that the only digit? */ SKIPWHITE (s); if (*s == ',') { /* Get the next digit */ s++; READNUM (s, db->ranges[1][END]); SKIPWHITE (s); /* To move to end */ } else db->ranges[1][END] = db->ranges[1][START]; *string = s; return type; } static char * read_diff (filea, fileb, output_placement) char const *filea, *fileb; char **output_placement; { char const *argv[7]; char horizon_arg[256]; char const **ap; int fds[2]; char *diff_result; size_t bytes, current_chunk_size, total; pid_t pid; int wstatus; ap = argv; *ap++ = diff_program; if (always_text) *ap++ = "-a"; sprintf (horizon_arg, "--horizon-lines=%d", horizon_lines); *ap++ = horizon_arg; *ap++ = "--"; *ap++ = filea; *ap++ = fileb; *ap = 0; if (pipe (fds) < 0) perror_with_exit ("pipe failed"); pid = vfork (); if (pid == 0) { /* Child */ close (fds[0]); if (fds[1] != STDOUT_FILENO) { dup2 (fds[1], STDOUT_FILENO); close (fds[1]); } execve (diff_program, (char **) argv, environ); /* Avoid stdio, because the parent process's buffers are inherited. */ write (STDERR_FILENO, diff_program, strlen (diff_program)); write (STDERR_FILENO, ": not found\n", 12); _exit (2); } if (pid == -1) perror_with_exit ("fork failed"); close (fds[1]); /* Prevent erroneous lack of EOF */ current_chunk_size = DIFF_CHUNK_SIZE; diff_result = xmalloc (current_chunk_size); total = 0; do { bytes = myread (fds[0], diff_result + total, current_chunk_size - total); total += bytes; if (total == current_chunk_size) diff_result = xrealloc (diff_result, (current_chunk_size *= 2)); } while (bytes); if (total != 0 && diff_result[total-1] != '\n') fatal ("invalid diff format; incomplete last line"); *output_placement = diff_result; #if HAVE_WAITPID if (waitpid (pid, &wstatus, 0) < 0) perror_with_exit ("waitpid failed"); #else for (;;) { pid_t w = wait (&wstatus); if (w < 0) perror_with_exit ("wait failed"); if (w == pid) break; } #endif if (! (WIFEXITED (wstatus) && WEXITSTATUS (wstatus) < 2)) fatal ("subsidiary diff failed"); return diff_result + total; } /* * Scan a regular diff line (consisting of > or <, followed by a * space, followed by text (including nulls) up to a newline. * * This next routine began life as a macro and many parameters in it * are used as call-by-reference values. */ static char * scan_diff_line (scan_ptr, set_start, set_length, limit, firstchar) char *scan_ptr, **set_start; size_t *set_length; char *limit; char firstchar; { char *line_ptr; if (!(scan_ptr[0] == (firstchar) && scan_ptr[1] == ' ')) fatal ("invalid diff format; incorrect leading line chars"); *set_start = line_ptr = scan_ptr + 2; while (*line_ptr++ != '\n') ; /* Include newline if the original line ended in a newline, or if an edit script is being generated. Copy any missing newline message to stderr if an edit script is being generated, because edit scripts cannot handle missing newlines. Return the beginning of the next line. */ *set_length = line_ptr - *set_start; if (line_ptr < limit && *line_ptr == '\\') { if (edscript) fprintf (stderr, "%s:", argv0); else --*set_length; line_ptr++; do { if (edscript) putc (*line_ptr, stderr); } while (*line_ptr++ != '\n'); } return line_ptr; } /* * This routine outputs a three way diff passed as a list of * diff3_block's. * The argument MAPPING is indexed by external file number (in the * argument list) and contains the internal file number (from the * diff passed). This is important because the user expects his * outputs in terms of the argument list number, and the diff passed * may have been done slightly differently (if the last argument * was "-", for example). * REV_MAPPING is the inverse of MAPPING. */ static void output_diff3 (outputfile, diff, mapping, rev_mapping) FILE *outputfile; struct diff3_block *diff; int const mapping[3], rev_mapping[3]; { int i; int oddoneout; char *cp; struct diff3_block *ptr; int line; size_t length; int dontprint; static int skew_increment[3] = { 2, 3, 1 }; /* 0==>2==>1==>3 */ char const *line_prefix = tab_align_flag ? "\t" : " "; for (ptr = diff; ptr; ptr = D_NEXT (ptr)) { char x[2]; switch (ptr->correspond) { case DIFF_ALL: x[0] = '\0'; dontprint = 3; /* Print them all */ oddoneout = 3; /* Nobody's odder than anyone else */ break; case DIFF_1ST: case DIFF_2ND: case DIFF_3RD: oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST]; x[0] = oddoneout + '1'; x[1] = '\0'; dontprint = oddoneout==0; break; default: fatal ("internal error: invalid diff type passed to output"); } fprintf (outputfile, "====%s\n", x); /* Go 0, 2, 1 if the first and third outputs are equivalent. */ for (i = 0; i < 3; i = (oddoneout == 1 ? skew_increment[i] : i + 1)) { int realfile = mapping[i]; int lowt = D_LOWLINE (ptr, realfile), hight = D_HIGHLINE (ptr, realfile); fprintf (outputfile, "%d:", i + 1); switch (lowt - hight) { case 1: fprintf (outputfile, "%da\n", lowt - 1); break; case 0: fprintf (outputfile, "%dc\n", lowt); break; default: fprintf (outputfile, "%d,%dc\n", lowt, hight); break; } if (i == dontprint) continue; if (lowt <= hight) { line = 0; do { fprintf (outputfile, line_prefix); cp = D_RELNUM (ptr, realfile, line); length = D_RELLEN (ptr, realfile, line); fwrite (cp, sizeof (char), length, outputfile); } while (++line < hight - lowt + 1); if (cp[length - 1] != '\n') fprintf (outputfile, "\n\\ No newline at end of file\n"); } } } } /* * Output to OUTPUTFILE the lines of B taken from FILENUM. * Double any initial '.'s; yield nonzero if any initial '.'s were doubled. */ static int dotlines (outputfile, b, filenum) FILE *outputfile; struct diff3_block *b; int filenum; { int i; int leading_dot = 0; for (i = 0; i < D_NUMLINES (b, filenum); i++) { char *line = D_RELNUM (b, filenum, i); if (line[0] == '.') { leading_dot = 1; fprintf (outputfile, "."); } fwrite (line, sizeof (char), D_RELLEN (b, filenum, i), outputfile); } return leading_dot; } /* * Output to OUTPUTFILE a '.' line. If LEADING_DOT is nonzero, * also output a command that removes initial '.'s * starting with line START and continuing for NUM lines. */ static void undotlines (outputfile, leading_dot, start, num) FILE *outputfile; int leading_dot, start, num; { fprintf (outputfile, ".\n"); if (leading_dot) if (num == 1) fprintf (outputfile, "%ds/^\\.//\n", start); else fprintf (outputfile, "%d,%ds/^\\.//\n", start, start + num - 1); } /* * This routine outputs a diff3 set of blocks as an ed script. This * script applies the changes between file's 2 & 3 to file 1. It * takes the precise format of the ed script to be output from global * variables set during options processing. Note that it does * destructive things to the set of diff3 blocks it is passed; it * reverses their order (this gets around the problems involved with * changing line numbers in an ed script). * * Note that this routine has the same problem of mapping as the last * one did; the variable MAPPING maps from file number according to * the argument list to file number according to the diff passed. All * files listed below are in terms of the argument list. * REV_MAPPING is the inverse of MAPPING. * * The arguments FILE0, FILE1 and FILE2 are the strings to print * as the names of the three files. These may be the actual names, * or may be the arguments specified with -L. * * Returns 1 if conflicts were found. */ static int output_diff3_edscript (outputfile, diff, mapping, rev_mapping, file0, file1, file2) FILE *outputfile; struct diff3_block *diff; int const mapping[3], rev_mapping[3]; char const *file0, *file1, *file2; { int leading_dot; int conflicts_found = 0, conflict; struct diff3_block *b; for (b = reverse_diff3_blocklist (diff); b; b = b->next) { /* Must do mapping correctly. */ enum diff_type type = ((b->correspond == DIFF_ALL) ? DIFF_ALL : ((enum diff_type) (((int) DIFF_1ST) + rev_mapping[(int) b->correspond - (int) DIFF_1ST]))); /* If we aren't supposed to do this output block, skip it. */ switch (type) { default: continue; case DIFF_2ND: if (!show_2nd) continue; conflict = 1; break; case DIFF_3RD: if (overlap_only) continue; conflict = 0; break; case DIFF_ALL: if (simple_only) continue; conflict = flagging; break; } if (conflict) { conflicts_found = 1; /* Mark end of conflict. */ fprintf (outputfile, "%da\n", D_HIGHLINE (b, mapping[FILE0])); leading_dot = 0; if (type == DIFF_ALL) { if (show_2nd) { /* Append lines from FILE1. */ fprintf (outputfile, "||||||| %s\n", file1); leading_dot = dotlines (outputfile, b, mapping[FILE1]); } /* Append lines from FILE2. */ fprintf (outputfile, "=======\n"); leading_dot |= dotlines (outputfile, b, mapping[FILE2]); } fprintf (outputfile, ">>>>>>> %s\n", file2); undotlines (outputfile, leading_dot, D_HIGHLINE (b, mapping[FILE0]) + 2, (D_NUMLINES (b, mapping[FILE1]) + D_NUMLINES (b, mapping[FILE2]) + 1)); /* Mark start of conflict. */ fprintf (outputfile, "%da\n<<<<<<< %s\n", D_LOWLINE (b, mapping[FILE0]) - 1, type == DIFF_ALL ? file0 : file1); leading_dot = 0; if (type == DIFF_2ND) { /* Prepend lines from FILE1. */ leading_dot = dotlines (outputfile, b, mapping[FILE1]); fprintf (outputfile, "=======\n"); } undotlines (outputfile, leading_dot, D_LOWLINE (b, mapping[FILE0]) + 1, D_NUMLINES (b, mapping[FILE1])); } else if (D_NUMLINES (b, mapping[FILE2]) == 0) /* Write out a delete */ { if (D_NUMLINES (b, mapping[FILE0]) == 1) fprintf (outputfile, "%dd\n", D_LOWLINE (b, mapping[FILE0])); else fprintf (outputfile, "%d,%dd\n", D_LOWLINE (b, mapping[FILE0]), D_HIGHLINE (b, mapping[FILE0])); } else /* Write out an add or change */ { switch (D_NUMLINES (b, mapping[FILE0])) { case 0: fprintf (outputfile, "%da\n", D_HIGHLINE (b, mapping[FILE0])); break; case 1: fprintf (outputfile, "%dc\n", D_HIGHLINE (b, mapping[FILE0])); break; default: fprintf (outputfile, "%d,%dc\n", D_LOWLINE (b, mapping[FILE0]), D_HIGHLINE (b, mapping[FILE0])); break; } undotlines (outputfile, dotlines (outputfile, b, mapping[FILE2]), D_LOWLINE (b, mapping[FILE0]), D_NUMLINES (b, mapping[FILE2])); } } if (finalwrite) fprintf (outputfile, "w\nq\n"); return conflicts_found; } /* * Read from INFILE and output to OUTPUTFILE a set of diff3_ blocks DIFF * as a merged file. This acts like 'ed file0 <[output_diff3_edscript]', * except that it works even for binary data or incomplete lines. * * As before, MAPPING maps from arg list file number to diff file number, * REV_MAPPING is its inverse, * and FILE0, FILE1, and FILE2 are the names of the files. * * Returns 1 if conflicts were found. */ static int output_diff3_merge (infile, outputfile, diff, mapping, rev_mapping, file0, file1, file2) FILE *infile, *outputfile; struct diff3_block *diff; int const mapping[3], rev_mapping[3]; char const *file0, *file1, *file2; { int c, i; int conflicts_found = 0, conflict; struct diff3_block *b; int linesread = 0; for (b = diff; b; b = b->next) { /* Must do mapping correctly. */ enum diff_type type = ((b->correspond == DIFF_ALL) ? DIFF_ALL : ((enum diff_type) (((int) DIFF_1ST) + rev_mapping[(int) b->correspond - (int) DIFF_1ST]))); char const *format_2nd = "<<<<<<< %s\n"; /* If we aren't supposed to do this output block, skip it. */ switch (type) { default: continue; case DIFF_2ND: if (!show_2nd) continue; conflict = 1; break; case DIFF_3RD: if (overlap_only) continue; conflict = 0; break; case DIFF_ALL: if (simple_only) continue; conflict = flagging; format_2nd = "||||||| %s\n"; break; } /* Copy I lines from file 0. */ i = D_LOWLINE (b, FILE0) - linesread - 1; linesread += i; while (0 <= --i) do { c = getc (infile); if (c == EOF) if (ferror (infile)) perror_with_exit ("input file"); else if (feof (infile)) fatal ("input file shrank"); putc (c, outputfile); } while (c != '\n'); if (conflict) { conflicts_found = 1; if (type == DIFF_ALL) { /* Put in lines from FILE0 with bracket. */ fprintf (outputfile, "<<<<<<< %s\n", file0); for (i = 0; i < D_NUMLINES (b, mapping[FILE0]); i++) fwrite (D_RELNUM (b, mapping[FILE0], i), sizeof (char), D_RELLEN (b, mapping[FILE0], i), outputfile); } if (show_2nd) { /* Put in lines from FILE1 with bracket. */ fprintf (outputfile, format_2nd, file1); for (i = 0; i < D_NUMLINES (b, mapping[FILE1]); i++) fwrite (D_RELNUM (b, mapping[FILE1], i), sizeof (char), D_RELLEN (b, mapping[FILE1], i), outputfile); } fprintf (outputfile, "=======\n"); } /* Put in lines from FILE2. */ for (i = 0; i < D_NUMLINES (b, mapping[FILE2]); i++) fwrite (D_RELNUM (b, mapping[FILE2], i), sizeof (char), D_RELLEN (b, mapping[FILE2], i), outputfile); if (conflict) fprintf (outputfile, ">>>>>>> %s\n", file2); /* Skip I lines in file 0. */ i = D_NUMLINES (b, FILE0); linesread += i; while (0 <= --i) while ((c = getc (infile)) != '\n') if (c == EOF) if (ferror (infile)) perror_with_exit ("input file"); else if (feof (infile)) { if (i || b->next) fatal ("input file shrank"); return conflicts_found; } } /* Copy rest of common file. */ while ((c = getc (infile)) != EOF || !(ferror (infile) | feof (infile))) putc (c, outputfile); return conflicts_found; } /* * Reverse the order of the list of diff3 blocks. */ static struct diff3_block * reverse_diff3_blocklist (diff) struct diff3_block *diff; { register struct diff3_block *tmp, *next, *prev; for (tmp = diff, prev = 0; tmp; tmp = next) { next = tmp->next; tmp->next = prev; prev = tmp; } return prev; } static size_t myread (fd, ptr, size) int fd; char *ptr; size_t size; { size_t result = read (fd, ptr, size); if (result == -1) perror_with_exit ("read failed"); return result; } VOID * xmalloc (size) size_t size; { VOID *result = (VOID *) malloc (size ? size : 1); if (!result) fatal ("virtual memory exhausted"); return result; } static VOID * xrealloc (ptr, size) VOID *ptr; size_t size; { VOID *result = (VOID *) realloc (ptr, size ? size : 1); if (!result) fatal ("virtual memory exhausted"); return result; } static void fatal (string) char const *string; { fprintf (stderr, "%s: %s\n", argv0, string); exit (2); } static void perror_with_exit (string) char const *string; { int e = errno; fprintf (stderr, "%s: ", argv0); errno = e; perror (string); exit (2); } diffutils-2.4/sdiff.c100444 74720 14 60662 5444410124 13523 0ustar eggertguest/* SDIFF -- interactive merge front end to diff Copyright (C) 1992, 1993 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU DIFF; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* GNU SDIFF was written by Thomas Lord. */ #include #include #include "system.h" #include #include "getopt.h" /* Size of chunks read from files which must be parsed into lines. */ #define SDIFF_BUFSIZE ((size_t) 65536) /* Default name of the diff program */ #ifndef DIFF_PROGRAM #define DIFF_PROGRAM "/usr/bin/diff" #endif /* Users' editor of nonchoice */ #ifndef DEFAULT_EDITOR #define DEFAULT_EDITOR "ed" #endif extern char version_string[]; static char const *prog; static char const *diffbin = DIFF_PROGRAM; static char const *edbin = DEFAULT_EDITOR; static char *tmpname; static int volatile tmpmade; static pid_t volatile diffpid; struct line_filter; static FILE *ck_fdopen PARAMS((int, char const *)); static FILE *ck_fopen PARAMS((char const *, char const *)); static RETSIGTYPE catchsig PARAMS((int)); static VOID *xmalloc PARAMS((size_t)); static char const *expand_name PARAMS((char *, int, char const *)); static int edit PARAMS((struct line_filter *, int, struct line_filter *, int, FILE*)); static int interact PARAMS((struct line_filter *, struct line_filter *, struct line_filter *, FILE*)); static int lf_snarf PARAMS((struct line_filter *, char *, size_t)); static int skip_white PARAMS((void)); static size_t ck_fread PARAMS((char *, size_t, FILE *)); static size_t lf_refill PARAMS((struct line_filter *)); static void checksigs PARAMS((void)); static void ck_fclose PARAMS((FILE *)); static void ck_fflush PARAMS((FILE *)); static void ck_fwrite PARAMS((char const *, size_t, FILE *)); static void cleanup PARAMS((void)); static void diffarg PARAMS((char const *)); static void execdiff PARAMS((int, char const *, char const *, char const *)); static void exiterr PARAMS((void)); static void fatal PARAMS((char const *)); static void flush_line PARAMS((void)); static void give_help PARAMS((void)); static void lf_copy PARAMS((struct line_filter *, int, FILE *)); static void lf_init PARAMS((struct line_filter *, FILE *)); static void lf_skip PARAMS((struct line_filter *, int)); static void perror_fatal PARAMS((char const *)); static void trapsigs PARAMS((void)); static void untrapsig PARAMS((int)); static void usage PARAMS((void)); /* this lossage until the gnu libc conquers the universe */ #define PVT_tmpdir "/tmp" static char *private_tempnam PARAMS((char const *, char const *, int, size_t *)); static int diraccess PARAMS((char const *)); static int exists PARAMS((char const *)); /* Options: */ /* name of output file if -o spec'd */ static char *out_file; /* do not print common lines if true, set by -s option */ static int suppress_common_flag; static struct option const longopts[] = { {"ignore-blank-lines", 0, 0, 'B'}, {"speed-large-files", 0, 0, 'H'}, {"ignore-matching-lines", 1, 0, 'I'}, {"ignore-all-space", 0, 0, 'W'}, /* swap W and w for historical reasons */ {"text", 0, 0, 'a'}, {"ignore-space-change", 0, 0, 'b'}, {"minimal", 0, 0, 'd'}, {"ignore-case", 0, 0, 'i'}, {"left-column", 0, 0, 'l'}, {"output", 1, 0, 'o'}, {"suppress-common-lines", 0, 0, 's'}, {"expand-tabs", 0, 0, 't'}, {"width", 1, 0, 'w'}, {"version", 0, 0, 'v'}, {0, 0, 0, 0} }; /* prints usage message and quits */ static void usage () { fprintf (stderr, "Usage: %s [options] from-file to-file\n", prog); fprintf (stderr, "Options:\n\ [-abBdHilstv] [-I regexp] [-o outfile] [-w columns]\n\ [--text] [--minimal] [--speed-large-files] [--expand-tabs]\n\ [--ignore-case] [--ignore-matching-lines=regexp]\n\ [--ignore-space-change] [--ignore-blank-lines] [--ignore-all-space]\n\ [--suppress-common-lines] [--left-column] [--output=outfile]\n\ [--version] [--width=columns]\n"); exit (2); } static void cleanup () { if (0 < diffpid) kill (diffpid, SIGPIPE); if (tmpmade) unlink (tmpname); } static void exiterr () { cleanup (); untrapsig (0); checksigs (); exit (2); } static void fatal (msg) char const *msg; { fprintf (stderr, "%s: %s\n", prog, msg); exiterr (); } static void perror_fatal (msg) char const *msg; { int e = errno; checksigs (); fprintf (stderr, "%s: ", prog); errno = e; perror (msg); exiterr (); } /* malloc freely or DIE! */ VOID * xmalloc (size) size_t size; { VOID *r = malloc (size); if (!r) fatal ("virtual memory exhausted"); return r; } static FILE * ck_fopen (fname, type) char const *fname, *type; { FILE *r = fopen (fname, type); if (!r) perror_fatal (fname); return r; } static FILE * ck_fdopen (fd, type) int fd; char const *type; { FILE *r = fdopen (fd, type); if (!r) perror_fatal ("fdopen"); return r; } static void ck_fclose (f) FILE *f; { if (fclose (f)) perror_fatal ("input/output error"); } static size_t ck_fread (buf, size, f) char *buf; size_t size; FILE *f; { size_t r = fread (buf, sizeof (char), size, f); if (r == 0 && ferror (f)) perror_fatal ("input error"); return r; } static void ck_fwrite (buf, size, f) char const *buf; size_t size; FILE *f; { if (fwrite (buf, sizeof (char), size, f) != size) perror_fatal ("output error"); } static void ck_fflush (f) FILE *f; { if (fflush (f) != 0) perror_fatal ("output error"); } #if !HAVE_MEMCHR char * memchr (s, c, n) char *s; int c; size_t n; { unsigned char *p = (unsigned char *) s, *lim = p + n; for (; p < lim; p++) if (*p == c) return (char *) p; return 0; } #endif #ifndef HAVE_WAITPID /* Emulate waitpid well enough for sdiff, which has at most two children. */ static pid_t waitpid (pid, stat_loc, options) pid_t pid; int *stat_loc; int options; { static int ostatus; static pid_t opid; int npid, status; if (pid == opid) { opid = 0; status = ostatus; } else while ((npid = wait (&status)) != pid) { if (npid < 0) return npid; opid = npid; ostatus = status; } *stat_loc = status; return pid; } #endif static char const * expand_name (name, isdir, other_name) char *name; int isdir; char const *other_name; { if (strcmp (name, "-") == 0) fatal ("cannot interactively merge standard input"); if (!isdir) return name; else { /* Yield NAME/BASE, where BASE is OTHER_NAME's basename. */ char const *p = strrchr (other_name, '/'), *base = p ? p+1 : other_name; size_t namelen = strlen (name), baselen = strlen (base); char *r = xmalloc (namelen + baselen + 2); memcpy (r, name, namelen); r[namelen] = '/'; memcpy (r + namelen + 1, base, baselen + 1); return r; } } struct line_filter { FILE *infile; char *bufpos; char *buffer; char *buflim; }; static void lf_init (lf, infile) struct line_filter *lf; FILE *infile; { lf->infile = infile; lf->bufpos = lf->buffer = lf->buflim = xmalloc (SDIFF_BUFSIZE + 1); lf->buflim[0] = '\n'; } /* Fill an exhausted line_filter buffer from its INFILE */ static size_t lf_refill (lf) struct line_filter *lf; { size_t s = ck_fread (lf->buffer, SDIFF_BUFSIZE, lf->infile); lf->bufpos = lf->buffer; lf->buflim = lf->buffer + s; lf->buflim[0] = '\n'; checksigs (); return s; } /* Advance LINES on LF's infile, copying lines to OUTFILE */ static void lf_copy (lf, lines, outfile) struct line_filter *lf; int lines; FILE *outfile; { char *start = lf->bufpos; while (lines) { lf->bufpos = memchr (lf->bufpos, '\n', lf->buflim - lf->bufpos); if (! lf->bufpos) { ck_fwrite (start, lf->buflim - start, outfile); if (! lf_refill (lf)) return; start = lf->bufpos; } else { --lines; ++lf->bufpos; } } ck_fwrite (start, lf->bufpos - start, outfile); } /* Advance LINES on LF's infile without doing output */ static void lf_skip (lf, lines) struct line_filter *lf; int lines; { while (lines) { lf->bufpos = memchr (lf->bufpos, '\n', lf->buflim - lf->bufpos); if (! lf->bufpos) { if (! lf_refill (lf)) break; } else { --lines; ++lf->bufpos; } } } /* Snarf a line into a buffer. Return EOF if EOF, 0 if error, 1 if OK. */ static int lf_snarf (lf, buffer, bufsize) struct line_filter *lf; char *buffer; size_t bufsize; { char *start = lf->bufpos; for (;;) { char *next = memchr (start, '\n', lf->buflim + 1 - start); size_t s = next - start; if (bufsize <= s) return 0; memcpy (buffer, start, s); if (next < lf->buflim) { buffer[s] = 0; lf->bufpos = next + 1; return 1; } if (! lf_refill (lf)) return s ? 0 : EOF; buffer += s; bufsize -= s; start = next; } } int main (argc, argv) int argc; char *argv[]; { int opt; int version_requested = 0; char *editor = getenv ("EDITOR"); char *differ = getenv ("DIFF"); prog = argv[0]; if (editor) edbin = editor; if (differ) diffbin = differ; diffarg ("diff"); /* parse command line args */ while ((opt = getopt_long (argc, argv, "abBdHiI:lo:stvw:W", longopts, 0)) != EOF) { switch (opt) { case 'a': diffarg ("-a"); break; case 'b': diffarg ("-b"); break; case 'B': diffarg ("-B"); break; case 'd': diffarg ("-d"); break; case 'H': diffarg ("-H"); break; case 'i': diffarg ("-i"); break; case 'I': diffarg ("-I"); diffarg (optarg); break; case 'l': diffarg ("--left-column"); break; case 'o': out_file = optarg; break; case 's': suppress_common_flag = 1; break; case 't': diffarg ("-t"); break; case 'v': version_requested = 1; fprintf (stderr, "GNU sdiff version %s\n", version_string); ck_fflush (stderr); break; case 'w': diffarg ("-W"); diffarg (optarg); break; case 'W': diffarg ("-w"); break; default: usage (); } } /* check: did user just want version message? if so exit. */ if (version_requested && argc - optind == 0) exit (0); if (argc - optind != 2) usage (); if (! out_file) /* easy case: diff does everything for us */ execdiff (suppress_common_flag, "-y", argv[optind], argv[optind + 1]); else { FILE *left, *right, *out, *diffout; int diff_fds[2]; int interact_ok; pid_t pid; struct line_filter lfilt; struct line_filter rfilt; struct line_filter diff_filt; int leftdir = diraccess (argv[optind]); int rightdir = diraccess (argv[optind + 1]); if (leftdir && rightdir) fatal ("both files to be compared are directories"); left = ck_fopen (expand_name (argv[optind], leftdir, argv[optind + 1]), "r"); ; right = ck_fopen (expand_name (argv[optind + 1], rightdir, argv[optind]), "r"); out = ck_fopen (out_file, "w"); if (pipe (diff_fds)) perror_fatal ("pipe"); trapsigs (); diffpid = pid = vfork (); if (pid == 0) { signal (SIGINT, SIG_IGN); /* in case user interrupts editor */ signal (SIGPIPE, SIG_DFL); close (diff_fds[0]); if (diff_fds[1] != STDOUT_FILENO) { dup2 (diff_fds[1], STDOUT_FILENO); close (diff_fds[1]); } execdiff (0, "--sdiff-merge-assist", argv[optind], argv[optind + 1]); } if (pid < 0) perror_fatal ("fork failed"); close (diff_fds[1]); diffout = ck_fdopen (diff_fds[0], "r"); lf_init (&diff_filt, diffout); lf_init (&lfilt, left); lf_init (&rfilt, right); interact_ok = interact (&diff_filt, &lfilt, &rfilt, out); ck_fclose (diffout); ck_fclose (left); ck_fclose (right); ck_fclose (out); { int wstatus; while (waitpid (pid, &wstatus, 0) < 0) if (errno == EINTR) checksigs (); else perror_fatal ("wait failed"); diffpid = 0; if (tmpmade) { unlink (tmpname); tmpmade = 0; } if (! interact_ok) exiterr (); if (! (WIFEXITED (wstatus) && WEXITSTATUS (wstatus) < 2)) fatal ("Subsidiary diff failed"); untrapsig (0); checksigs (); exit (WEXITSTATUS (wstatus)); } } return 0; /* Fool -Wall . . . */ } static char const **diffargv; static void diffarg (a) char const *a; { static unsigned diffargs, diffargsmax; if (diffargs == diffargsmax) { if (! diffargsmax) { diffargv = (char const **) xmalloc (sizeof (char)); diffargsmax = 8; } diffargsmax *= 2; diffargv = (char const **) realloc (diffargv, diffargsmax * sizeof (char const *)); if (! diffargv) fatal ("out of memory"); } diffargv[diffargs++] = a; } static void execdiff (differences_only, option, file1, file2) int differences_only; char const *option, *file1, *file2; { if (differences_only) diffarg ("--suppress-common-lines"); diffarg (option); diffarg ("--"); diffarg (file1); diffarg (file2); diffarg (0); execvp (diffbin, (char **) diffargv); write (STDERR_FILENO, diffbin, strlen (diffbin)); write (STDERR_FILENO, ": not found\n", 12); _exit (2); } /* Signal handling */ #define NUM_SIGS (sizeof (sigs) / sizeof (*sigs)) static int const sigs[] = { #ifdef SIGHUP SIGHUP, #endif #ifdef SIGQUIT SIGQUIT, #endif #ifdef SIGTERM SIGTERM, #endif #ifdef SIGXCPU SIGXCPU, #endif #ifdef SIGXFSZ SIGXFSZ, #endif SIGINT, SIGPIPE }; /* Prefer `sigaction' if it is available, since `signal' can lose signals. */ #if HAVE_SIGACTION static struct sigaction initial_action[NUM_SIGS]; #define initial_handler(i) (initial_action[i].sa_handler) #else static RETSIGTYPE (*initial_action[NUM_SIGS]) (); #define initial_handler(i) (initial_action[i]) #endif static int volatile ignore_SIGINT; static int volatile signal_received; static int sigs_trapped; static RETSIGTYPE catchsig (s) int s; { #if ! HAVE_SIGACTION signal (s, SIG_IGN); #endif if (! (s == SIGINT && ignore_SIGINT)) signal_received = s; } static void trapsigs () { int i; #if HAVE_SIGACTION struct sigaction catchaction; bzero (&catchaction, sizeof (catchaction)); catchaction.sa_handler = catchsig; #ifdef SA_INTERRUPT /* Non-Posix BSD-style systems like SunOS 4.1.x need this so that `read' calls are interrupted properly. */ catchaction.sa_flags = SA_INTERRUPT; #endif sigemptyset (&catchaction.sa_mask); for (i = 0; i < NUM_SIGS; i++) sigaddset (&catchaction.sa_mask, sigs[i]); for (i = 0; i < NUM_SIGS; i++) { sigaction (sigs[i], 0, &initial_action[i]); if (initial_handler (i) != SIG_IGN && sigaction (sigs[i], &catchaction, 0) != 0) fatal ("signal error"); } #else /* ! HAVE_SIGACTION */ for (i = 0; i < NUM_SIGS; i++) { initial_action[i] = signal (sigs[i], SIG_IGN); if (initial_handler (i) != SIG_IGN && signal (sigs[i], catchsig) != SIG_IGN) fatal ("signal error"); } #endif /* ! HAVE_SIGACTION */ sigs_trapped = 1; } /* Untrap signal S, or all trapped signals if S is zero. */ static void untrapsig (s) int s; { int i; if (sigs_trapped) for (i = 0; i < NUM_SIGS; i++) if ((!s || sigs[i] == s) && initial_handler (i) != SIG_IGN) #if HAVE_SIGACTION sigaction (sigs[i], &initial_action[i], 0); #else signal (sigs[i], initial_action[i]); #endif } /* Exit if a signal has been received. */ static void checksigs () { int s = signal_received; if (s) { cleanup (); /* Yield an exit status indicating that a signal was received. */ untrapsig (s); kill (getpid (), s); /* That didn't work, so exit with error status. */ exit (2); } } static void give_help () { fprintf (stderr,"l:\tuse the left version\n"); fprintf (stderr,"r:\tuse the right version\n"); fprintf (stderr,"e l:\tedit then use the left version\n"); fprintf (stderr,"e r:\tedit then use the right version\n"); fprintf (stderr,"e b:\tedit then use the left and right versions concatenated\n"); fprintf (stderr,"e:\tedit a new version\n"); fprintf (stderr,"s:\tsilently include common lines\n"); fprintf (stderr,"v:\tverbosely include common lines\n"); fprintf (stderr,"q:\tquit\n"); } static int skip_white () { int c; while (isspace (c = getchar ()) && c != '\n') checksigs (); if (ferror (stdin)) perror_fatal ("input error"); return c; } static void flush_line () { int c; while ((c = getchar ()) != '\n' && c != EOF) ; if (ferror (stdin)) perror_fatal ("input error"); } /* interpret an edit command */ static int edit (left, lenl, right, lenr, outfile) struct line_filter *left; int lenl; struct line_filter *right; int lenr; FILE *outfile; { for (;;) { int cmd0, cmd1; int gotcmd = 0; cmd1 = 0; /* Pacify `gcc -W'. */ while (!gotcmd) { if (putchar ('%') != '%') perror_fatal ("output error"); ck_fflush (stdout); cmd0 = skip_white (); switch (cmd0) { case 'l': case 'r': case 's': case 'v': case 'q': if (skip_white () != '\n') { give_help (); flush_line (); continue; } gotcmd = 1; break; case 'e': cmd1 = skip_white (); switch (cmd1) { case 'l': case 'r': case 'b': if (skip_white () != '\n') { give_help (); flush_line (); continue; } gotcmd = 1; break; case '\n': gotcmd = 1; break; default: give_help (); flush_line (); continue; } break; case EOF: if (feof (stdin)) { gotcmd = 1; cmd0 = 'q'; break; } /* falls through */ default: flush_line (); /* falls through */ case '\n': give_help (); continue; } } switch (cmd0) { case 'l': lf_copy (left, lenl, outfile); lf_skip (right, lenr); return 1; case 'r': lf_copy (right, lenr, outfile); lf_skip (left, lenl); return 1; case 's': suppress_common_flag = 1; break; case 'v': suppress_common_flag = 0; break; case 'q': return 0; case 'e': if (! tmpname && ! (tmpname = private_tempnam (0, "sdiff", 1, 0))) perror_fatal ("temporary file name"); tmpmade = 1; { FILE *tmp = ck_fopen (tmpname, "w+"); if (cmd1 == 'l' || cmd1 == 'b') lf_copy (left, lenl, tmp); else lf_skip (left, lenl); if (cmd1 == 'r' || cmd1 == 'b') lf_copy (right, lenr, tmp); else lf_skip (right, lenr); ck_fflush (tmp); { pid_t pid; int wstatus; ignore_SIGINT = 1; checksigs (); pid = vfork (); if (pid == 0) { char const *argv[3]; int i = 0; argv[i++] = edbin; argv[i++] = tmpname; argv[i++] = 0; execvp (edbin, (char **) argv); write (STDERR_FILENO, edbin, strlen (edbin)); write (STDERR_FILENO, ": not found\n", 12); _exit (1); } if (pid < 0) perror_fatal ("fork failed"); while (waitpid (pid, &wstatus, 0) < 0) if (errno == EINTR) checksigs (); else perror_fatal ("wait failed"); ignore_SIGINT = 0; if (! (WIFEXITED (wstatus) && WEXITSTATUS (wstatus) < 1)) fatal ("Subsidiary editor failed"); } if (fseek (tmp, 0L, SEEK_SET) != 0) perror_fatal ("fseek"); { /* SDIFF_BUFSIZE is too big for a local var in some compilers, so we allocate it dynamically. */ char *buf = xmalloc (SDIFF_BUFSIZE); size_t size; while ((size = ck_fread (buf, SDIFF_BUFSIZE, tmp)) != 0) { checksigs (); ck_fwrite (buf, size, outfile); } ck_fclose (tmp); free (buf); } return 1; } default: give_help (); break; } } } /* Alternately reveal bursts of diff output and handle user commands. */ static int interact (diff, left, right, outfile) struct line_filter *diff; struct line_filter *left; struct line_filter *right; FILE *outfile; { for (;;) { char diff_help[256]; int snarfed = lf_snarf (diff, diff_help, sizeof (diff_help)); if (snarfed <= 0) return snarfed; checksigs (); switch (diff_help[0]) { case ' ': puts (diff_help + 1); break; case 'i': { int lenl = atoi (diff_help + 1), lenr, lenmax; char *p = strchr (diff_help, ','); if (!p) fatal (diff_help); lenr = atoi (p + 1); lenmax = max (lenl, lenr); if (suppress_common_flag) lf_skip (diff, lenmax); else lf_copy (diff, lenmax, stdout); lf_copy (left, lenl, outfile); lf_skip (right, lenr); break; } case 'c': { int lenl = atoi (diff_help + 1), lenr; char *p = strchr (diff_help, ','); if (!p) fatal (diff_help); lenr = atoi (p + 1); lf_copy (diff, max (lenl, lenr), stdout); if (! edit (left, lenl, right, lenr, outfile)) return 0; break; } default: fatal (diff_help); break; } } } /* temporary lossage: this is torn from gnu libc */ /* Return nonzero if DIR is an existing directory. */ static int diraccess (dir) char const *dir; { struct stat buf; return stat (dir, &buf) == 0 && S_ISDIR (buf.st_mode); } /* Return nonzero if FILE exists. */ static int exists (file) char const *file; { struct stat buf; return stat (file, &buf) == 0; } /* These are the characters used in temporary filenames. */ static char const letters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; /* Generate a temporary filename. If DIR_SEARCH is nonzero, DIR and PFX are used as described for tempnam. If not, a temporary filename in P_tmpdir with no special prefix is generated. If LENPTR is not 0, *LENPTR is set the to length (including the terminating '\0') of the resultant filename, which is returned. This goes through a cyclic pattern of all possible filenames consisting of five decimal digits of the current pid and three of the characters in `letters'. Data for tempnam and tmpnam is kept separate, but when tempnam is using P_tmpdir and no prefix (i.e, it is identical to tmpnam), the same data is used. Each potential filename is tested for an already-existing file of the same name, and no name of an existing file will be returned. When the cycle reaches its end (12345ZZZ), 0 is returned. */ static char * private_tempnam (dir, pfx, dir_search, lenptr) char const *dir; char const *pfx; int dir_search; size_t *lenptr; { static char const tmpdir[] = PVT_tmpdir; static struct { char buf[3]; char *s; size_t i; } infos[2], *info; static char *buf; static size_t bufsize = 1; static pid_t oldpid = 0; pid_t pid = getpid (); register size_t len, plen; if (dir_search) { register char const *d = getenv ("TMPDIR"); if (d && !diraccess (d)) d = 0; if (!d && dir && diraccess (dir)) d = dir; if (!d && diraccess (tmpdir)) d = tmpdir; if (!d && diraccess ("/tmp")) d = "/tmp"; if (!d) { errno = ENOENT; return 0; } dir = d; } else dir = tmpdir; if (pfx && *pfx) { plen = strlen (pfx); if (plen > 5) plen = 5; } else plen = 0; if (dir != tmpdir && !strcmp (dir, tmpdir)) dir = tmpdir; info = &infos[(plen == 0 && dir == tmpdir) ? 1 : 0]; if (pid != oldpid) { oldpid = pid; info->buf[0] = info->buf[1] = info->buf[2] = '0'; info->s = &info->buf[0]; info->i = 0; } len = strlen (dir) + 1 + plen + 8; if (bufsize <= len) { do { bufsize *= 2; } while (bufsize <= len); if (buf) free (buf); buf = xmalloc (bufsize); } for (;;) { *info->s = letters[info->i]; sprintf (buf, "%s/%.*s%.5lu%.3s", dir, (int) plen, pfx, (unsigned long) pid % 100000, info->buf); if (!exists (buf)) break; ++info->i; if (info->i > sizeof (letters) - 1) { info->i = 0; if (info->s == &info->buf[2]) { errno = EEXIST; return 0; } ++info->s; } } if (lenptr) *lenptr = len; return buf; } diffutils-2.4/cmp.c100444 74720 14 31634 5445367064 13223 0ustar eggertguest/* cmp -- compare two files. Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by Torbjorn Granlund and David MacKenzie. */ #include #include "system.h" #include "getopt.h" #include "cmpbuf.h" #if __STDC__ && defined (HAVE_VPRINTF) void error (int, int, char const *, ...); #else void error (); #endif VOID *xmalloc PARAMS((size_t)); static int cmp PARAMS((void)); static off_t file_position PARAMS((int)); static size_t block_compare PARAMS((char const *, char const *)); static size_t block_compare_and_count PARAMS((char const *, char const *, long *)); static size_t block_read PARAMS((int, char *, size_t)); static void printc PARAMS((int, unsigned)); static void usage PARAMS((char const *)); /* Name under which this program was invoked. */ char const *program_name; /* Filenames of the compared files. */ static char const *file[2]; /* File descriptors of the files. */ static int file_desc[2]; /* Read buffers for the files. */ static char *buffer[2]; /* Optimal block size for the files. */ static size_t buf_size; /* Initial prefix to ignore for each file. */ static off_t ignore_initial; /* Output format: type_first_diff to print the offset and line number of the first differing bytes type_all_diffs to print the (decimal) offsets and (octal) values of all differing bytes type_status to only return an exit status indicating whether the files differ */ static enum { type_first_diff, type_all_diffs, type_status } comparison_type; /* If nonzero, print values of bytes quoted like cat -t does. */ static int opt_print_chars; static struct option const long_options[] = { {"print-chars", 0, 0, 'c'}, {"ignore-initial", 1, 0, 'i'}, {"verbose", 0, 0, 'l'}, {"silent", 0, 0, 's'}, {"quiet", 0, 0, 's'}, {0, 0, 0, 0} }; static void usage (reason) char const *reason; { if (reason) fprintf (stderr, "%s: %s\n", program_name, reason); fprintf (stderr, "\ Usage: %s [-cls] [-i chars] [--ignore-initial=bytes]\n\ [--print-chars] [--quiet] [--silent] [--verbose]\n\ from-file [to-file]\n", program_name); exit (2); } int main (argc, argv) int argc; char *argv[]; { int c, i, exit_status; struct stat stat_buf[2]; program_name = argv[0]; /* Parse command line options. */ while ((c = getopt_long (argc, argv, "ci:ls", long_options, 0)) != EOF) switch (c) { case 'c': opt_print_chars = 1; break; case 'i': ignore_initial = 0; while (*optarg) { /* Don't use `atol', because `off_t' may be longer than `long'. */ unsigned digit = *optarg++ - '0'; if (9 < digit) usage ("--ignore-initial value must be a nonnegative integer"); ignore_initial = 10 * ignore_initial + digit; } break; case 'l': comparison_type = type_all_diffs; break; case 's': comparison_type = type_status; break; default: usage (0); } if (optind == argc) usage (0); file[0] = argv[optind++]; file[1] = optind < argc ? argv[optind++] : "-"; if (optind < argc) usage ("extra arguments"); for (i = 0; i < 2; i++) { /* If file[1] is "-", treat it first; this avoids a misdiagnostic if stdin is closed and opening file[0] yields file descriptor 0. */ int i1 = i ^ (strcmp (file[1], "-") == 0); /* Two files with the same name are identical. But wait until we open the file once, for proper diagnostics. */ if (i && strcmp (file[0], file[1]) == 0) exit (0); if (strcmp (file[i1], "-") == 0) file_desc[i1] = STDIN_FILENO; else { file_desc[i1] = open (file[i1], O_RDONLY); if (file_desc[i1] < 0) { if (comparison_type == type_status) exit (2); else error (2, errno, "%s", file[i1]); } } if (fstat (file_desc[i1], &stat_buf[i1]) != 0) error (2, errno, "%s", file[i1]); } /* If the files are links to the same inode and have the same file position, they are identical. */ if (stat_buf[0].st_dev == stat_buf[1].st_dev && stat_buf[0].st_ino == stat_buf[1].st_ino && file_position (0) == file_position (1)) exit (0); /* If output is redirected to "/dev/null", we may assume `-s'. */ if (comparison_type != type_status) { struct stat outstat, nullstat; if (fstat (STDOUT_FILENO, &outstat) == 0 && stat ("/dev/null", &nullstat) == 0 && outstat.st_dev == nullstat.st_dev && outstat.st_ino == nullstat.st_ino) comparison_type = type_status; } /* If only a return code is needed, and if both input descriptors are associated with plain files, conclude that the files differ if they have different sizes. */ if (comparison_type == type_status && S_ISREG (stat_buf[0].st_mode) && S_ISREG (stat_buf[1].st_mode)) { off_t s0 = stat_buf[0].st_size - file_position (0); off_t s1 = stat_buf[1].st_size - file_position (1); if (max (0, s0) != max (0, s1)) exit (1); } /* Get the optimal block size of the files. */ buf_size = buffer_lcm (STAT_BLOCKSIZE (stat_buf[0]), STAT_BLOCKSIZE (stat_buf[1])); /* Allocate buffers, with space for sentinels at the end. */ for (i = 0; i < 2; i++) buffer[i] = xmalloc (buf_size + sizeof (long)); exit_status = cmp (); for (i = 0; i < 2; i++) if (close (file_desc[i]) != 0) error (2, errno, "%s", file[i]); if (comparison_type != type_status) { if (ferror (stdout)) error (2, 0, "write error"); else if (fclose (stdout) != 0) error (2, errno, "write error"); } exit (exit_status); return exit_status; } /* Compare the two files already open on `file_desc[0]' and `file_desc[1]', using `buffer[0]' and `buffer[1]'. Return 0 if identical, 1 if different, >1 if error. */ static int cmp () { long line_number = 1; /* Line number (1...) of first difference. */ long char_number = ignore_initial + 1; /* Offset (1...) in files of 1st difference. */ size_t read0, read1; /* Number of chars read from each file. */ size_t first_diff; /* Offset (0...) in buffers of 1st diff. */ size_t smaller; /* The lesser of `read0' and `read1'. */ char *buf0 = buffer[0]; char *buf1 = buffer[1]; int ret = 0; int i; if (ignore_initial) for (i = 0; i < 2; i++) if (file_position (i) == -1) { /* lseek failed; read and discard the ignored initial prefix. */ off_t ig = ignore_initial; do { size_t r = read (file_desc[i], buf0, (size_t) min (ig, buf_size)); if (!r) break; if (r == -1) error (2, errno, "%s", file[i]); ig -= r; } while (ig); } do { read0 = block_read (file_desc[0], buf0, buf_size); if (read0 == -1) error (2, errno, "%s", file[0]); read1 = block_read (file_desc[1], buf1, buf_size); if (read1 == -1) error (2, errno, "%s", file[1]); /* Insert sentinels for the block compare. */ buf0[read0] = ~buf1[read0]; buf1[read1] = ~buf0[read1]; /* If the line number should be written for differing files, compare the blocks and count the number of newlines simultaneously. */ first_diff = (comparison_type == type_first_diff ? block_compare_and_count (buf0, buf1, &line_number) : block_compare (buf0, buf1)); char_number += first_diff; smaller = min (read0, read1); if (first_diff < smaller) { switch (comparison_type) { case type_first_diff: /* See Posix.2 section 4.10.6.1 for this format. */ printf ("%s %s differ: char %ld, line %ld", file[0], file[1], char_number, line_number); if (opt_print_chars) { unsigned char c0 = buf0[first_diff]; unsigned char c1 = buf1[first_diff]; printf (" is %3o ", c0); printc (0, c0); printf (" %3o ", c1); printc (0, c1); } putchar ('\n'); /* Fall through. */ case type_status: return 1; case type_all_diffs: do { unsigned char c0 = buf0[first_diff]; unsigned char c1 = buf1[first_diff]; if (c0 != c1) { if (opt_print_chars) { printf ("%6lu %3o ", char_number, c0); printc (4, c0); printf (" %3o ", c1); printc (0, c1); putchar ('\n'); } else /* See Posix.2 section 4.10.6.1 for this format. */ printf ("%6ld %3o %3o\n", char_number, c0, c1); } char_number++; first_diff++; } while (first_diff < smaller); ret = 1; break; } } if (read0 != read1) { if (comparison_type != type_status) /* See Posix.2 section 4.10.6.2 for this format. */ fprintf (stderr, "cmp: EOF on %s\n", file[read1 < read0]); return 1; } } while (read0 == buf_size); return ret; } /* Compare two blocks of memory P0 and P1 until they differ, and count the number of '\n' occurrences in the common part of P0 and P1. Assumes that P0 and P1 are aligned at long addresses! If the blocks are not guaranteed to be different, put sentinels at the ends of the blocks before calling this function. Return the offset of the first byte that differs. Increment *COUNT by the count of '\n' occurrences. */ static size_t block_compare_and_count (p0, p1, count) char const *p0, *p1; long *count; { long l; /* One word from first buffer. */ long const *l0, *l1; /* Pointers into each buffer. */ char const *c0, *c1; /* Pointers for finding exact address. */ long cnt = 0; /* Number of '\n' occurrences. */ long nnnn; /* Newline, sizeof (long) times. */ int i; l0 = (long const *) p0; l1 = (long const *) p1; nnnn = 0; for (i = 0; i < sizeof (long); i++) nnnn = (nnnn << CHAR_BIT) | '\n'; /* Find the rough position of the first difference by reading long ints, not bytes. */ while ((l = *l0++) == *l1++) { l ^= nnnn; for (i = 0; i < sizeof (long); i++) { cnt += ! (unsigned char) l; l >>= CHAR_BIT; } } /* Find the exact differing position (endianness independent). */ c0 = (char const *) (l0 - 1); c1 = (char const *) (l1 - 1); while (*c0 == *c1) { cnt += *c0 == '\n'; c0++; c1++; } *count += cnt; return c0 - p0; } /* Compare two blocks of memory P0 and P1 until they differ. Assumes that P0 and P1 are aligned at long addresses! If the blocks are not guaranteed to be different, put sentinels at the ends of the blocks before calling this function. Return the offset of the first byte that differs. */ static size_t block_compare (p0, p1) char const *p0, *p1; { long const *l0, *l1; char const *c0, *c1; l0 = (long const *) p0; l1 = (long const *) p1; /* Find the rough position of the first difference by reading long ints, not bytes. */ while (*l0++ == *l1++) ; /* Find the exact differing position (endianness independent). */ c0 = (char const *) (l0 - 1); c1 = (char const *) (l1 - 1); while (*c0 == *c1) { c0++; c1++; } return c0 - p0; } /* Read NCHARS bytes from descriptor FD into BUF. Return the number of characters successfully read. The number returned is always NCHARS unless end-of-file or error. */ static size_t block_read (fd, buf, nchars) int fd; char *buf; size_t nchars; { char *bp = buf; do { size_t nread = read (fd, bp, nchars); if (nread == -1) return -1; if (nread == 0) break; bp += nread; nchars -= nread; } while (nchars != 0); return bp - buf; } /* Print character C, making nonvisible characters visible by quoting like cat -t does. Pad with spaces on the right to WIDTH characters. */ static void printc (width, c) int width; unsigned c; { register FILE *fs = stdout; if (c >= 128) { putc ('M', fs); putc ('-', fs); c -= 128; width -= 2; } if (c < 32) { putc ('^', fs); c += 64; --width; } else if (c == 127) { putc ('^', fs); c = '?'; --width; } putc (c, fs); while (--width > 0) putc (' ', fs); } /* Position file I to `ignore_initial' bytes from its initial position, and yield its new position. Don't try more than once. */ static off_t file_position (i) int i; { static int positioned[2]; static off_t position[2]; if (! positioned[i]) { positioned[i] = 1; position[i] = lseek (file_desc[i], ignore_initial, SEEK_CUR); } return position[i]; } diffutils-2.4/error.c100666 74720 14 5642 5437441106 13552 0ustar eggertguest/* error.c -- error handler for noninteractive utilities Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by David MacKenzie. */ #if HAVE_CONFIG_H #include "config.h" #endif #include #ifdef HAVE_VPRINTF #if __STDC__ #include #define VA_START(args, lastarg) va_start(args, lastarg) #else /* !__STDC__ */ #include #define VA_START(args, lastarg) va_start(args) #endif /* !__STDC__ */ #else /* !HAVE_VPRINTF */ #ifdef HAVE_DOPRNT #define va_alist args #define va_dcl int args; #else /* !HAVE_DOPRNT */ #define va_alist a1, a2, a3, a4, a5, a6, a7, a8 #define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8; #endif /* !HAVE_DOPRNT */ #endif /* !HAVE_VPRINTF */ #ifdef STDC_HEADERS #include #include #else /* !STDC_HEADERS */ void exit (); #endif /* !STDC_HEADERS */ extern char *program_name; #ifndef HAVE_STRERROR static char * private_strerror (errnum) int errnum; { extern char *sys_errlist[]; extern int sys_nerr; if (errnum > 0 && errnum <= sys_nerr) return sys_errlist[errnum]; return "Unknown system error"; } #define strerror private_strerror #endif /* !HAVE_STRERROR */ /* Print the program name and error message MESSAGE, which is a printf-style format string with optional args. If ERRNUM is nonzero, print its corresponding system error message. Exit with status STATUS if it is nonzero. */ /* VARARGS */ void #if defined (HAVE_VPRINTF) && __STDC__ error (int status, int errnum, char *message, ...) #else /* !HAVE_VPRINTF or !__STDC__ */ error (status, errnum, message, va_alist) int status; int errnum; char *message; va_dcl #endif /* !HAVE_VPRINTF or !__STDC__ */ { #ifdef HAVE_VPRINTF va_list args; #endif /* HAVE_VPRINTF */ fprintf (stderr, "%s: ", program_name); #ifdef HAVE_VPRINTF VA_START (args, message); vfprintf (stderr, message, args); va_end (args); #else /* !HAVE_VPRINTF */ #ifdef HAVE_DOPRNT _doprnt (message, &args, stderr); #else /* !HAVE_DOPRNT */ fprintf (stderr, message, a1, a2, a3, a4, a5, a6, a7, a8); #endif /* !HAVE_DOPRNT */ #endif /* !HAVE_VPRINTF */ if (errnum) fprintf (stderr, ": %s", strerror (errnum)); putc ('\n', stderr); fflush (stderr); if (status) exit (status); } diffutils-2.4/xmalloc.c100666 74720 14 3460 5422331765 14057 0ustar eggertguest/* xmalloc.c -- malloc with out of memory checking Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #if HAVE_CONFIG_H #include "config.h" #endif #if __STDC__ #define VOID void #else #define VOID char #endif #if STDC_HEADERS #include #else #include VOID *malloc (); VOID *realloc (); void free (); #endif #if __STDC__ && defined (HAVE_VPRINTF) void error (int, int, char const *, ...); #else void error (); #endif /* Allocate N bytes of memory dynamically, with error checking. */ VOID * xmalloc (n) size_t n; { VOID *p; p = malloc (n); if (p == 0) /* Must exit with 2 for `cmp'. */ error (2, 0, "virtual memory exhausted"); return p; } /* Change the size of an allocated block of memory P to N bytes, with error checking. If P is NULL, run xmalloc. If N is 0, run free and return NULL. */ VOID * xrealloc (p, n) VOID *p; size_t n; { if (p == 0) return xmalloc (n); if (n == 0) { free (p); return 0; } p = realloc (p, n); if (p == 0) /* Must exit with 2 for `cmp'. */ error (2, 0, "virtual memory exhausted"); return p; } diffutils-2.4/getopt.c100666 12120 1 52075 5432543736 13352 0ustar rmsdaemon/* Getopt for GNU. NOTE: getopt is now part of the C library, so if you don't know what "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu before changing it! Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because getopt.c was found in $srcdir). */ #include #endif #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ #ifndef const #define const #endif #endif /* This tells Alpha OSF/1 not to define a getopt prototype in . */ #ifndef _NO_PROTO #define _NO_PROTO #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ #include #endif /* GNU C library. */ /* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a long-named option. Because this is not POSIX.2 compliant, it is being phased out. */ /* #define GETOPT_COMPAT */ /* This version of `getopt' appears to the caller like standard Unix `getopt' but it behaves differently for the user, since it allows the user to intersperse the options with the other arguments. As `getopt' works, it permutes the elements of ARGV so that, when it is done, all the options precede everything else. Thus all application programs are extended to handle flexible argument order. Setting the environment variable POSIXLY_CORRECT disables permutation. Then the behavior is completely standard. GNU application programs can use a third alternative mode in which they can distinguish the relative order of options and other arguments. */ #include "getopt.h" /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ char *optarg = 0; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ /* XXX 1003.2 says this must be 1 before any call. */ int optind = 0; /* The next char to be scanned in the option-element in which the last option character we returned was found. This allows us to pick up the scan where we left off. If this is zero, or a null string, it means resume the scan by advancing to the next ARGV-element. */ static char *nextchar; /* Callers store zero here to inhibit the error message for unrecognized options. */ int opterr = 1; /* Set to an option character which was unrecognized. This must be initialized on some systems to avoid linking in the system's own getopt implementation. */ int optopt = '?'; /* Describe how to deal with options that follow non-option ARGV-elements. If the caller did not specify anything, the default is REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise. REQUIRE_ORDER means don't recognize them as options; stop option processing when the first non-option is seen. This is what Unix does. This mode of operation is selected by either setting the environment variable POSIXLY_CORRECT, or using `+' as the first character of the list of option characters. PERMUTE is the default. We permute the contents of ARGV as we scan, so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. RETURN_IN_ORDER is an option available to programs that were written to expect options and other ARGV-elements in any order and that care about the ordering of the two. We describe each non-option ARGV-element as if it were the argument of an option with character code 1. Using `-' as the first character of the list of option characters selects this mode of operation. The special argument `--' forces an end of option-scanning regardless of the value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause `getopt' to return EOF with `optind' != ARGC. */ static enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering; #ifdef __GNU_LIBRARY__ /* We want to avoid inclusion of string.h with non-GNU libraries because there are many ways it can cause trouble. On some systems, it contains special magic macros that don't work in GCC. */ #include #define my_index strchr #else /* Avoid depending on library functions or files whose names are inconsistent. */ char *getenv (); static char * my_index (str, chr) const char *str; int chr; { while (*str) { if (*str == chr) return (char *) str; str++; } return 0; } /* If using GCC, we can safely declare strlen this way. If not using GCC, it is ok not to declare it. (Supposedly there are some machines where it might get a warning, but changing this conditional to __STDC__ is too risky.) */ #ifdef __GNUC__ #ifdef IN_GCC #include "gstddef.h" #else #include #endif extern size_t strlen (const char *); #endif #endif /* GNU C library. */ /* Handle permutation of arguments. */ /* Describe the part of ARGV that contains non-options that have been skipped. `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is the index after the last of them. */ static int first_nonopt; static int last_nonopt; /* Exchange two adjacent subsequences of ARGV. One subsequence is elements [first_nonopt,last_nonopt) which contains all the non-options that have been skipped so far. The other is elements [last_nonopt,optind), which contains all the options processed since those non-options were skipped. `first_nonopt' and `last_nonopt' are relocated so that they describe the new indices of the non-options in ARGV after they are moved. */ static void exchange (argv) char **argv; { int bottom = first_nonopt; int middle = last_nonopt; int top = optind; char *tem; /* Exchange the shorter segment with the far end of the longer segment. That puts the shorter segment into the right place. It leaves the longer segment in the right place overall, but it consists of two parts that need to be swapped next. */ while (top > middle && middle > bottom) { if (top - middle > middle - bottom) { /* Bottom segment is the short one. */ int len = middle - bottom; register int i; /* Swap it with the top part of the top segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[top - (middle - bottom) + i]; argv[top - (middle - bottom) + i] = tem; } /* Exclude the moved bottom segment from further swapping. */ top -= len; } else { /* Top segment is the short one. */ int len = top - middle; register int i; /* Swap it with the bottom part of the bottom segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[middle + i]; argv[middle + i] = tem; } /* Exclude the moved top segment from further swapping. */ bottom += len; } } /* Update records for the slots the non-options now occupy. */ first_nonopt += (optind - last_nonopt); last_nonopt = optind; } /* Scan elements of ARGV (whose length is ARGC) for option characters given in OPTSTRING. If an element of ARGV starts with '-', and is not exactly "-" or "--", then it is an option element. The characters of this element (aside from the initial '-') are option characters. If `getopt' is called repeatedly, it returns successively each of the option characters from each of the option elements. If `getopt' finds another option character, it returns that character, updating `optind' and `nextchar' so that the next call to `getopt' can resume the scan with the following option character or ARGV-element. If there are no more option characters, `getopt' returns `EOF'. Then `optind' is the index in ARGV of the first ARGV-element that is not an option. (The ARGV-elements have been permuted so that those that are not options now come last.) OPTSTRING is a string containing the legitimate option characters. If an option character is seen that is not listed in OPTSTRING, return '?' after printing an error message. If you set `opterr' to zero, the error message is suppressed but we still return '?'. If a char in OPTSTRING is followed by a colon, that means it wants an arg, so the following text in the same ARGV-element, or the text of the following ARGV-element, is returned in `optarg'. Two colons mean an option that wants an optional arg; if there is text in the current ARGV-element, it is returned in `optarg', otherwise `optarg' is set to zero. If OPTSTRING starts with `-' or `+', it requests different methods of handling the non-option ARGV-elements. See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. Long-named options begin with `--' instead of `-'. Their names may be abbreviated as long as the abbreviation is unique or is an exact match for some defined option. If they have an argument, it follows the option name in the same ARGV-element, separated from the option name by a `=', or else the in next ARGV-element. When `getopt' finds a long-named option, it returns 0 if that option's `flag' field is nonzero, the value of the option's `val' field if the `flag' field is zero. The elements of ARGV aren't really const, because we permute them. But we pretend they're const in the prototype to be compatible with other systems. LONGOPTS is a vector of `struct option' terminated by an element containing a name which is zero. LONGIND returns the index in LONGOPT of the long-named option found. It is only valid when a long-named option has been found by the most recent call. If LONG_ONLY is nonzero, '-' as well as '--' can introduce long-named options. */ int _getopt_internal (argc, argv, optstring, longopts, longind, long_only) int argc; char *const *argv; const char *optstring; const struct option *longopts; int *longind; int long_only; { int option_index; optarg = 0; /* Initialize the internal data when the first call is made. Start processing options with ARGV-element 1 (since ARGV-element 0 is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ if (optind == 0) { first_nonopt = last_nonopt = optind = 1; nextchar = NULL; /* Determine how to handle the ordering of options and nonoptions. */ if (optstring[0] == '-') { ordering = RETURN_IN_ORDER; ++optstring; } else if (optstring[0] == '+') { ordering = REQUIRE_ORDER; ++optstring; } else if (getenv ("POSIXLY_CORRECT") != NULL) ordering = REQUIRE_ORDER; else ordering = PERMUTE; } if (nextchar == NULL || *nextchar == '\0') { if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (last_nonopt != optind) first_nonopt = optind; /* Now skip any additional non-options and extend the range of non-options previously skipped. */ while (optind < argc && (argv[optind][0] != '-' || argv[optind][1] == '\0') #ifdef GETOPT_COMPAT && (longopts == NULL || argv[optind][0] != '+' || argv[optind][1] == '\0') #endif /* GETOPT_COMPAT */ ) optind++; last_nonopt = optind; } /* Special ARGV-element `--' means premature end of options. Skip it like a null option, then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ if (optind != argc && !strcmp (argv[optind], "--")) { optind++; if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (first_nonopt == last_nonopt) first_nonopt = optind; last_nonopt = argc; optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ if (optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) optind = first_nonopt; return EOF; } /* If we have come to a non-option and did not permute it, either stop the scan or describe it to the caller and pass it by. */ if ((argv[optind][0] != '-' || argv[optind][1] == '\0') #ifdef GETOPT_COMPAT && (longopts == NULL || argv[optind][0] != '+' || argv[optind][1] == '\0') #endif /* GETOPT_COMPAT */ ) { if (ordering == REQUIRE_ORDER) return EOF; optarg = argv[optind++]; return 1; } /* We have found another option-ARGV-element. Start decoding its characters. */ nextchar = (argv[optind] + 1 + (longopts != NULL && argv[optind][1] == '-')); } if (longopts != NULL && ((argv[optind][0] == '-' && (argv[optind][1] == '-' || long_only)) #ifdef GETOPT_COMPAT || argv[optind][0] == '+' #endif /* GETOPT_COMPAT */ )) { const struct option *p; char *s = nextchar; int exact = 0; int ambig = 0; const struct option *pfound = NULL; int indfound; while (*s && *s != '=') s++; /* Test all options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, s - nextchar)) { if (s - nextchar == strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (opterr) fprintf (stderr, "%s: option `%s' is ambiguous\n", argv[0], argv[optind]); nextchar += strlen (nextchar); optind++; return '?'; } if (pfound != NULL) { option_index = indfound; optind++; if (*s) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = s + 1; else { if (opterr) { if (argv[optind - 1][1] == '-') /* --option */ fprintf (stderr, "%s: option `--%s' doesn't allow an argument\n", argv[0], pfound->name); else /* +option or -option */ fprintf (stderr, "%s: option `%c%s' doesn't allow an argument\n", argv[0], argv[optind - 1][0], pfound->name); } nextchar += strlen (nextchar); return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (opterr) fprintf (stderr, "%s: option `%s' requires an argument\n", argv[0], argv[optind - 1]); nextchar += strlen (nextchar); return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } /* Can't find it as a long option. If this is not getopt_long_only, or the option starts with '--' or is not a valid short option, then it's an error. Otherwise interpret it as a short option. */ if (!long_only || argv[optind][1] == '-' #ifdef GETOPT_COMPAT || argv[optind][0] == '+' #endif /* GETOPT_COMPAT */ || my_index (optstring, *nextchar) == NULL) { if (opterr) { if (argv[optind][1] == '-') /* --option */ fprintf (stderr, "%s: unrecognized option `--%s'\n", argv[0], nextchar); else /* +option or -option */ fprintf (stderr, "%s: unrecognized option `%c%s'\n", argv[0], argv[optind][0], nextchar); } nextchar = (char *) ""; optind++; return '?'; } } /* Look at and handle the next option-character. */ { char c = *nextchar++; char *temp = my_index (optstring, c); /* Increment `optind' when we start to process its last character. */ if (*nextchar == '\0') ++optind; if (temp == NULL || c == ':') { if (opterr) { #if 0 if (c < 040 || c >= 0177) fprintf (stderr, "%s: unrecognized option, character code 0%o\n", argv[0], c); else fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c); #else /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c); #endif } optopt = c; return '?'; } if (temp[1] == ':') { if (temp[2] == ':') { /* This is an option that accepts an argument optionally. */ if (*nextchar != '\0') { optarg = nextchar; optind++; } else optarg = 0; nextchar = NULL; } else { /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (opterr) { #if 0 fprintf (stderr, "%s: option `-%c' requires an argument\n", argv[0], c); #else /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: option requires an argument -- %c\n", argv[0], c); #endif } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; nextchar = NULL; } } return c; } } int getopt (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { return _getopt_internal (argc, argv, optstring, (const struct option *) 0, (int *) 0, 0); } #endif /* _LIBC or not __GNU_LIBRARY__. */ #ifdef TEST /* Compile with -DTEST to make an executable for use in testing the above definition of `getopt'. */ int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; c = getopt (argc, argv, "abc:d:0123456789"); if (c == EOF) break; switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ diffutils-2.4/getopt1.c100666 21570 13 10520 5432543734 13136 0ustar djmuser/* getopt_long and getopt_long_only entry points for GNU getopt. Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because getopt1.c was found in $srcdir). */ #include #endif #include "getopt.h" #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ #ifndef const #define const #endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ #include #else char *getenv (); #endif #ifndef NULL #define NULL 0 #endif int getopt_long (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 0); } /* Like getopt_long, but '-' as well as '--' can indicate a long option. If an option that starts with '-' (not '--') doesn't match a long option, but does match a short option, it is parsed as a short option instead. */ int getopt_long_only (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 1); } #endif /* _LIBC or not __GNU_LIBRARY__. */ #ifdef TEST #include int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; int option_index = 0; static struct option long_options[] = { {"add", 1, 0, 0}, {"append", 0, 0, 0}, {"delete", 1, 0, 0}, {"verbose", 0, 0, 0}, {"create", 0, 0, 0}, {"file", 1, 0, 0}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "abc:d:0123456789", long_options, &option_index); if (c == EOF) break; switch (c) { case 0: printf ("option %s", long_options[option_index].name); if (optarg) printf (" with arg %s", optarg); printf ("\n"); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case 'd': printf ("option d with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ diffutils-2.4/getopt.h100666 12241 1 10474 5372534261 14032 0ustar rolanddaemon/* Declarations for getopt. Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _GETOPT_H #define _GETOPT_H 1 #ifdef __cplusplus extern "C" { #endif /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ extern char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ extern int optind; /* Callers store zero here to inhibit the error message `getopt' prints for unrecognized options. */ extern int opterr; /* Set to an option character which was unrecognized. */ extern int optopt; /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector of `struct option' terminated by an element containing a name which is zero. The field `has_arg' is: no_argument (or 0) if the option does not take an argument, required_argument (or 1) if the option requires an argument, optional_argument (or 2) if the option takes an optional argument. If the field `flag' is not NULL, it points to a variable that is set to the value given in the field `val' when the option is found, but left unchanged if the option is not found. To have a long-named option do something other than set an `int' to a compiled-in constant, such as set a value from `optarg', set the option's `flag' field to zero and its `val' field to a nonzero value (the equivalent single-letter option character, if there is one). For long options that have a zero `flag' field, `getopt' returns the contents of the `val' field. */ struct option { #if __STDC__ const char *name; #else char *name; #endif /* has_arg can't be an enum because some compilers complain about type mismatches in all the code that assumes it is an int. */ int has_arg; int *flag; int val; }; /* Names for the values of the `has_arg' field of `struct option'. */ #define no_argument 0 #define required_argument 1 #define optional_argument 2 #if __STDC__ #if defined(__GNU_LIBRARY__) /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation errors, only prototype getopt for the GNU C library. */ extern int getopt (int argc, char *const *argv, const char *shortopts); #else /* not __GNU_LIBRARY__ */ extern int getopt (); #endif /* not __GNU_LIBRARY__ */ extern int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); extern int getopt_long_only (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); /* Internal only. Users should not call this directly. */ extern int _getopt_internal (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind, int long_only); #else /* not __STDC__ */ extern int getopt (); extern int getopt_long (); extern int getopt_long_only (); extern int _getopt_internal (); #endif /* not __STDC__ */ #ifdef __cplusplus } #endif #endif /* _GETOPT_H */ diffutils-2.4/alloca.c100666 12120 1 33212 5444000351 13253 0ustar rmsdaemon/* alloca.c -- allocate automatically reclaimed memory (Mostly) portable public-domain implementation -- D A Gwyn This implementation of the PWB library alloca function, which is used to allocate space off the run-time stack so that it is automatically reclaimed upon procedure exit, was inspired by discussions with J. Q. Johnson of Cornell. J.Otto Tennant contributed the Cray support. There are some preprocessor constants that can be defined when compiling for your specific system, for improved efficiency; however, the defaults should be okay. The general concept of this implementation is to keep track of all alloca-allocated blocks, and reclaim any that are found to be deeper in the stack than the current invocation. This heuristic does not reclaim storage as soon as it becomes invalid, but it will do so eventually. As a special case, alloca(0) reclaims storage without allocating any. It is a good idea to use alloca(0) in your main control loop, etc. to force garbage collection. */ #ifdef HAVE_CONFIG_H #include #endif /* If compiling with GCC 2, this file's not needed. */ #if !defined (__GNUC__) || __GNUC__ < 2 /* If someone has defined alloca as a macro, there must be some other way alloca is supposed to work. */ #ifndef alloca #ifdef emacs #ifdef static /* actually, only want this if static is defined as "" -- this is for usg, in which emacs must undefine static in order to make unexec workable */ #ifndef STACK_DIRECTION you lose -- must know STACK_DIRECTION at compile-time #endif /* STACK_DIRECTION undefined */ #endif /* static */ #endif /* emacs */ /* If your stack is a linked list of frames, you have to provide an "address metric" ADDRESS_FUNCTION macro. */ #if defined (CRAY) && defined (CRAY_STACKSEG_END) long i00afunc (); #define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg)) #else #define ADDRESS_FUNCTION(arg) &(arg) #endif #if __STDC__ typedef void *pointer; #else typedef char *pointer; #endif #define NULL 0 /* Different portions of Emacs need to call different versions of malloc. The Emacs executable needs alloca to call xmalloc, because ordinary malloc isn't protected from input signals. On the other hand, the utilities in lib-src need alloca to call malloc; some of them are very simple, and don't have an xmalloc routine. Non-Emacs programs expect this to call use xmalloc. Callers below should use malloc. */ #ifndef emacs #define malloc xmalloc #endif extern pointer malloc (); /* Define STACK_DIRECTION if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #ifndef STACK_DIRECTION #define STACK_DIRECTION 0 /* Direction unknown. */ #endif #if STACK_DIRECTION != 0 #define STACK_DIR STACK_DIRECTION /* Known at compile-time. */ #else /* STACK_DIRECTION == 0; need run-time code. */ static int stack_dir; /* 1 or -1 once known. */ #define STACK_DIR stack_dir static void find_stack_direction () { static char *addr = NULL; /* Address of first `dummy', once known. */ auto char dummy; /* To get stack address. */ if (addr == NULL) { /* Initial entry. */ addr = ADDRESS_FUNCTION (dummy); find_stack_direction (); /* Recurse once. */ } else { /* Second entry. */ if (ADDRESS_FUNCTION (dummy) > addr) stack_dir = 1; /* Stack grew upward. */ else stack_dir = -1; /* Stack grew downward. */ } } #endif /* STACK_DIRECTION == 0 */ /* An "alloca header" is used to: (a) chain together all alloca'ed blocks; (b) keep track of stack depth. It is very important that sizeof(header) agree with malloc alignment chunk size. The following default should work okay. */ #ifndef ALIGN_SIZE #define ALIGN_SIZE sizeof(double) #endif typedef union hdr { char align[ALIGN_SIZE]; /* To force sizeof(header). */ struct { union hdr *next; /* For chaining headers. */ char *deep; /* For stack depth measure. */ } h; } header; static header *last_alloca_header = NULL; /* -> last alloca header. */ /* Return a pointer to at least SIZE bytes of storage, which will be automatically reclaimed upon exit from the procedure that called alloca. Originally, this space was supposed to be taken from the current stack frame of the caller, but that method cannot be made to work for some implementations of C, for example under Gould's UTX/32. */ pointer alloca (size) unsigned size; { auto char probe; /* Probes stack depth: */ register char *depth = ADDRESS_FUNCTION (probe); #if STACK_DIRECTION == 0 if (STACK_DIR == 0) /* Unknown growth direction. */ find_stack_direction (); #endif /* Reclaim garbage, defined as all alloca'd storage that was allocated from deeper in the stack than currently. */ { register header *hp; /* Traverses linked list. */ for (hp = last_alloca_header; hp != NULL;) if ((STACK_DIR > 0 && hp->h.deep > depth) || (STACK_DIR < 0 && hp->h.deep < depth)) { register header *np = hp->h.next; free ((pointer) hp); /* Collect garbage. */ hp = np; /* -> next header. */ } else break; /* Rest are not deeper. */ last_alloca_header = hp; /* -> last valid storage. */ } if (size == 0) return NULL; /* No allocation required. */ /* Allocate combined header + user data storage. */ { register pointer new = malloc (sizeof (header) + size); /* Address of header. */ ((header *) new)->h.next = last_alloca_header; ((header *) new)->h.deep = depth; last_alloca_header = (header *) new; /* User storage begins just after header. */ return (pointer) ((char *) new + sizeof (header)); } } #if defined (CRAY) && defined (CRAY_STACKSEG_END) #ifdef DEBUG_I00AFUNC #include #endif #ifndef CRAY_STACK #define CRAY_STACK #ifndef CRAY2 /* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */ struct stack_control_header { long shgrow:32; /* Number of times stack has grown. */ long shaseg:32; /* Size of increments to stack. */ long shhwm:32; /* High water mark of stack. */ long shsize:32; /* Current size of stack (all segments). */ }; /* The stack segment linkage control information occurs at the high-address end of a stack segment. (The stack grows from low addresses to high addresses.) The initial part of the stack segment linkage control information is 0200 (octal) words. This provides for register storage for the routine which overflows the stack. */ struct stack_segment_linkage { long ss[0200]; /* 0200 overflow words. */ long sssize:32; /* Number of words in this segment. */ long ssbase:32; /* Offset to stack base. */ long:32; long sspseg:32; /* Offset to linkage control of previous segment of stack. */ long:32; long sstcpt:32; /* Pointer to task common address block. */ long sscsnm; /* Private control structure number for microtasking. */ long ssusr1; /* Reserved for user. */ long ssusr2; /* Reserved for user. */ long sstpid; /* Process ID for pid based multi-tasking. */ long ssgvup; /* Pointer to multitasking thread giveup. */ long sscray[7]; /* Reserved for Cray Research. */ long ssa0; long ssa1; long ssa2; long ssa3; long ssa4; long ssa5; long ssa6; long ssa7; long sss0; long sss1; long sss2; long sss3; long sss4; long sss5; long sss6; long sss7; }; #else /* CRAY2 */ /* The following structure defines the vector of words returned by the STKSTAT library routine. */ struct stk_stat { long now; /* Current total stack size. */ long maxc; /* Amount of contiguous space which would be required to satisfy the maximum stack demand to date. */ long high_water; /* Stack high-water mark. */ long overflows; /* Number of stack overflow ($STKOFEN) calls. */ long hits; /* Number of internal buffer hits. */ long extends; /* Number of block extensions. */ long stko_mallocs; /* Block allocations by $STKOFEN. */ long underflows; /* Number of stack underflow calls ($STKRETN). */ long stko_free; /* Number of deallocations by $STKRETN. */ long stkm_free; /* Number of deallocations by $STKMRET. */ long segments; /* Current number of stack segments. */ long maxs; /* Maximum number of stack segments so far. */ long pad_size; /* Stack pad size. */ long current_address; /* Current stack segment address. */ long current_size; /* Current stack segment size. This number is actually corrupted by STKSTAT to include the fifteen word trailer area. */ long initial_address; /* Address of initial segment. */ long initial_size; /* Size of initial segment. */ }; /* The following structure describes the data structure which trails any stack segment. I think that the description in 'asdef' is out of date. I only describe the parts that I am sure about. */ struct stk_trailer { long this_address; /* Address of this block. */ long this_size; /* Size of this block (does not include this trailer). */ long unknown2; long unknown3; long link; /* Address of trailer block of previous segment. */ long unknown5; long unknown6; long unknown7; long unknown8; long unknown9; long unknown10; long unknown11; long unknown12; long unknown13; long unknown14; }; #endif /* CRAY2 */ #endif /* not CRAY_STACK */ #ifdef CRAY2 /* Determine a "stack measure" for an arbitrary ADDRESS. I doubt that "lint" will like this much. */ static long i00afunc (long *address) { struct stk_stat status; struct stk_trailer *trailer; long *block, size; long result = 0; /* We want to iterate through all of the segments. The first step is to get the stack status structure. We could do this more quickly and more directly, perhaps, by referencing the $LM00 common block, but I know that this works. */ STKSTAT (&status); /* Set up the iteration. */ trailer = (struct stk_trailer *) (status.current_address + status.current_size - 15); /* There must be at least one stack segment. Therefore it is a fatal error if "trailer" is null. */ if (trailer == 0) abort (); /* Discard segments that do not contain our argument address. */ while (trailer != 0) { block = (long *) trailer->this_address; size = trailer->this_size; if (block == 0 || size == 0) abort (); trailer = (struct stk_trailer *) trailer->link; if ((block <= address) && (address < (block + size))) break; } /* Set the result to the offset in this segment and add the sizes of all predecessor segments. */ result = address - block; if (trailer == 0) { return result; } do { if (trailer->this_size <= 0) abort (); result += trailer->this_size; trailer = (struct stk_trailer *) trailer->link; } while (trailer != 0); /* We are done. Note that if you present a bogus address (one not in any segment), you will get a different number back, formed from subtracting the address of the first block. This is probably not what you want. */ return (result); } #else /* not CRAY2 */ /* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP. Determine the number of the cell within the stack, given the address of the cell. The purpose of this routine is to linearize, in some sense, stack addresses for alloca. */ static long i00afunc (long address) { long stkl = 0; long size, pseg, this_segment, stack; long result = 0; struct stack_segment_linkage *ssptr; /* Register B67 contains the address of the end of the current stack segment. If you (as a subprogram) store your registers on the stack and find that you are past the contents of B67, you have overflowed the segment. B67 also points to the stack segment linkage control area, which is what we are really interested in. */ stkl = CRAY_STACKSEG_END (); ssptr = (struct stack_segment_linkage *) stkl; /* If one subtracts 'size' from the end of the segment, one has the address of the first word of the segment. If this is not the first segment, 'pseg' will be nonzero. */ pseg = ssptr->sspseg; size = ssptr->sssize; this_segment = stkl - size; /* It is possible that calling this routine itself caused a stack overflow. Discard stack segments which do not contain the target address. */ while (!(this_segment <= address && address <= stkl)) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl); #endif if (pseg == 0) break; stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; this_segment = stkl - size; } result = address - this_segment; /* If you subtract pseg from the current end of the stack, you get the address of the previous stack segment's end. This seems a little convoluted to me, but I'll bet you save a cycle somewhere. */ while (pseg != 0) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o\n", pseg, size); #endif stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; result += size; } return (result); } #endif /* not CRAY2 */ #endif /* CRAY */ #endif /* no alloca */ #endif /* not GCC version 2 */ diffutils-2.4/README100666 21570 13 650 5255257660 12235 0ustar djmuserThis directory contains the GNU diff, diff3, sdiff, and cmp utilities. Their features are a superset of the Unix features and they are significantly faster. cmp has been moved here from the GNU textutils. See the file COPYING for copying conditions. See the file diff.texi (or diff.info*) for documentation. See the file INSTALL for compilation and installation instructions. Report bugs to bug-gnu-utils@prep.ai.mit.edu diffutils-2.4/INSTALL100666 21570 13 12335 5445717646 12457 0ustar djmuser This is a generic INSTALL file for utilities distributions. If this package does not come with, e.g., installable documentation or data files, please ignore the references to them below. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation, and creates the Makefile(s) (one in each subdirectory of the source directory). In some packages it creates a C header file containing system-dependent definitions. It also creates a file `config.status' that you can run in the future to recreate the current configuration. To compile this package: 1. Configure the package for your system. Normally, you just `cd' to the directory containing the package's source code and type `./configure'. If you're using `csh' on an old version of System V, you might need to type `sh configure' instead to prevent `csh' from trying to execute `configure' itself. Running `configure' takes a minute or two. While it is running, it prints some messages that tell what it is doing. If you don't want to see the messages, run `configure' with its standard output redirected to `/dev/null'; for example, `./configure >/dev/null'. To compile the package in a different directory from the one containing the source code, you must use a version of `make' that supports the `VPATH' variable, such as GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. If for some reason `configure' is not in the source code directory that you are configuring, then it will report that it can't find the source code. In that case, run `configure' with the option `--srcdir=DIR', where DIR is the directory that contains the source code. By default, `make install' will install the package's files in `/usr/local/bin', `/usr/local/man', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PATH'. Alternately, you can do so by consistently giving a value for the `prefix' variable when you run `make', e.g., make prefix=/usr/gnu make prefix=/usr/gnu install You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PATH' or set the `make' variable `exec_prefix' to PATH, the package will use PATH as the prefix for installing programs and libraries. Data files and documentation will still use the regular prefix. Normally, all files are installed using the same prefix. Some packages pay attention to `--with-PACKAGE' options to `configure', where PACKAGE is something like `gnu-as' or `x' (for the X Window System). The README should mention any `--with-' options that the package recognizes. `configure' ignores any other arguments that you give it. On systems that require unusual options for compilation or linking that the package's `configure' script does not know about, you can give `configure' initial values for variables by setting them in the environment. In Bourne-compatible shells, you can do that on the command line like this: CC='gcc -traditional' LIBS=-lposix ./configure Here are the `make' variables that you might want to override with environment variables when running `configure'. For these variables, any value given in the environment overrides the value that `configure' would choose: - Variable: CC C compiler program. The default is `cc'. - Variable: INSTALL Program to use to install files. The default is `install' if you have it, `cp' otherwise. For these variables, any value given in the environment is added to the value that `configure' chooses: - Variable: DEFS Configuration options, in the form `-Dfoo -Dbar...'. Do not use this variable in packages that create a configuration header file. - Variable: LIBS Libraries to link with, in the form `-lfoo -lbar...'. If you need to do unusual things to compile the package, we encourage you to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the README so we can include them in the next release. 2. Type `make' to compile the package. If you want, you can override the `make' variables CFLAGS and LDFLAGS like this: make CFLAGS=-O2 LDFLAGS=-s 3. If the package comes with self-tests and you want to run them, type `make check'. If you're not sure whether there are any, try it; if `make' responds with something like make: *** No way to make target `check'. Stop. then the package does not come with self-tests. 4. Type `make install' to install programs, data files, and documentation. 5. You can remove the program binaries and object files from the source directory by typing `make clean'. To also remove the Makefile(s), the header file containing system-dependent definitions (if the package uses one), and `config.status' (all the files that `configure' created), type `make distclean'. The file `configure.in' is used to create `configure' by a program called `autoconf'. You only need it if you want to regenerate `configure' using a newer version of `autoconf'. diffutils-2.4/NEWS100666 74720 14 10032 5445364005 12762 0ustar eggertguestUser-visible changes in version 2.4: * New cmp option: --ignore-initial=BYTES * New diff3 option: -T --initial-tab * New diff option: --line-format=FORMAT * New diff group format specifications: [eflmnEFLMN] A printf spec followed by one of the following letters causes the integer corresponding to that letter to be printed according to the printf specification. E.g. `%5df' prints the number of the first line in the group in the old file using the "%5d" format. e: line number just before the group in old file; equals f - 1 f: first line number in group in the old file l: last line number in group in the old file m: line number just after the group in old file; equals l + 1 n: number of lines in group in the old file; equals l - f + 1 E, F, L, M, N: likewise, for lines in the new file %(A=B?T:E) If A equals B then T else E. A and B are each either a decimal constant or a single letter interpreted as above. T and E are arbitrary format strings. This format spec is equivalent to T if A's value equals B's; otherwise it is equivalent to E. For example, `%(N=0?no:%dN) line%(N=1?:s)' is equivalent to `no lines' if N (the number of lines in the group in the the new file) is 0, to `1 line' if N is 1, and to `%dN lines' otherwise. %c'C' where C is a single character, stands for the character C. C may not be a backslash or an apostrophe. E.g. %c':' stands for a colon. %c'\O' where O is a string of 1, 2, or 3 octal digits, stands for the character with octal code O. E.g. %c'\0' stands for a null character. * New diff line format specifications: n The line number, printed with . E.g. `%5dn' prints the line number with a "%5d" format. %c'C' %c'\O' The character C, or with octal code O, as above. * Supported s have the same meaning as with printf, but must match the extended regular expression %-*[0-9]*(\.[0-9]*)?[doxX]. * The format spec %0 introduced in version 2.1 has been removed, since it is incompatible with printf specs like %02d. To represent a null char, use %c'\0' instead. * cmp and diff now conform to Posix.2 (ISO/IEC 9945-2:1993) if the underlying system conforms to Posix: - Some messages' wordings are changed in minor ways. - ``White space'' is now whatever C's `isspace' says it is. - When comparing directories, if `diff' finds a file that is not a regular file or a directory, it reports the file's type instead of diffing it. (As usual, it follows symbolic links first.) - When signaled, sdiff exits with the signal's status, not with status 2. * Now portable to hosts where int, long, pointer, etc. are not all the same size. * `cmp - -' now works like `diff - -'. User-visible changes in version 2.3: * New diff option: --horizon-lines=lines User-visible changes in version 2.1: * New diff options: --{old,new,unchanged}-line-format='format' --{old,new,unchanged,changed}-group-format='format' -U * New diff3 option: -A --show-all * diff3 -m now defaults to -A, not -E. * diff3 now takes up to three -L or --label options, not just two. If just two options are given, they refer to the first two input files, not the first and third input files. * sdiff and diff -y handle incomplete lines. User-visible changes in version 2.0: * Add sdiff and cmp programs. * Add Texinfo documentation. * Add configure script. * Improve diff performance. * New diff options: -x --exclude -X --exclude-from -P --unidirectional-new-file -W --width -y --side-by-side --left-column --sdiff-merge-assist --suppress-common-lines * diff options renamed: --label renamed from --file-label --forward-ed renamed from --reversed-ed --paginate renamed from --print --entire-new-file renamed from --entire-new-files --new-file renamed from --new-files --all-text removed * New diff3 options: -v --version * Add long-named equivalents for other diff3 options. * diff options -F (--show-function-line) and -I (--ignore-matching-lines) can now be given more than once. diffutils-2.4/diagmeet.note100644 21623 1 2055 4741735212 14267 0ustar mibdaemonHere is a comparison matrix which shows a case in which it is possible for the forward and backward scan in `diag' to meet along a nonzero length of diagonal simultaneous (so that bdiag[d] and fdiag[d] are not equal) even though there is no snake on that diagonal at the meeting point. 85 1 1 1 159 1 1 17 1 2 3 4 60 1 2 1 2 2 3 4 71 3 3 4 5 85 4 3 4 5 17 5 4 5 1 6 4 5 6 183 7 5 6 7 10 8 6 7 1 9 6 7 8 12 7 8 9 10 13 10 8 9 10 14 10 9 10 17 10 10 1 10 9 10 1 8 10 10 10 183 8 7 9 9 9 10 7 6 8 9 8 8 1 6 5 7 7 1 5 6 6 1 5 5 5 50 5 4 4 4 1 4 3 3 85 5 4 3 2 2 1 2 1 17 5 4 3 2 1 1 1 1 0 85 1 1 1 159 1 1 17 diffutils-2.4/Makefile.in100444 74720 14 10474 5445446662 14346 0ustar eggertguest# Makefile for GNU DIFF # Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. # # This file is part of GNU DIFF. # # GNU DIFF is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # GNU DIFF is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with GNU DIFF; see the file COPYING. If not, write to # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. #### Start of system configuration section. #### srcdir = @srcdir@ VPATH = @srcdir@ CC = @CC@ INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_DATA = @INSTALL_DATA@ MAKEINFO = makeinfo CFLAGS = -g LDFLAGS = -g LIBS = @LIBS@ # Some System V machines do not come with libPW. # If this is true for you, use the GNU alloca.o here. ALLOCA = @ALLOCA@ prefix = /usr/local exec_prefix = $(prefix) # Prefix for each installed program, normally empty or `g'. binprefix = bindir = $(exec_prefix)/bin infodir = $(prefix)/info #### End of system configuration section. #### SHELL = /bin/sh # The source files for all of the programs. srcs=diff.c analyze.c cmpbuf.c cmpbuf.h io.c context.c ed.c normal.c ifdef.c \ util.c dir.c \ version.c diff.h regex.c regex.h side.c system.h \ diff3.c sdiff.c cmp.c error.c xmalloc.c getopt.c getopt1.c getopt.h \ fnmatch.c fnmatch.h alloca.c # Object files for diff only. objs=diff.o analyze.o cmpbuf.o io.o context.o \ ed.o normal.o util.o dir.o fnmatch.o \ regex.o side.o ifdef.o version.o \ getopt.o getopt1.o $(ALLOCA) distfiles = $(srcs) README INSTALL NEWS diagmeet.note Makefile.in \ config.h.in configure configure.in COPYING ChangeLog \ diff.texi diff.info* texinfo.tex \ mkinstalldirs all: diff diff3 sdiff cmp diff.info COMPILE = $(CC) -c -DHAVE_CONFIG_H $(CPPFLAGS) -I. -I$(srcdir) $(CFLAGS) .c.o: $(COMPILE) $< diff: $(objs) $(CC) -o $@ $(LDFLAGS) $(objs) $(LIBS) diff3: diff3.o getopt.o getopt1.o version.o $(ALLOCA) $(CC) -o $@ $(LDFLAGS) diff3.o getopt.o getopt1.o version.o $(ALLOCA) $(LIBS) sdiff: sdiff.o getopt.o getopt1.o version.o $(ALLOCA) $(CC) -o $@ $(LDFLAGS) sdiff.o getopt.o getopt1.o version.o $(ALLOCA) $(LIBS) cmp: cmp.o cmpbuf.o getopt.o getopt1.o error.o xmalloc.o $(ALLOCA) $(CC) -o $@ $(LDFLAGS) cmp.o cmpbuf.o getopt.o getopt1.o error.o xmalloc.o $(ALLOCA) $(LIBS) diff.info: diff.texi $(MAKEINFO) $(srcdir)/diff.texi $(objs): diff.h system.h cmp.o diff3.o sdiff.o: system.h context.o diff.o regex.o: regex.h cmp.o diff.o diff3.o sdiff.o getopt.o getopt1.o: getopt.h diff.o fnmatch.o: fnmatch.h analyze.o cmpbuf.o cmp.o: cmpbuf.h diff3.o: diff3.c $(COMPILE) -DDIFF_PROGRAM=\"$(bindir)/$(binprefix)diff\" $(srcdir)/diff3.c sdiff.o: sdiff.c $(COMPILE) -DDIFF_PROGRAM=\"$(bindir)/$(binprefix)diff\" $(srcdir)/sdiff.c TAGS: $(srcs) etags $(srcs) clean: rm -f *.o diff diff3 sdiff cmp core mostlyclean: clean distclean: clean rm -f Makefile config.status realclean: distclean rm -f TAGS *.info* install: all installdirs for p in diff diff3 sdiff cmp; \ do $(INSTALL_PROGRAM) $$p $(bindir)/$(binprefix)$$p; done cd $(srcdir); for f in diff.info*; \ do $(INSTALL_DATA) $$f $(infodir)/$$f; done installdirs: $(SHELL) ${srcdir}/mkinstalldirs $(bindir) $(infodir) uninstall: for p in diff diff3 sdiff cmp; \ do rm -f $(bindir)/$(binprefix)$$p; done rm -f $(infodir)/diff.info* Makefile: Makefile.in config.status $(SHELL) config.status config.status: configure $(SHELL) $(srcdir)/configure --no-create configure: configure.in cd $(srcdir); autoconf config.h.in: configure.in cd $(srcdir); autoheader dist: $(distfiles) echo diffutils-`sed -e '/version_string/!d' -e 's/[^0-9]*\([0-9a-z.]*\).*/\1/' -e q version.c` > .fname rm -rf `cat .fname` mkdir `cat .fname` -ln $(distfiles) `cat .fname` for file in $(distfiles); do \ [ -r `cat .fname`/$$file ] || cp -p $$file `cat .fname` || exit; \ done tar -chf - `cat .fname` | gzip >`cat .fname`.tar.gz rm -rf `cat .fname` .fname # Prevent GNU make v3 from overflowing arg limit on SysV. .NOEXPORT: diffutils-2.4/config.h.in100666 74720 14 5367 5444435371 14311 0ustar eggertguest/* config.h.in. Generated automatically from configure.in by autoheader. */ /* Define if using alloca.c. */ #undef C_ALLOCA /* Define to empty if the keyword does not work. */ #undef const /* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. This function is required for alloca.c support on those systems. */ #undef CRAY_STACKSEG_END /* Define if you have dirent.h. */ #undef DIRENT /* Define if you have alloca.h and it should be used (not Ultrix). */ #undef HAVE_ALLOCA_H /* Define if you don't have vprintf but do have _doprnt. */ #undef HAVE_DOPRNT /* Define if your struct stat has st_blksize. */ #undef HAVE_ST_BLKSIZE /* Define if you have unistd.h. */ #undef HAVE_UNISTD_H /* Define if you have vfork.h. */ #undef HAVE_VFORK_H /* Define if you have the vprintf function. */ #undef HAVE_VPRINTF /* Define if on MINIX. */ #undef _MINIX /* Define if you don't have dirent.h, but have ndir.h. */ #undef NDIR /* Define to `int' if doesn't define. */ #undef pid_t /* Define if the system does not provide POSIX.1 features except with this defined. */ #undef _POSIX_1_SOURCE /* Define if you need to in order for stat and other things to work. */ #undef _POSIX_SOURCE /* Define as the return type of signal handlers (int or void). */ #undef RETSIGTYPE /* If using the C implementation of alloca, define if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #undef STACK_DIRECTION /* Define if you have the ANSI C header files. */ #undef STDC_HEADERS /* Define if you don't have dirent.h, but have sys/dir.h. */ #undef SYSDIR /* Define if you don't have dirent.h, but have sys/ndir.h. */ #undef SYSNDIR /* Define vfork as fork if vfork does not work. */ #undef vfork /* Define if the closedir function returns void instead of int. */ #undef VOID_CLOSEDIR /* Define if you have dup2. */ #undef HAVE_DUP2 /* Define if you have memchr. */ #undef HAVE_MEMCHR /* Define if you have sigaction. */ #undef HAVE_SIGACTION /* Define if you have strerror. */ #undef HAVE_STRERROR /* Define if you have waitpid. */ #undef HAVE_WAITPID /* Define if you have the header file. */ #undef HAVE_FCNTL_H /* Define if you have the header file. */ #undef HAVE_LIMITS_H /* Define if you have the header file. */ #undef HAVE_STDLIB_H /* Define if you have the header file. */ #undef HAVE_STRING_H /* Define if you have the header file. */ #undef HAVE_SYS_WAIT_H /* Define if you have the header file. */ #undef HAVE_TIME_H diffutils-2.4/configure100777 74720 14 112340 5444434225 14220 0ustar eggertguest#!/bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf. # Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp] [--no-create] # [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE[=VALUE]] # Ignores all args except --srcdir, --prefix, --exec-prefix, --no-create, and # --with-PACKAGE[=VALUE] unless this script has special code to handle it. for arg do # Handle --exec-prefix with a space before the argument. if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix= # Handle --host with a space before the argument. elif test x$next_host = xyes; then next_host= # Handle --prefix with a space before the argument. elif test x$next_prefix = xyes; then prefix=$arg; next_prefix= # Handle --srcdir with a space before the argument. elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir= else case $arg in # For backward compatibility, also recognize exact -exec_prefix. -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*) exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e) next_exec_prefix=yes ;; -gas | --gas | --ga | --g) ;; -host=* | --host=* | --hos=* | --ho=* | --h=*) ;; -host | --host | --hos | --ho | --h) next_host=yes ;; -nfp | --nfp | --nf) ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre | --no-cr | --no-c | --no- | --no) no_create=1 ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) next_prefix=yes ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*) srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s) next_srcdir=yes ;; -with-* | --with-*) package=`echo $arg|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $package| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $package: invalid package name" >&2; exit 1 fi package=`echo $package| sed 's/-/_/g'` case "$arg" in *=*) val="`echo $arg|sed 's/[^=]*=//'`" ;; *) val=1 ;; esac eval "with_$package='$val'" ;; -v | -verbose | --verbose | --verbos | --verbo | --verb | --ver | --ve | --v) verbose=yes ;; *) ;; esac fi done trap 'rm -fr conftest* core; exit 1' 1 3 15 # NLS nuisances. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = 'set' ; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = 'set' ; then LANG=C; export LANG; fi rm -f conftest* confdefs.h > confdefs.h compile='${CC-cc} $CFLAGS conftest.c -o conftest $LIBS >/dev/null 2>&1' # A filename unique to this package, relative to the directory that # configure is in, which we can look for to find out if srcdir is correct. unique_file=diff.h # Find the source files, if location was not specified. if test -z "$srcdir"; then srcdirdefaulted=yes # Try the directory containing this script, then `..'. prog=$0 confdir=`echo $prog|sed 's%/[^/][^/]*$%%'` test "X$confdir" = "X$prog" && confdir=. srcdir=$confdir if test ! -r $srcdir/$unique_file; then srcdir=.. fi fi if test ! -r $srcdir/$unique_file; then if test x$srcdirdefaulted = xyes; then echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2 else echo "configure: Can not find sources in \`${srcdir}'." 1>&2 fi exit 1 fi # Preserve a srcdir of `.' to avoid automounter screwups with pwd. # But we can't avoid them for `..', to make subdirectories work. case $srcdir in .|/*|~*) ;; *) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute. esac # Save the original args to write them into config.status later. configure_args="$*" if test -z "$CC"; then # Extract the first word of `gcc', so it can be a program name with args. set dummy gcc; word=$2 echo checking for $word IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. if test -f $dir/$word; then CC="gcc" break fi done IFS="$saveifs" fi test -z "$CC" && CC="cc" test -n "$CC" && test -n "$verbose" && echo " setting CC to $CC" # Find out if we are using GNU C, under whatever name. cat > conftest.c < conftest.out 2>&1 if egrep yes conftest.out >/dev/null 2>&1; then GCC=1 # For later tests. fi rm -f conftest* echo checking how to run the C preprocessor if test -z "$CPP"; then # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and ``${CC-cc}'' will simply confuse # make. It must be expanded now. CPP="${CC-cc} -E" cat > conftest.c < Syntax Error EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then : else CPP=/lib/cpp fi rm -f conftest* fi test ".${verbose}" != "." && echo " setting CPP to $CPP" # Make sure to not get the incompatible SysV /etc/install and # /usr/sbin/install, which might be in PATH before a BSD-like install, # or the SunOS /usr/etc/install directory, or the AIX /bin/install, # or the AFS install, which mishandles nonexistent args, or # /usr/ucb/install on SVR4, which tries to use the nonexistent group # `staff'. On most BSDish systems install is in /usr/bin, not /usr/ucb # anyway. Sigh. if test "z${INSTALL}" = "z" ; then echo checking for install IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. case $dir in /etc|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;; *) if test -f $dir/installbsd; then INSTALL="$dir/installbsd -c" # OSF1 INSTALL_PROGRAM='$(INSTALL)' INSTALL_DATA='$(INSTALL) -m 644' break fi if test -f $dir/install; then if grep dspmsg $dir/install >/dev/null 2>&1; then : # AIX else INSTALL="$dir/install -c" INSTALL_PROGRAM='$(INSTALL)' INSTALL_DATA='$(INSTALL) -m 644' break fi fi ;; esac done IFS="$saveifs" fi INSTALL=${INSTALL-cp} test -n "$verbose" && echo " setting INSTALL to $INSTALL" INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'} test -n "$verbose" && echo " setting INSTALL_PROGRAM to $INSTALL_PROGRAM" INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'} test -n "$verbose" && echo " setting INSTALL_DATA to $INSTALL_DATA" echo checking for minix/config.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then MINIX=1 fi rm -f conftest* # The Minix shell can't assign to the same variable on the same line! if test -n "$MINIX"; then { test -n "$verbose" && \ echo " defining _POSIX_SOURCE" echo "#define" _POSIX_SOURCE 1 >> confdefs.h DEFS="$DEFS -D_POSIX_SOURCE=1" SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD} \${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD} \${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD} " } { test -n "$verbose" && \ echo " defining" _POSIX_1_SOURCE to be 2 echo "#define" _POSIX_1_SOURCE 2 >> confdefs.h DEFS="$DEFS -D_POSIX_1_SOURCE=2" SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_1_SOURCE\${SEDdB}_POSIX_1_SOURCE\${SEDdC}2\${SEDdD} \${SEDuA}_POSIX_1_SOURCE\${SEDuB}_POSIX_1_SOURCE\${SEDuC}2\${SEDuD} \${SEDeA}_POSIX_1_SOURCE\${SEDeB}_POSIX_1_SOURCE\${SEDeC}2\${SEDeD} " } { test -n "$verbose" && \ echo " defining _MINIX" echo "#define" _MINIX 1 >> confdefs.h DEFS="$DEFS -D_MINIX=1" SEDDEFS="${SEDDEFS}\${SEDdA}_MINIX\${SEDdB}_MINIX\${SEDdC}1\${SEDdD} \${SEDuA}_MINIX\${SEDuB}_MINIX\${SEDuC}1\${SEDuD} \${SEDeA}_MINIX\${SEDeB}_MINIX\${SEDeC}1\${SEDeD} " } fi echo checking for POSIXized ISC if test -d /etc/conf/kconfig.d && grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1 then ISC=1 # If later tests want to check for ISC. { test -n "$verbose" && \ echo " defining _POSIX_SOURCE" echo "#define" _POSIX_SOURCE 1 >> confdefs.h DEFS="$DEFS -D_POSIX_SOURCE=1" SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD} \${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD} \${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD} " } if test -n "$GCC"; then CC="$CC -posix" else CC="$CC -Xp" fi fi echo checking for directory library header dirheader= if test -z "$dirheader"; then echo checking for dirent.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = opendir ("/"); } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining DIRENT" echo "#define" DIRENT 1 >> confdefs.h DEFS="$DEFS -DDIRENT=1" SEDDEFS="${SEDDEFS}\${SEDdA}DIRENT\${SEDdB}DIRENT\${SEDdC}1\${SEDdD} \${SEDuA}DIRENT\${SEDuB}DIRENT\${SEDuC}1\${SEDuD} \${SEDeA}DIRENT\${SEDeB}DIRENT\${SEDeC}1\${SEDeD} " } dirheader=dirent.h fi rm -f conftest* fi if test -z "$dirheader"; then echo checking for sys/ndir.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = opendir ("/"); } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining SYSNDIR" echo "#define" SYSNDIR 1 >> confdefs.h DEFS="$DEFS -DSYSNDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}SYSNDIR\${SEDdB}SYSNDIR\${SEDdC}1\${SEDdD} \${SEDuA}SYSNDIR\${SEDuB}SYSNDIR\${SEDuC}1\${SEDuD} \${SEDeA}SYSNDIR\${SEDeB}SYSNDIR\${SEDeC}1\${SEDeD} " } dirheader=sys/ndir.h fi rm -f conftest* fi if test -z "$dirheader"; then echo checking for sys/dir.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = opendir ("/"); } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining SYSDIR" echo "#define" SYSDIR 1 >> confdefs.h DEFS="$DEFS -DSYSDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}SYSDIR\${SEDdB}SYSDIR\${SEDdC}1\${SEDdD} \${SEDuA}SYSDIR\${SEDuB}SYSDIR\${SEDuC}1\${SEDuD} \${SEDeA}SYSDIR\${SEDeB}SYSDIR\${SEDeC}1\${SEDeD} " } dirheader=sys/dir.h fi rm -f conftest* fi if test -z "$dirheader"; then echo checking for ndir.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = opendir ("/"); } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining NDIR" echo "#define" NDIR 1 >> confdefs.h DEFS="$DEFS -DNDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}NDIR\${SEDdB}NDIR\${SEDdC}1\${SEDdD} \${SEDuA}NDIR\${SEDuB}NDIR\${SEDuC}1\${SEDuD} \${SEDeA}NDIR\${SEDeB}NDIR\${SEDeC}1\${SEDeD} " } dirheader=ndir.h fi rm -f conftest* fi echo checking for closedir return value cat > conftest.c < #include <$dirheader> int closedir(); main() { exit(closedir(opendir(".")) != 0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then : else { test -n "$verbose" && \ echo " defining VOID_CLOSEDIR" echo "#define" VOID_CLOSEDIR 1 >> confdefs.h DEFS="$DEFS -DVOID_CLOSEDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}VOID_CLOSEDIR\${SEDdB}VOID_CLOSEDIR\${SEDdC}1\${SEDdD} \${SEDuA}VOID_CLOSEDIR\${SEDuB}VOID_CLOSEDIR\${SEDuC}1\${SEDuD} \${SEDeA}VOID_CLOSEDIR\${SEDeB}VOID_CLOSEDIR\${SEDeC}1\${SEDeD} " } fi rm -f conftest* prog='/* Ultrix mips cc rejects this. */ typedef int charset[2]; const charset x; /* SunOS 4.1.1 cc rejects this. */ char const *const *ccp; char **p; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; ccp = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++ccp; p = (char**) ccp; ccp = (char const *const *) p; { /* SCO 3.2v4 cc rejects this. */ char *t; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25,17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; }; struct s *b; b->j = 5; }' echo checking for working const cat > conftest.c <> confdefs.h DEFS="$DEFS -Dconst=" SEDDEFS="${SEDDEFS}\${SEDdA}const\${SEDdB}const\${SEDdC}\${SEDdD} \${SEDuA}const\${SEDuB}const\${SEDuC}\${SEDuD} \${SEDeA}const\${SEDeB}const\${SEDeC}\${SEDeD} " } fi rm -f conftest* echo checking for ANSI C header files cat > conftest.c < #include #include #include EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. echo '#include "confdefs.h" #include ' > conftest.c eval "$CPP conftest.c > conftest.out 2>&1" if egrep "memchr" conftest.out >/dev/null 2>&1; then # SGI's /bin/cc from Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. cat > conftest.c < #define ISLOWER(c) ('a' <= (c) && (c) <= 'z') #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #define XOR(e,f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2); exit (0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining STDC_HEADERS" echo "#define" STDC_HEADERS 1 >> confdefs.h DEFS="$DEFS -DSTDC_HEADERS=1" SEDDEFS="${SEDDEFS}\${SEDdA}STDC_HEADERS\${SEDdB}STDC_HEADERS\${SEDdC}1\${SEDdD} \${SEDuA}STDC_HEADERS\${SEDuB}STDC_HEADERS\${SEDuC}1\${SEDuD} \${SEDeA}STDC_HEADERS\${SEDeB}STDC_HEADERS\${SEDeC}1\${SEDeD} " } fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* echo checking for unistd.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then { test -n "$verbose" && \ echo " defining HAVE_UNISTD_H" echo "#define" HAVE_UNISTD_H 1 >> confdefs.h DEFS="$DEFS -DHAVE_UNISTD_H=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_UNISTD_H\${SEDdB}HAVE_UNISTD_H\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_UNISTD_H\${SEDuB}HAVE_UNISTD_H\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_UNISTD_H\${SEDeB}HAVE_UNISTD_H\${SEDeC}1\${SEDeD} " } fi rm -f conftest* echo checking for pid_t in sys/types.h echo '#include "confdefs.h" #include ' > conftest.c eval "$CPP conftest.c > conftest.out 2>&1" if egrep "pid_t" conftest.out >/dev/null 2>&1; then : else { test -n "$verbose" && \ echo " defining" pid_t to be int echo "#define" pid_t int >> confdefs.h DEFS="$DEFS -Dpid_t=int" SEDDEFS="${SEDDEFS}\${SEDdA}pid_t\${SEDdB}pid_t\${SEDdC}int\${SEDdD} \${SEDuA}pid_t\${SEDuB}pid_t\${SEDuC}int\${SEDuD} \${SEDeA}pid_t\${SEDeB}pid_t\${SEDeC}int\${SEDeD} " } fi rm -f conftest* echo checking for return type of signal handlers cat > conftest.c < #include #ifdef signal #undef signal #endif extern void (*signal ()) (); int main() { exit(0); } int t() { int i; } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining" RETSIGTYPE to be void echo "#define" RETSIGTYPE void >> confdefs.h DEFS="$DEFS -DRETSIGTYPE=void" SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}void\${SEDdD} \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}void\${SEDuD} \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}void\${SEDeD} " } else { test -n "$verbose" && \ echo " defining" RETSIGTYPE to be int echo "#define" RETSIGTYPE int >> confdefs.h DEFS="$DEFS -DRETSIGTYPE=int" SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}int\${SEDdD} \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}int\${SEDuD} \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}int\${SEDeD} " } fi rm -f conftest* for func in dup2 memchr sigaction strerror waitpid do trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'` echo checking for ${func} cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${func}) || defined (__stub___${func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${func}(); ${func}(); #endif } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining ${trfunc}" echo "#define" ${trfunc} 1 >> confdefs.h DEFS="$DEFS -D${trfunc}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD} \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD} \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done for hdr in fcntl.h limits.h stdlib.h string.h sys/wait.h time.h do trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'` echo checking for ${hdr} cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then { test -n "$verbose" && \ echo " defining ${trhdr}" echo "#define" ${trhdr} 1 >> confdefs.h DEFS="$DEFS -D${trhdr}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD} \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD} \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done echo checking for vfork.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then { test -n "$verbose" && \ echo " defining HAVE_VFORK_H" echo "#define" HAVE_VFORK_H 1 >> confdefs.h DEFS="$DEFS -DHAVE_VFORK_H=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_VFORK_H\${SEDdB}HAVE_VFORK_H\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_VFORK_H\${SEDuB}HAVE_VFORK_H\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_VFORK_H\${SEDeB}HAVE_VFORK_H\${SEDeC}1\${SEDeD} " } fi rm -f conftest* echo checking for working vfork echo checking for return type of signal handlers cat > conftest.c < #include #ifdef signal #undef signal #endif extern void (*signal ()) (); int main() { exit(0); } int t() { int i; } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining" RETSIGTYPE to be void echo "#define" RETSIGTYPE void >> confdefs.h DEFS="$DEFS -DRETSIGTYPE=void" SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}void\${SEDdD} \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}void\${SEDuD} \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}void\${SEDeD} " } else { test -n "$verbose" && \ echo " defining" RETSIGTYPE to be int echo "#define" RETSIGTYPE int >> confdefs.h DEFS="$DEFS -DRETSIGTYPE=int" SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}int\${SEDdD} \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}int\${SEDuD} \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}int\${SEDeD} " } fi rm -f conftest* cat > conftest.c < #include #include #include #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_VFORK_H #include #endif static int signalled; static RETSIGTYPE catch (s) int s; { signalled = 1; } main() { pid_t parent = getpid (); pid_t child; signal (SIGINT, catch); child = vfork (); if (child == 0) { /* On sparc systems, changes by the child to local and incoming argument registers are propagated back to the parent. The compiler is told about this with #include , but some compilers (e.g. gcc -O) don't grok . Test for this by using lots of local variables, at least as many local variables as main has allocated so far including compiler temporaries. 4 locals are enough for gcc 1.40.3 on a sparc, but we use 8 to be safe. A buggy compiler should reuse the register of parent for one of the local variables, since it will think that parent can't possibly be used any more in this routine. Assigning to the local variable will thus munge parent in the parent process. */ pid_t p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(), p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid(); /* Convince the compiler that p..p7 are live; otherwise, it might use the same hardware register for all 8 local variables. */ if (p != p1 || p != p2 || p != p3 || p != p4 || p != p5 || p != p6 || p != p7) _exit(1); /* On some systems (e.g. SunOS 5.2), if the parent is catching a signal, the child ignores the signal before execing, and the parent later receives that signal, the parent dumps core. Test for this by ignoring SIGINT in the child. */ signal (SIGINT, SIG_IGN); /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent from child file descriptors. If the child closes a descriptor before it execs or exits, this munges the parent's descriptor as well. Test for this by closing stdout in the child. */ _exit(close(fileno(stdout)) != 0); } else { int status; struct stat st; while (wait(&status) != child) ; exit( /* Was there some problem with vforking? */ child < 0 /* Did the child fail? (This shouldn't happen.) */ || status /* Did the vfork/compiler bug occur? */ || parent != getpid() /* Did the signal handling bug occur? */ || kill(parent, SIGINT) != 0 || signalled != 1 /* Did the file descriptor bug occur? */ || fstat(fileno(stdout), &st) != 0 ); } } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then : else { test -n "$verbose" && \ echo " defining" vfork to be fork echo "#define" vfork fork >> confdefs.h DEFS="$DEFS -Dvfork=fork" SEDDEFS="${SEDDEFS}\${SEDdA}vfork\${SEDdB}vfork\${SEDdC}fork\${SEDdD} \${SEDuA}vfork\${SEDuB}vfork\${SEDuC}fork\${SEDuD} \${SEDeA}vfork\${SEDeB}vfork\${SEDeC}fork\${SEDeD} " } fi rm -f conftest* echo checking for vprintf cat > conftest.c <> confdefs.h DEFS="$DEFS -DHAVE_VPRINTF=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_VPRINTF\${SEDdB}HAVE_VPRINTF\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_VPRINTF\${SEDuB}HAVE_VPRINTF\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_VPRINTF\${SEDeB}HAVE_VPRINTF\${SEDeC}1\${SEDeD} " } else vprintf_missing=1 fi rm -f conftest* if test -n "$vprintf_missing"; then echo checking for _doprnt cat > conftest.c <> confdefs.h DEFS="$DEFS -DHAVE_DOPRNT=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_DOPRNT\${SEDdB}HAVE_DOPRNT\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_DOPRNT\${SEDuB}HAVE_DOPRNT\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_DOPRNT\${SEDeB}HAVE_DOPRNT\${SEDeC}1\${SEDeD} " } fi rm -f conftest* fi # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! echo checking for working alloca.h cat > conftest.c < int main() { exit(0); } int t() { char *p = alloca(2 * sizeof(int)); } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining HAVE_ALLOCA_H" echo "#define" HAVE_ALLOCA_H 1 >> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA_H=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ALLOCA_H\${SEDdB}HAVE_ALLOCA_H\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_ALLOCA_H\${SEDuB}HAVE_ALLOCA_H\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_ALLOCA_H\${SEDeB}HAVE_ALLOCA_H\${SEDeC}1\${SEDeD} " } fi rm -f conftest* decl="#ifdef __GNUC__ #define alloca __builtin_alloca #else #if HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else char *alloca (); #endif #endif #endif " echo checking for alloca cat > conftest.c < conftest.c < conftest.out 2>&1" if egrep "winnitude" conftest.out >/dev/null 2>&1; then echo checking for _getb67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub__getb67) || defined (__stub____getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char _getb67(); _getb67(); #endif } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be _getb67 echo "#define" CRAY_STACKSEG_END _getb67 >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}_getb67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}_getb67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}_getb67\${SEDeD} " } else echo checking for GETB67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_GETB67) || defined (__stub___GETB67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char GETB67(); GETB67(); #endif } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be GETB67 echo "#define" CRAY_STACKSEG_END GETB67 >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}GETB67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}GETB67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}GETB67\${SEDeD} " } else echo checking for getb67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_getb67) || defined (__stub___getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char getb67(); getb67(); #endif } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be getb67 echo "#define" CRAY_STACKSEG_END getb67 >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=getb67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}getb67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}getb67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}getb67\${SEDeD} " } fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* if test -n "$alloca_missing"; then # The SVR3 libPW and SVR4 libucb both contain incompatible functions # that cause trouble. Some versions do not even contain alloca or # contain a buggy version. If you still want to use their alloca, # use ar to extract alloca.o from them instead of compiling alloca.c. ALLOCA=alloca.o { test -n "$verbose" && \ echo " defining C_ALLOCA" echo "#define" C_ALLOCA 1 >> confdefs.h DEFS="$DEFS -DC_ALLOCA=1" SEDDEFS="${SEDDEFS}\${SEDdA}C_ALLOCA\${SEDdB}C_ALLOCA\${SEDdC}1\${SEDdD} \${SEDuA}C_ALLOCA\${SEDuB}C_ALLOCA\${SEDuC}1\${SEDuD} \${SEDeA}C_ALLOCA\${SEDeB}C_ALLOCA\${SEDeC}1\${SEDeD} " } echo 'checking stack direction for C alloca' echo checking whether cross-compiling # If we cannot run a trivial program, we must be cross compiling. cat > conftest.c </dev/null; then : else cross_compiling=1 fi rm -f conftest* if test -n "$cross_compiling" then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be 0 echo "#define" STACK_DIRECTION 0 >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=0" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}0\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}0\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}0\${SEDeD} " } else cat > conftest.c < addr) ? 1 : -1; } main () { exit (find_stack_direction() < 0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be 1 echo "#define" STACK_DIRECTION 1 >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=1" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}1\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}1\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}1\${SEDeD} " } else { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be -1 echo "#define" STACK_DIRECTION -1 >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=-1" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}-1\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}-1\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}-1\${SEDeD} " } fi fi rm -f conftest* fi echo checking for st_blksize in struct stat cat > conftest.c < #include int main() { exit(0); } int t() { struct stat s; s.st_blksize; } EOF if eval $compile; then { test -n "$verbose" && \ echo " defining HAVE_ST_BLKSIZE" echo "#define" HAVE_ST_BLKSIZE 1 >> confdefs.h DEFS="$DEFS -DHAVE_ST_BLKSIZE=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ST_BLKSIZE\${SEDdB}HAVE_ST_BLKSIZE\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_ST_BLKSIZE\${SEDuB}HAVE_ST_BLKSIZE\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_ST_BLKSIZE\${SEDeB}HAVE_ST_BLKSIZE\${SEDeC}1\${SEDeD} " } fi rm -f conftest* echo checking for Xenix cat > conftest.c < conftest.out 2>&1" if egrep "yes" conftest.out >/dev/null 2>&1; then XENIX=1 fi rm -f conftest* if test -n "$XENIX"; then LIBS="$LIBS -lx" case "$DEFS" in *SYSNDIR*) ;; *) LIBS="-ldir $LIBS" ;; # Make sure -ldir precedes any -lx. esac fi rm -f confdefs.h if test -n "$prefix"; then test -z "$exec_prefix" && exec_prefix='${prefix}' prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%" fi if test -n "$exec_prefix"; then prsub="$prsub s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%" fi # Quote sed substitution magic chars in DEFS. cat >conftest.def < config.status </dev/null | sed 1q`: # # $0 $configure_args for arg do case "\$arg" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo running /bin/sh $0 $configure_args exec /bin/sh $0 $configure_args ;; *) echo "Usage: config.status --recheck" 2>&1; exit 1 ;; esac done trap 'rm -fr Makefile config.h conftest*; exit 1' 1 3 15 CC='$CC' CPP='$CPP' INSTALL='$INSTALL' INSTALL_PROGRAM='$INSTALL_PROGRAM' INSTALL_DATA='$INSTALL_DATA' ALLOCA='$ALLOCA' LIBS='$LIBS' srcdir='$srcdir' prefix='$prefix' exec_prefix='$exec_prefix' prsub='$prsub' EOF cat >> config.status <<\EOF top_srcdir=$srcdir # Allow make-time overrides of the generated file list. test -n "$gen_files" || gen_files="Makefile" for file in .. $gen_files; do if test "x$file" != x..; then srcdir=$top_srcdir # Remove last slash and all that follows it. Not all systems have dirname. dir=`echo $file|sed 's%/[^/][^/]*$%%'` if test "$dir" != "$file"; then test "$top_srcdir" != . && srcdir=$top_srcdir/$dir test ! -d $dir && mkdir $dir fi echo creating $file rm -f $file echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file sed -e " $prsub s%@CC@%$CC%g s%@CPP@%$CPP%g s%@INSTALL@%$INSTALL%g s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g s%@INSTALL_DATA@%$INSTALL_DATA%g s%@ALLOCA@%$ALLOCA%g s%@LIBS@%$LIBS%g s%@srcdir@%$srcdir%g s%@DEFS@%-DHAVE_CONFIG_H%" $top_srcdir/${file}.in >> $file fi; done test -n "$gen_configs" || gen_configs="config.h" for file in .. $gen_configs; do if test "x$file" != x..; then echo creating $file # These sed commands are put into SEDDEFS when defining a macro. # They are broken into pieces to make the sed script easier to manage. # They are passed to sed as "A NAME B NAME C VALUE D", where NAME # is the cpp macro being defined and VALUE is the value it is being given. # Each defining turns into a single global substitution command. # # SEDd sets the value in "#define NAME VALUE" lines. SEDdA='s@^\([ ]*\)#\([ ]*define[ ][ ]*\)' SEDdB='\([ ][ ]*\)[^ ]*@\1#\2' SEDdC='\3' SEDdD='@g' # SEDu turns "#undef NAME" with trailing blanks into "#define NAME VALUE". SEDuA='s@^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' SEDuB='\([ ]\)@\1#\2define\3' SEDuC=' ' SEDuD='\4@g' # SEDe turns "#undef NAME" without trailing blanks into "#define NAME VALUE". SEDeA='s@^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' SEDeB='$@\1#\2define\3' SEDeC=' ' SEDeD='@g' rm -f conftest.sed EOF # Turn off quoting long enough to insert the sed commands. rm -f conftest.sh cat > conftest.sh < conftest.s1 # Like head -20. sed 1,${maxshlines}d conftest.sh > conftest.s2 # Like tail +21. # Write a limited-size here document to append to conftest.sed. echo 'cat >> conftest.sed <> config.status cat conftest.s1 >> config.status echo 'CONFEOF' >> config.status rm -f conftest.s1 conftest.sh mv conftest.s2 conftest.sh done rm -f conftest.sh # Now back to your regularly scheduled config.status. cat >> config.status <<\EOF # This sed command replaces #undef's with comments. This is necessary, for # example, in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it in # config.h. cat >> conftest.sed <<\CONFEOF s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, CONFEOF rm -f conftest.h # Break up the sed commands because old seds have small limits. maxsedlines=20 cp $top_srcdir/$file.in conftest.h1 while : do lines=`grep -c . conftest.sed` if test -z "$lines" || test "$lines" -eq 0; then break; fi rm -f conftest.s1 conftest.s2 conftest.h2 sed ${maxsedlines}q conftest.sed > conftest.s1 # Like head -20. sed 1,${maxsedlines}d conftest.sed > conftest.s2 # Like tail +21. sed -f conftest.s1 < conftest.h1 > conftest.h2 rm -f conftest.s1 conftest.h1 conftest.sed mv conftest.h2 conftest.h1 mv conftest.s2 conftest.sed done rm -f conftest.sed conftest.h echo "/* $file. Generated automatically by configure. */" > conftest.h cat conftest.h1 >> conftest.h rm -f conftest.h1 if cmp -s $file conftest.h 2>/dev/null; then # The file exists and we would not be changing it. rm -f conftest.h else rm -f $file mv conftest.h $file fi fi; done exit 0 EOF chmod +x config.status test -n "$no_create" || ./config.status diffutils-2.4/configure.in100444 74720 14 676 5444405611 14541 0ustar eggertguestdnl Process this file with autoconf to produce a configure script. AC_INIT(diff.h) AC_CONFIG_HEADER(config.h) AC_PROG_CC AC_PROG_CPP AC_PROG_INSTALL AC_MINIX AC_ISC_POSIX AC_DIR_HEADER AC_CONST AC_STDC_HEADERS AC_UNISTD_H AC_PID_T AC_RETSIGTYPE AC_HAVE_FUNCS(dup2 memchr sigaction strerror waitpid) AC_HAVE_HEADERS(fcntl.h limits.h stdlib.h string.h sys/wait.h time.h) AC_VFORK AC_VPRINTF AC_ALLOCA AC_ST_BLKSIZE AC_XENIX_DIR AC_OUTPUT(Makefile) diffutils-2.4/COPYING100666 74720 14 43076 5022247405 13327 0ustar eggertguest GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. diffutils-2.4/ChangeLog100666 74720 14 146374 5445722615 14105 0ustar eggertguestWed Sep 14 07:14:15 1993 Paul Eggert (eggert@twinsun.com) * Version 2.4 released. * ifdef.c (scan_char_literal): New function, for new %c'x' and %c'\ooo' format specs. (format_group, print_ifdef_lines): Use it. Remove %0 format spec. * cmp.c (cmp): Don't try to read past end of file; this doesn't work on ttys. * system.h, version.c: #include , not "config.h", to allow configuring in a separate directory when the source directory has already been configured. * Makefile.in (COMPILE): New defn, with proper -I options so that `#include ' works. (.c.o, diff3.o, sdiff.o): Use it. Mon Sep 13 06:45:43 1993 Paul Eggert (eggert@twinsun.com) * diff.c (main, longopts): Add --line-format=FORMAT option. (specify_format): Args no longer const pointers. All callers changed. * ifdef.c: Add support for %?c, %(A=B?T:E), PRINTF_SPECn formats. (struct group): New struct. (print_ifdef_lines): Use it to simplify argument passing. Remove the convention that last arg -1 signifies that the lines from file 2 are the same as the lines from file 1; this convention no longer works, now that line numbers might be printed out, since the line numbers may differ. Add first FILE * argument to output to. All callers changed. Use a faster test for the single-fwrite optimization. (format_group, scan_printf_spec, groups_letter_value): New functions. * diff.h (group_format, line_format): No longer const pointers. (format_ifdef): 1st arg is no longer const pointer. * configure.in: Configure HAVE_LIMITS_H, HAVE_STDLIB_H. * system.h , , : Include only if HAVE_LIMITS_H etc. * system.h (memcmp, memcpy, strchr, strrchr, struct dirent): Prefer these standard names to the traditional names (bcmp, bcpy, index, rindex, struct direct). All callers changed. * system.h (PARAMS, VOID): Define earlier so that malloc decl can use VOID. (STAT_BLOCKSIZE): Simplify ersatz defn; just use 8K. Fri Sep 3 00:21:02 1993 Paul Eggert (eggert@twinsun.com) * diff.c (compare_files): Two files with the same name must be the same file; avoid a needless `stat' in that case. Fri Aug 27 06:59:03 1993 Paul Eggert (eggert@twinsun.com) * Pervasive changes for portability to 64-bit hosts: Add prototypes to function declarations. Use size_t, not int, when needed. * Other pervasive changes: Use `const' more often. Use STD{IN,OUT,ERR}_FILENO instead of [012]. Use 0, not NULL, for portability to broken hosts. * Makefile.in: (srcs, objs, distfiles, cmp): New files cmpbuf.[ch]. (distfiles): New files config.h.in, mkinstalldirs. (.c.o): Add -DHAVE_CONFIG_H. * analyze.c: (diag): Pacify `gcc -Wall' with a useless assignment. (diff_2_files): Use l.c.m., not max, of files' buffer sizes. * cmp.c: Make globals static when possible. (file): Now a 2-element array; replaces `file1' and `file2'. (file_desc, buffer): Likewise, for file[12]_desc and buf[12]. (main): Likewise, for stat_buf[12]. Index these variables with `i'. (ignore_initial): New var. (long_options): Now const. Add `--ignore-initial'. (usage): Sort options and add `--ignore-initial'. (main, cmp): Add `--ignore-initial' support. (main): `cmp - -' now succeeds. When comparing standard input to a file, and using a shortcut (e.g. looking at file sizes or inode numbers), take the lseek offset into account before deciding whether the files are identical. Avoid mentioning `dev_t', `ino_t' for portability to nonstandard hosts. Use l.c.m. of files' buffer sizes, not 8 * 1024. ferror (stdout) does not imply errno has a useful value. If 2nd file is "-", treat it first, in case stdin is closed. (cmp): Always compute `char_number', `smaller' for speed and simplicity. Say `cmp: EOF on input', not `/usr/gnu/bin/cmp: EOF on input', as per Posix.2. (block_compare_and_count): Increment line_number argument. Remove end_char argument; it's always '\n'. All callers changed. Do not assume sizeof(long) == 4; this isn't true on some 64-bit hosts. (block_compare): Minimize differences with block_compare_and_count. (block_read): Coalesce `bp += nread's. (printc): Remove `FILE *' arg; output to stdout. All callers changed. * configure.in: Configure HAVE_SIGACTION, RETSIGTYPE, HAVE_VPRINTF. Configure into config.h. * context.c (print_context_label): Standard input's st_mtime is no longer a special case here, since `compare_files' now sets it to the current time. * diff.c (usage): Sort options. (filetype): New function. (compare_files): Set stdin's st_mtime to be the current time. Leave its name "-" instead of changing it to "Standard Input"; to test whether a file is stdin, we must compare its name to "-" instead of its desc to 0, since if it's closed other file descs may be 0. When comparing standard input to a file, and using a shortcut (e.g. looking at file sizes or inode numbers), take the lseek offset into account before deciding whether the files are identical. Pretend that nonexistent files have the same filetype as existing files. Rename `errorcount' to `failed', since it's boolean. In directory comparisons, if a file is neither a regular file nor a directory, just print its type and the other file's type. * diff.h (Is_space, textchar): Remove. (struct msg, msg_chain, msg_chain_end): Move to util.c. (VOID): Move to system.h. (line_cmp, version_string, change_letter, print_number_range, find_change): New decls. * diff.texi: whitespace -> white space. It now stands for whatever isspace yields. Add --ignore-initial. * diff3.c (VOID): Move to system.h. (version_string): Now char[]. (usage): Sort options. (process_diff): Pacify `gcc -Wall' with a useless assignment. (read_diff): pid is of type pid_t, not int. Use waitpid if available. (output_diff3): Simplify test for `\ No newline at end of file' message. * dir.c (struct dirdata): Rename `files' to `names' to avoid confusion with external struct file_data `files'. * io.c (line_cmp): Move declaration to diff.h. (textchar): Remove. (find_and_hash_each_line): Use locale's definition of white space instead of using one hardwired defn for -b and another for -w. * normal.c (change_letter, print_number_range, find_change): Move decls to diff.h. (print_normal_hunk): Now static. * sdiff.c (SEEK_SET): Move to system.h. (version_string): Now char[], not char*. (private_tempnam): Remove hardcoded limit on temporary file names. (exiterr, perror_fatal, main): When exiting because of a signal, exit with that signal's status. (lf_refill, main, skip_white, edit, interact): Check for signal. (ignore_SIGINT): Renamed from `ignore_signals'. (NUM_SIGS, initial_handler): New macros. (initial_action, signal_received, sigs_trapped): New vars. (catchsig, trapsigs): Use sigaction if possible, since this closes the windows of vulnerability that `signal' has. Use RETSIGTYPE not void. When a signal comes in, just set a global variable; this is safer. (checksigs, untrapsig): New functions. (edit): Pacify `gcc -Wall' with a useless assignment. Respond to each empty line with help, not to every other empty line. (private_tempnam): Remove hardcoded limit on temporary file name length. Don't assume sizeof (pid_t) <= sizeof (int). * system.h: (S_IXOTH, S_IXGRP, S_IXUSR, SEEK_SET, SEEK_CUR, STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO): New macros, if system doesn't define them. (volatile): Don't define if already defined. (PARAMS): New macro. (VOID): Move here from diff.h. * util.c (struct msg, msg_chain, msg_chain_end): Moved here from diff.h. (message5): New function. (pr_pid): New var. (begin_output): Allocate `name' more precisely. Put child pid into pr_pid, so that we can wait for it later. Don't check execl's return value, since any return must be an error. (finish_output): Detect and report output errors. Use waitpid if available. Check pr exit status. (line_cmp): Use locale's definition of white space instead of using one hardwired defn for -b and another for -w. (analyze_cmp): Avoid double negation with `! nontrivial'. Pacify `gcc -Wall' be rewriting for-loop into do-while-loop. (dir_file_pathname): New function. * version.c (version_string): Now char[], not char*. Thu Jul 29 20:44:30 1993 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * Makefile.in (config.status): Run config.status --recheck, not configure, to get the right args passed. Thu Jul 22 10:46:30 1993 Paul Eggert (eggert@twinsun.com) * Makefile.in (dist): Replace `if [ ! TEST ]; then ACTION; fi' with `[ TEST ] || ACTION || exit' so that the containing for-loop exits with proper status for `make'. Thu Jul 8 19:47:22 1993 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * Makefile.in (installdirs): New target. (install): Use it. (Makefile, config.status, configure): New targets. Sat Jun 5 23:10:40 1993 Paul Eggert (eggert@twinsun.com) * Makefile.in (dist): Switch from .z to .gz. Wed May 26 17:16:02 1993 Paul Eggert (eggert@twinsun.com) * diff.c (main): Cast args to compare_files, for traditional C. * side.c (print_sdiff_common_lines_print_sdiff_hunk): Likewise. * analyze.c, diff3.c, sdiff.c, util.c: Don't assume NULL is defined properly. Tue May 25 14:54:05 1993 Paul Eggert (eggert@twinsun.com) * analyze.c (diff_2_files): With -q, do not report that files differ if all their differences are ignored. (briefly_report): New function. * diff.h (ignore_some_changes): New variable. * diff.c (compare_files): Don't use the file size shortcut if ignore_some_changes is nonzero, since the file size may differ merely due to ignored changes. (main): Set ignore_some_changes if we might ignore some changes. Remove unsystematic assignment of 0 to static vars. * io.c (read_files): New argument PRETEND_BINARY says whether to pretend the files are binary. * diff3.c (tab_align_flag): New variable, for new -T option. (main, usage, output_diff3): Add support for -T. Sun May 23 15:25:29 1993 Richard Stallman (rms@mole.gnu.ai.mit.edu) * dir.c (dir_sort): Always init `data' to avoid GCC warning. Sat May 22 15:35:02 1993 Paul Eggert (eggert@twinsun.com) * Makefile.in (dist): Change name of package from diff to diffutils. Don't bother to build .Z dist; .z suffices. Fri May 21 16:35:22 1993 Paul Eggert (eggert@twinsun.com) * diff.c: Include "system.h" to get memchr declaration. * system.h (memchr): Declare if !HAVE_MEMCHR, not if !HAVE_MEMCHR && !STDC_HEADERS. Wed May 19 17:43:55 1993 Paul Eggert (eggert@twinsun.com) * Version 2.3 released. Fri Apr 23 17:18:44 1993 Paul Eggert (eggert@twinsun.com) * io.c (find_identical_ends): Do not discard the last HORIZON_LINES lines of the prefix, or the first HORIZON_LINES lines of the suffix. * diff.c (main, longopts, usage): Add --horizon-lines option. * diff3.c (main, process_diff, read_diff): Invoke second diff with --horizon-lines determined by the first diff. * diff.h, diff3.c (horizon_lines): New variable. Mon Mar 22 16:16:00 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * system.h [HAVE_STRING_H || STDC_HEADERS] (bcopy, bcmp, bzero): Don't define if already defined. Fri Mar 5 00:20:16 1993 Richard Stallman (rms@mole.gnu.ai.mit.edu) * diff.c (main): Use NULL in arg to compare_files. Thu Feb 25 15:26:01 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * system.h: Declare memchr #if !HAVE_MEMCHR && !STDC_HEADERS, not #if !HAVE_MEMCHR || !STDC_HEADERS. Mon Feb 22 15:04:46 1993 Richard Stallman (rms@geech.gnu.ai.mit.edu) * io.c (find_identical_ends): Move complicated arg outside GUESS_LINES. Mon Feb 22 12:56:12 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Makefile.in (.c.o): Add -I$(srcdir); put $(CFLAGS) last before $<. Sat Feb 20 19:18:56 1993 Richard Stallman (rms@mole.gnu.ai.mit.edu) * io.c (binary_file_p): Return zero if file size is zero. Fri Feb 19 17:31:32 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 2.2 released. * system.h [HAVE_STRING_H || STDC_HEADERS] (index, rindex): Don't define if already defined. Wed Feb 17 17:08:00 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Makefile.in (srcs): Remove limits.h. Thu Feb 11 03:36:00 1993 Richard Stallman (rms@mole.gnu.ai.mit.edu) * diff3.c (xmalloc): No longer static. * sdiff.c (edit): Allocate buf dynamically. * dir.c (dir_sort): Handle VOID_CLOSEDIR. Wed Feb 10 00:15:54 1993 Richard Stallman (rms@mole.gnu.ai.mit.edu) * limits.h: File deleted (should never have been there). Tue Feb 9 03:53:22 1993 Richard Stallman (rms@mole.gnu.ai.mit.edu) * Makefile.in (.c.o, diff3.o, sdiff.o): Put $(CFLAGS) last. Wed Feb 3 15:42:10 1993 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * system.h: Don't #define const; let configure do it. Mon Feb 1 02:13:23 1993 Paul Eggert (eggert@hal.gnu.ai.mit.edu) * Version 2.1 released. * Makefile.in (dist): Survive ln failures. Create .tar.z (gzipped tar) file as well as .tar.Z (compressed tar) file. Fri Jan 8 22:31:41 1993 Paul Eggert (eggert@twinsun.com) * side.c (print_half_line): When the input position falls outside the column, do not output a tab even if the output position still falls within the column. Mon Dec 21 13:54:36 1992 David J. MacKenzie (djm@kropotkin.gnu.ai.mit.edu) * Makefile.in (.c.o): Add -I. Fri Dec 18 14:08:20 1992 Paul Eggert (eggert@twinsun.com) * configure.in: Add HAVE_FCNTL_H, since system.h uses it. Tue Nov 24 10:06:48 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * Makefile.in: Note change from USG to HAVE_STRING_H. Mon Nov 23 18:44:00 1992 Paul Eggert (eggert@twinsun.com) * io.c (find_and_hash_each_line): When running out of lines, double the number of allocated lines, instead of just doubling that number minus the prefix lines. This is more likely to avoid the need for further memory allocation. Wed Nov 18 20:40:28 1992 Paul Eggert (eggert@twinsun.com) * dir.c (dir_sort): Plug memory leak: space holding directory contents was not being reclaimed. Get directory size from struct file_data for initial guess at memory needed. Detect errors when reading and closing directory. (diff_dirs): Pass struct file_data to dir_sort. Finish plugging leak. * diff.c (compare_files): Pass struct file_data to diff_dirs. * io.c (find_and_hash_each_line): Don't assume alloc_lines is nonzero when allocating more lines. Thu Nov 12 16:02:18 1992 Paul Eggert (eggert@twinsun.com) * diff.c (main): Add `-U lines' as an alias for `--unified=lines'. * diff3.c (usage): Add third --label option in example. * util.c (analyze_hunk): Fix test for ignoring blank lines. * configure.in, system.h: Avoid USG; use HAVE_TIME_H etc. instead. Mon Nov 9 05:13:25 1992 Paul Eggert (eggert@twinsun.com) * diff3.c (main, usage): Add -A or --show-all. -m now defaults to -A, not -E. Allow up to three -L options. (output_diff3_edscript, output_diff3_merge): Remove spurious differences between these two functions. Output ||||||| for -A. Distinguish between conflicts and overlaps. (dotlines, undotlines): New functions that output `Ns', not `N,Ns'. (output_diff3_edscript, output_diff3_merge): Use them. * io.c (find_identical_ends): shift_boundaries needs an extra identical line at the end, not at the beginning. * sdiff.c (edit): execvp wants char **, not const char **. Mon Oct 19 04:39:32 1992 Paul Eggert (eggert@twinsun.com) * context.c (print_context_script, find_function): Context line numbers start with - file->prefix_lines, not 0. * io.c (binary_file_p): Undo last change; it was a library bug. Sun Oct 18 00:17:29 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu) * io.c (binary_file_p): Consider empty file as non-binary. Mon Oct 5 05:18:46 1992 Paul Eggert (eggert@twinsun.com) * diff3.c (main, make_3way_diff, using_to_diff3_block): Don't report bogus differences (for one of -mexEX3) just because the file0-file1 diffs don't line up with the file0-file2 diffs. (This is entirely possible since we don't use diff's -n option.) Always compare file1 to file2, so that diff3 sees those changes directly. Typically, file2 is now the common file, not file0. (output_diff3_merge): The input file is file 0, not the common file. (FC, FO): New macros; they replace FILE1, FILE0 for two-way diffs, to distinguish them from three-way diffs. * diff3.c (using_to_diff3_block): Fold repeated code into loops. * diff3.c (make_3way_diff, process_diff): Have the *_end variable point to the next field to be changed, not to the last object allocated; this saves an if-then-else. * diff3.c (process_diff): Use D_NUMLINES instead of its definiens. * diff3.c: Make fns and vars static unless they must be external. Wed Sep 30 09:21:59 1992 Paul Eggert (eggert@twinsun.com) * analyze.c (diff_2_files): OUTPUT_IFDEF is now robust. * diff.h (ROBUST_OUTPUT_STYLE): Likewise. (default_line_format): Remove. All refs removed. * ifdef.c (print_ifdef_lines): Add %L. Optimize %l\n even if user specified it, as opposed to its being the default. Tue Sep 29 19:01:28 1992 Paul Eggert (eggert@twinsun.com) * diff.c (longopts, main): --{old,new,unchanged,changed}--group-format are new options, so that -D is no longer overloaded. Set no_diff_means_no_output if --unchanged-{line,group}-format allows it. * diff.h (enum line_class): New type. (group_format, line_format): Use it to regularize option flags. All refs changed. * ifdef.c (format_ifdef, print_ifdef_lines): %n is no longer a format. Mon Sep 28 04:51:42 1992 Paul Eggert (eggert@twinsun.com) * diff.c (main, usage): Replace --line-prefix with the more general --{old,new,unchanged}-line-format options. * ifdef.c (format_ifdef, print_ifdef_lines): Likewise. * diff.h (line_format): Renamed from line_prefix. All refs changed. * diff.h, ifdef.c (default_line_format): New variable. * util.c (output_1_line): New function. (print_1_line): Use it. * ifdef.c: (format_ifdef, print_ifdef_lines): Add %0 format. Sun Sep 27 05:38:13 1992 Paul Eggert (eggert@twinsun.com) * diff.c (main): Add -E or --line-prefix option. Add -D'=xxx' for common lines. Change default -D< format from copy of -D> format to to -D<%<; similarly for default -D> format. * diff.h (common_format, line_prefix): New variables. * ifdef.c (format_ifdef): New function. (print_ifdef_script, print_ifdef_hunk, print_ifdef_lines): Use it for -D'=xxx', -E. * context.c (find_hunk): Glue together two non-ignorable changes that are exactly CONTEXT * 2 lines apart. This shortens output, removes a behavioral discontinuity at CONTEXT = 0, and is more compatible with traditional diff. * io.c (find_identical_ends): Slurp stdin at most once. * util.c (print_line_line): line_flag is const char *. Thu Sep 24 15:18:07 1992 Paul Eggert (eggert@twinsun.com) * ifdef.c (print_ifdef_lines): New function, which fwrites a sequence of lines all at once for speed. (print_ifdef_script, print_ifdef_hunk): Use it. Thu Sep 24 05:54:14 1992 Paul Eggert (eggert@twinsun.com) * diff.c (main): Support new -D options for if-then-else formats. (specify_format): New function. * diff.h (ifndef_format, ifdef_format, ifnelse_format): New variables. * ifdef.c (print_ifdef_hunk): Use the new variables instead of a hardwired format. * side.c (print_1sdiff_line): Represent incomplete lines on output. (print_sdiff_script): Likewise. Don't print 'q' at end, since that doesn't work with incomplete lines. * sdiff.c (interact): Don't assume diff output ends with 'q' line. * diff.h (ROBUST_OUTPUT_STYLE): OUTPUT_SDIFF is now robust. * sdiff.c (lf_copy, lf_snarf): Use memchr instead of index, to avoid dumping core when files contain null characters. (memchr): New function (if memchr is missing). * io.c (sip): New arg SKIP_TEST to skip test for binary file. (read_files): Don't bother testing second file if first is binary. Thu Sep 17 21:17:49 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * system.h [!USG && !_POSIX_VERSION]: Protect from conflicting prototype for wait in sys/wait.h. Wed Sep 16 12:32:18 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * Makefile.in: Include binprefix in -DDIFF_PROGRAM. Tue Sep 15 14:27:25 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * Version 2.0. Sat Sep 12 01:31:19 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * util.c, diff.h, system.h [!HAVE_MEMCHR]: Don't use void * and const when declaring memchr replacement. Declare memchr if !STDC_HEADERS && !USG. Thu Sep 10 15:17:32 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * Makefile.in (uninstall): New target. * diff.c (excluded_filename): Use fnmatch, not wildmat. (usage): Document -x, -X, --exclude, --exclude-from. Makefile.in: Use fnmatch.c, not wildmat.c. Sun Sep 6 23:46:25 1992 Paul Eggert (eggert@twinsun.com) * configure.in: Add HAVE_MEMCHR. * diff.h, util.c: Use it instead of MEMCHR_MISSING. Sun Sep 6 07:25:49 1992 Paul Eggert (eggert@twinsun.com) * diff.h: (struct line_def): Replace this 3-word struct with char *. This uses less memory, particularly for large files with short lines. (struct file_data): New member linbuf_base counts number of lines in common prefix that are not recorded in linbuf; this uses less memory if files are identical or differ only at end. New member buffered_lines counts possibly differing lines. New member valid_lines counts valid data. New member alloc_lines - linbuf_base replaces old linbufsize. linbuf[0] now always points at first differing line. Remove unused members ltran, suffix_lines. Add const where appropriate. (Is_space): New macro, for consistent definition of `white space'. (excluded_filename, memchr, sip, slurp): New declarations. * ed.c (print_ed_hunk): Adjust to diff.h's struct changes. * context.c (pr_context_hunk): Likewise. * ifdef.c (print_ifdef_script): Likewise. * side.c (print_sdiff_script, print_half_line): Likewise. * util.c (analyze_hunk, line_cmp, print_1_line): Likewise. * analyze.c (shift_boundaries): Remove unneeded variable `end' and unnecessary comparisons of `preceding' and `other_preceding' against 0. (diff_2_files): When comparing files byte-by-byte for equality, don't slurp them all in at once; just compare them a buffer at a time. This can win big if they differ early on. Move some code to compare_files to enable this change. Use only one buffer for stdin with `diff - -'. (discard_confusing_lines, diff_2_files): Coalesce malloc/free calls. (build_script): Remove obsolete OUTPUT_RCS code. * diff.c (add_exclude, add_exclude_file, excluded_filename): New fns. (main): Use them for the new --exclude and --exclude-from options. (compare_files): Don't open a file unless it must be read. Treat `diff file file' and `diff file dir' similarly. Move some code here from diff_2_files to enable this. Simplify file vs dir warning. * dir.c (dir_sort): Support new --exclude* options. * io.c (struct equivclass): Put hash code and line length here instead of struct line_def, so that they can be shared. (find_and_hash_each_line): Compute equivalence class as we go, instead of doing it in a separate pass; this thrashes memory less. Make buckets realloc-able, since we can't preallocate them. Record one more line start than there are lines, so that we can compute any line's length by subtracting its start from the next line's, instead of storing the length explicitly. This saves memory. Move prefix-handling code to find_identical_ends; this wins with large prefixes. Use Is_space, not is_space, for consistent treatment of white space. (prepare_text_end): New function. (find_identical_ends): Move slurping here, so it's only done when needed. Work even if the buffers are the same (because of `diff - -'). Compare prefixes a word at a time for speed. (find_equiv_class): Delete; now done by find_and_hash_each_line. (read_files): Don't slurp unless needed. find_equiv_class's work is now folded into find_and_hash_each_line. Don't copy stdin buffer if `diff - -'. Check for running out of primes. (sip, slurp): Split first part of `slurp' into another function `sip'. `sip' sets things up and perhaps reads the first ST_BLKSIZE buffer to see whether the file is binary; `slurp' now just finishes the job. This lets diff_2_files compare binary files lazily. Allocate a one-word sentinel to allow word-at-a-time prefix comparison. Count prefix lines only if needed, only count the first file's prefix. Don't bother to count suffix lines; it's never needed. Set up linbuf[0] to point at first differing line. (binary_file_p): Change test for binary files: if it has a null byte in its first buffer, it's binary. (primes): Add more primes. * util.c (line_cmp): Use bcmp for speed. Use Is_space, not is_space, for consistent treatment of white space. (translate_line_number): Internal line numbers now count from 0 starting after the prefix. (memchr): New function (if memchr is missing). * Makefile.in: Document HAVE_ST_BLKSIZE. Link with wildmat.o. * system.h (STAT_BLOCKSIZE): New macro based on HAVE_ST_BLKSIZE. * configure.in: Add AC_ST_BLKSIZE. * wildmat.c: New file. Fri Sep 4 01:28:51 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu) * sdiff.c (xmalloc): Renamed from ck_malloc. Callers changed. Thu Sep 3 15:28:59 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * diff.h: Don't declare free, index, rindex. Tue Aug 11 22:18:06 1992 John Gilmore (gnu at cygnus.com) * io.c (binary_file_p): Use heuristic to avoid declaring info files as binary files. Allow about 1.5% non-printing characters (in info's case, ^_). Tue Jul 7 01:09:26 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * diff.h: Replace function_regexp and ignore_regexp with lists of compiled regexps. * analyze.c, context.c, util.c: Test whether the lists, not the old variables, are empty. * util.c (analyze_hunk), context.c (find_function): Compare lines with the lists of regexps. * diff.c (add_regexp): New function. (main): Use it. * diff3: Add -v --version option. * Makefile.in: Link with version.o. * system.h: New file. * diff.h, cmp.c, diff3.c, sdiff.c: Use it. * diff.h, diff3.c: Include string.h or strings.h, as appropriate. Declare malloc and realloc. * diff3.c (perror_with_exit): Include program name in message. * diff3.c: Lowercase error messages for GNU standards. * sdiff.c [USG || STDC_HEADERS]: Define bcopy in terms of memcpy. * sdiff.c: Use the version number from version.c. * Makefile.in: Link with version.o. * cmp.c error.c xmalloc.c: New files from textutils. * Makefile.in: Add rules for them. * diff.c (longopts): --unidirectional-new-file is like -P, not -N. Rename --file-label to --label (leave old name, but undocumented). * sdiff.c, diff.c (usage): Condense messages and fix some errors. * diff3.c (main, usage): Add long-named options. Fri Jul 3 14:31:18 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * diff.h, diff3.c, sdiff.c: Change FOO_MISSING macros to HAVE_FOO. Thu Jun 25 16:59:47 1992 David J. MacKenzie (djm@apple-gunkies.gnu.ai.mit.edu) * diff.c: --reversed-ed -> --forward-ed. Wed Feb 26 12:17:32 1992 Paul Eggert (eggert@yata.uucp) * analyze.c, diff.c, diff.h, io.c: For -y, compare even if same file. Fri Feb 14 22:46:38 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu) * io.c, diff3.c, analyze.c: Add extra parentheses. Sun Feb 9 00:22:42 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu) * diff.h (unidirectional_new_file_flag): New variable. * diff.c (main): Set that for -P. (compare_files): Support -P, somewhat like -N. (longopts): Support long name for -P. Sat Jan 4 20:10:34 1992 Paul Eggert (eggert at yata.uucp) * Makefile.in: Distribute diff.info-* too. * README, sdiff.c: version number now matches version.c. * configure: Fix and document vfork test. * ifdef.c: Don't dump core if `diff -Dx f f'. Mon Dec 23 23:36:08 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * diff.h, diff3.c, sdiff.c: Change POSIX ifdefs to HAVE_UNISTD_H and _POSIX_VERSION. Wed Dec 18 17:00:31 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Makefile.in (srcs): Add sdiff.c. (tapefiles): Add diff.texi and diff.info. * diff.h, diff3.c, sdiff.c: Use HAVE_VFORK_H instead of VFORK_HEADER and VFORK_WORKS. Tue Dec 17 00:02:59 1991 Paul Eggert (eggert at yata.uucp) * Makefile.in (all): Add diff.info, sdiff. * configure, diff.c, sdiff.c: Prefix long options with `--', not `+'. * diff.c: Regularize option names. * configure: Fix check for vfork. * configure, diff.c, diff.h, diff3.c, sdiff.c: Use Posix definitions when possible. * context.c: Align context with tab if -T is given. Tune. * diff.c, diff.h, side.c: Calculate column widths so that tabs line up. * io.c: Add distinction between white space and printing chars. * side.c: Don't expand tabs unless -t is given. * side.c, util.c: Tab expansion now knows about '\b', '\f', '\r', '\v'. * util.c: -w skips all white space. Remove lint. Tune. * sdiff.c: Support many more diff options, e.g. `-', `sdiff file dir'. Ignore interrupts while the subsidiary editor is in control. Clean up temporary file and kill subsidiary diff if interrupted. Ensure subsidiary diff doesn't ignore SIGPIPE. Don't get confused while waiting for two subprocesses. Don't let buffers overflow. Check for I/O errors. Convert to GNU style. Tune. * sdiff.c, util.c: Don't lose errno. Don't confuse sdiff with messages like `Binary files differ'. * sdiff.c, side.c: Don't assume that common lines are identical. Simplify --sdiff-merge-assist format. Mon Sep 16 16:42:01 1991 Tom Lord (lord at churchy.gnu.ai.mit.edu) * Makefile.in, sdiff.c: introduced sdiff front end to diff. * Makefile.in, analyze.c, diff.c, diff.h, io.c, side.c: Added sdiff-style output format to diff. Mon Aug 26 16:44:55 1991 David J. MacKenzie (djm at pogo.gnu.ai.mit.edu) * Makefile.in, configure: Only put $< in Makefile if using VPATH, because older makes don't understand it. Fri Aug 2 12:22:30 1991 David J. MacKenzie (djm at apple-gunkies) * configure: Create config.status. Remove it and Makefile if interrupted while creating them. Thu Aug 1 22:24:31 1991 David J. MacKenzie (djm at apple-gunkies) * configure: Check for +srcdir etc. arg and look for Makefile.in in that directory. Set VPATH if srcdir is not `.'. * Makefile.in: Get rid of $(archpfx). Tue Jul 30 21:28:44 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu) * Makefile.in (prefix): Renamed from DESTDIR. Wed Jul 24 23:08:56 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * diff.h, diff3.c: Rearrange ifdefs to use POSIX, STDC_HEADERS, VFORK_MISSING, DIRENT. This way it works on more systems that aren't pure USG or BSD. Don't not define const if __GNUC__ is defined -- that would break with -traditional. * configure: Check for those features. Wed Jul 10 01:39:23 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * configure, Makefile.in: $(INSTALLPROG) -> $(INSTALL). Sat Jul 6 16:39:04 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * Replace Makefile with configure and Makefile.in. Update README with current compilation instructions. Sat Jul 6 14:03:29 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu) * util.c (setup_output): Just save the args for later use. (begin_output): Do the real work, with the values that were saved. It's safe to call begin_output more than once. Print the special headers for context format here. * analyze.c (diff_2_files): Don't print special headers here. * context.c (pr_context_hunk, pr_unidiff_hunk): Call begin_output. * ed.c (print_ed_hunk, print_forward_ed_hunk, print_rcs_hunk): * normal.c (print_normal_hunk): Likewise. * ifdef.c (print_ifdef_hunk): Likewise. * util.c (finish_output): Don't die if begin_output was not called. Thu Jun 20 23:10:01 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * Makefile: Add TAGS, distclean, and realclean targets. Set SHELL. Tue Apr 30 13:54:36 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu) * diff.h (TRUE, FALSE): Undefine these before defining. Thu Mar 14 18:27:27 1991 Richard Stallman (rms@mole.ai.mit.edu) * Makefile (objs): Include $(ALLOCA). Sat Mar 9 22:34:03 1991 Richard Stallman (rms at mole.ai.mit.edu) * diff.h: Include regex.h. Thu Feb 28 18:59:53 1991 Richard Stallman (rms at mole.ai.mit.edu) * Makefile (diff3): Link with GNU getopt. Sat Feb 23 12:49:43 1991 Richard Stallman (rms at mole.ai.mit.edu) * io.c (find_equiv_class): Make hash code unsigned before mod. * diff.h (files): Add EXTERN. Sun Jan 13 21:33:01 1991 Richard Stallman (rms at mole.ai.mit.edu) * diff.c: +print option renamed +paginate. Remove +all-text. Mon Jan 7 06:18:01 1991 David J. MacKenzie (djm at geech.ai.mit.edu) * Makefile (dist): New target, replacing diff.tar and diff.tar.Z, to encode version number in distribution directory and tar file names. Sun Jan 6 18:42:23 1991 Michael I Bushnell (mib at geech.ai.mit.edu) * Version 1.15 released. * version.c: Updated from 1.15 alpha to 1.15 * context.c (print_context_number_range, print_unidiff_number_range): Don't print N,M when N=M, print just N instead. * README: Updated for version 1.15. Makefile: Updated for version 1.15. * diff3.c (main): Don't get confused if one of the arguments is a directory. * diff.c (compare_files): Don't get confused if comparing standard input to a directory; print error instead. * analyze.c (diff_2_files), context.c (print_context_header, print_context_script), diff.c (main), diff.h (enum output_style): Tread unidiff as an output style in its own right. This also generates an error when both -u and -c are given. * diff.c (main): Better error messages when regexps are bad. * diff.c (compare_files): Don't assume stdin is opened. * diff3.c (read_diff): Don't assume things about the order of descriptor assignment and closes. * util.c (setup_output): Don't assume things about the order of descriptor assignment and closes. * diff.c (compare_files): Set a flag so that closes don't happen more than once. * diff.c (main): Don't just flush stdout, do a close. That way on broken systems we can still get errors. Mon Dec 24 16:24:17 1990 Richard Stallman (rms at mole.ai.mit.edu) * diff.c (usage): Use = for args of long options. Mon Dec 17 18:19:20 1990 Michael I Bushnell (mib at geech.ai.mit.edu) * context.c (print_context_label): Labels were interchanged badly. * context.c (pr_unidiff_hunk): Changes to deal with files ending in incomplete lines. * util.c (print_1_line): Other half of the changes. Mon Dec 3 14:23:55 1990 Richard Stallman (rms at mole.ai.mit.edu) * diff.c (longopts, usage): unidiff => unified. Wed Nov 7 17:13:08 1990 Richard Stallman (rms at mole.ai.mit.edu) * analyze.c (diff_2_files): No warnings about newlines for -D. * diff.c (pr_unidiff_hunk): Remove ref to output_patch_flag. Tue Oct 23 23:19:18 1990 Richard Stallman (rms at mole.ai.mit.edu) * diff.c (compare_files): For -D, compare even args are same file. * analyze.c (diff_2_files): Likewise. Also, output even if files have no differences. * analyze.c (diff_2_files): Print missing newline messages last. Return 2 if a newline is missing. Print them even if files end with identical text. Mon Oct 22 19:40:09 1990 Richard Stallman (rms at mole.ai.mit.edu) * diff.c (usage): Return 2. Wed Oct 10 20:54:04 1990 Richard Stallman (rms at mole.ai.mit.edu) * diff.c (longopts): Add +new-files. Sun Sep 23 22:49:29 1990 Richard Stallman (rms at mole.ai.mit.edu) * context.c (print_context_script): Handle unidiff_flag. (print_context_header): Likewise. (print_unidiff_number_range, pr_unidiff_hunk): New functions. * diff.c (longopts): Add element for +unidiff. (main): Handle +unidiff and -u. (usage): Mention them. Wed Sep 5 16:33:22 1990 Richard Stallman (rms at mole.ai.mit.edu) * io.c (find_and_hash_each_line): Deal with missing final newline after buffering necessary context lines. Sat Sep 1 16:32:32 1990 Richard Stallman (rms at mole.ai.mit.edu) * io.c (find_identical_ends): ROBUST_OUTPUT_FORMAT test was backward. Thu Aug 23 17:17:20 1990 Richard Stallman (rms at mole.ai.mit.edu) * diff3.c (WIFEXITED): Undef it if WEXITSTATUS is not defined. * context.c (find_function): Don't try to return values. Wed Aug 22 11:54:39 1990 Richard Stallman (rms at mole.ai.mit.edu) * diff.h (O_RDONLY): Define if not defined. Tue Aug 21 13:49:26 1990 Richard Stallman (rms at mole.ai.mit.edu) * Handle -L option. * context.c (print_context_label): New function. (print_context_header): Use that. * diff.c (main): Recognize the option. (usage): Updated. * diff.h (file_label): New variable. * diff3.c (main): Recognize -L instead of -t. * diff3.c (main): Support -m without other option. * diff3.c (WEXITSTATUS, WIFEXITED): Define whenever not defined. * diff3.c (bcopy, index, rindex): Delete definitions; not used. (D_LINENUM, D_LINELEN): Likewise. (struct diff_block): lengths includes newlines. (struct diff3_block): Likewise. (always_text, merge): New variables. (read_diff): Return address of end, not size read. Calls changed. Pass -a to diff if given to diff3. current_chunk_size now an int. Detect error in `pipe'. Check for incomplete line of output here. (scan_diff_line): Don't make scan_ptr + 2 before knowing it is valid. No need to check validity of diff output here. Include newline in length of line. (main): Compute rev_mapping here. Handle -a and -m. Error message if excess -t operands. Error for incompatible options. Error if `-' given more than once. Fix error storing in tag_strings. (output_diff3): REV_MAPPING is now an arg. Call changed. Change syntax of "missing newline" message. Expect length of line to include newline. (output_diff3_edscript): Return just 0 or 1. REV_MAPPING is now an arg. Call changed. (output_diff3_merge): New function. (process_diff): Better error message for bad diff format. (fatal, perror_with_exit): Return status 2. * analyze.c (diff_2_files): Report missing newline in either or both files, if not robust output style. * util.c (setup_output): Detect error from pipe. No need to close stdin. * util.c (print_1_line): Change format of missing-newline msg. Change if statements to switch. * io.c (slurp): Don't mention differences in final newline if -B. * io.c (binary_file_p): Use ISO char set as criterion, not ASCII. * io.c (find_identical_ends): Increase value of BEG0 by 1. Other changes in backwards scan to avoid decrementing pointers before start of array, and set LINES properly. * diff.h (ROBUST_OUTPUT_STYLE): New macro. * io.c (find_identical_ends, find_and_hash_each_line): Use that macro. * diff.h (dup2): Don't define if XENIX. * diff.c (main): Check for write error at end. * context.c (find_function): Don't return a value. Use argument FILE rather than global files. * analyze.c: Add external function declarations. * analyze.c (build_script): Turn off explicit check for final newline. * analyze.c (discard_confusing_lines): Make integers unsigned. Tue Jul 31 21:37:16 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * io.c (find_and_hash_each_line): Correct the criterion for leaving out the newline from the end of the line. Tue May 29 21:28:16 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * dir.c (diff_dirs): Free things only if nonzero. Mon Apr 16 18:31:05 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.h (NDIR_IN_SYS): New macro controls location of ndir.h. * diff3.c (xmalloc, xrealloc): Don't die if size == 0 returns 0. Sun Mar 25 15:58:42 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * analyze.c (discard_confusing_lines): `many' wasn't being used; use it. Cancelling provisionals near start of run must handle already cancelled provisionals. Cancelling subruns of provisionals was cancelling last nonprovisional. Sat Mar 24 14:02:51 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * analyze.c (discard_confusing_lines): Threshold for line occurring many times scales by square root of total lines. Within each run, cancel any long subrun of provisionals. Don't update `provisional' while cancelling provisionals. In big outer loop, handle provisional and nonprovisional separately. Thu Mar 22 16:35:33 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * analyze.c (discard_confusing_lines): The first loops to discard provisionals from ends failed to step. In second such loops, keep discarding all consecutive provisionals. Increase threshold for stopping discarding, and also check for consecutive nondiscardables as separate threshold. Fri Mar 16 00:33:08 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff3.c (read_diff): Pass -- as first arg to diff. * diff3.c: Include wait.h or define equivalent macros. (read_diff): Don't use stdio printing error in the inferior. Remember the pid and wait for it. Report failing status. Report failure of vfork. Sun Mar 11 17:10:32 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff3.c (main): Accept -t options and pass to output_diff3_edscript. (usage): Mention -t. (read_diff): Use vfork. (vfork): Don't use it on Sparc. * diff.h (vfork): Don't use it on Sparc. Tue Mar 6 22:37:20 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff3.c (dup2): Don't define on Xenix. * Makefile: Comments for Xenix. Thu Mar 1 17:19:23 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * analyze.c (diff_2_files): `message' requires three args. Fri Feb 23 10:56:50 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * diff.h, util.c, diff3.c: Change 'void *' to 'VOID *', with VOID defined as void if __STDC__, char if not. Sun Feb 18 20:31:58 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * Makefile: Add rules for getopt.c, getopt1.c, getopt.h. * getopt.c, getopt.h, getopt1.c: New files. * main.c (main, usage): Add long options. * analyze.c (shift_boundaries): Remove unused var 'j_end'. Thu Feb 8 02:43:16 1990 Jim Kingdon (kingdon at pogo.ai.mit.edu) * GNUmakefile: include ../Makerules before Makefile. Fri Feb 2 23:21:38 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * analyze.c (diif_2_files): If -B or -I, don't return 1 if all changes were ignored. Wed Jan 24 20:43:57 1990 Richard Stallman (rms at albert.ai.mit.edu) * diff3.c (fatal): Output to stderr. Thu Jan 11 00:25:56 1990 David J. MacKenzie (djm at hobbes.ai.mit.edu) * diff.c (usage): Mention -v. Wed Jan 10 16:06:38 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff3.c (output_diff3_edscript): Return number of overlaps. (main): If have overlaps, exit with status 1. Sun Dec 24 10:29:20 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * io.c (find_equiv_class): Fix typo that came from changing init of B to an assigment. * version.c: New file. * diff.c (main): -v prints version number. * io.c (binary_file_p): Null char implies binary file. Fri Nov 17 23:44:55 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * util.c (print_1_line): Fix off by 1 error. Thu Nov 16 13:51:10 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * util.c (xcalloc): Function deleted. * io.c (slurp): Null-terminate the buffer. * io.c (read_files): Delete unused vars. * io.c (find_equiv_class): Don't index by N if too low. * dir.c (dir_sort): Delete the extra declaration of compare_names. * diff.h: Don't declare xcalloc. Declare some other functions. * analyze.c (shift_boundaries): Test for END at end of range before indexing by it. Fix typo `preceeding' in var names. Sat Nov 11 14:04:16 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff3.c (using_to_diff3_block): Delete unused vars. (make_3way_diff, process_diff_control, read_diff, output_diff3): Likewise. Mon Nov 6 18:15:50 EST 1989 Jay Fenlason (hack@ai.mit.edu) * README Fix typo. Fri Nov 3 15:27:47 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.c (usage): Mention -D. * ifdef.c (print_ifdef_hunk): Write comments on #else and #endif. Sun Oct 29 16:41:07 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.c (compare_files): Don't fflush for identical files. Wed Oct 25 17:57:12 1989 Randy Smith (randy at apple-gunkies.ai.mit.edu) * diff3.c (using_to_diff3_block): When defaulting lines from FILE0, only copy up to just under the *lowest* line mentioned in the next diff. * diff3.c (fatal): Add \n to error messages. Wed Oct 25 15:05:49 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * Makefile (tapefiles): Add ChangeLog. Tue Oct 3 00:51:17 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff3.c (process_diff, create_diff3_block): Init ->next field. Fri Sep 29 08:16:45 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * util.c (line_cmp): Alter end char of line 2, not line 1. Wed Sep 20 00:12:37 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * Makefile (diff.tar): Expect ln to fail on some files; copy them with cp. Mon Sep 18 02:54:29 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * Handle -D option: * io.c (find_and_hash_each_line): Keep all lines of 1st file. * diff.c (main): Handle -D option. (compare_files): Reject -D if files spec'd are directories. * analyze.c (diff_2_files): Handle OUTPUT_IFDEF case. Fri Sep 1 20:15:50 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.c (option_list): Rename arg VECTOR as OPTIONVEC. Mon Aug 28 17:58:27 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.c (compare_files): Clear entire inf[i].stat. Wed Aug 23 17:48:47 1989 Richard Stallman (rms at apple-gunkies.ai.mit.edu) * io.c (find_identical_ends): Sign was backward determining where to bound the scan for the suffix. Wed Aug 16 12:49:16 1989 Richard Stallman (rms at hobbes.ai.mit.edu) * analyze.c (diff_2_files): If -q, treat all files as binary. * diff.c (main): Detect -q, record in no_details_flag. Sun Jul 30 23:12:00 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.c (usage): New function. (main): Call it. Wed Jul 26 02:02:19 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.c (main): Make -C imply -c. Thu Jul 20 17:57:51 1989 Chris Hanson (cph at kleph) * io.c (find_and_hash_each_line): Bug fix in context handling, introduced by last change. Fri Jul 14 17:39:20 1989 Chris Hanson (cph at kleph) * analyze.c: To make RCS work correctly on files that don't necessarily end in newline, introduce some changes that cause diffs to be sensitive to missing final newline. Because non-RCS modes don't want to be affected by these changes, they are conditional on `output_style == OUTPUT_RCS'. (diff_2_files) [OUTPUT_RCS]: Suppress the "File X missing newline" message. (build_script) [OUTPUT_RCS]: Cause the last line to compare as different if exactly one of the files is missing its final newline. * io.c (find_and_hash_each_line): Bug fix in ignore_space_change mode. Change line's length to include the newline. For OUTPUT_RCS, decrement last line's length if there is no final newline. (find_identical_ends) [OUTPUT_RCS]: If one of the files is missing a final newline, make sure it's not included in either the prefix or suffix. * util.c (print_1_line): Change line output routine to account for line length including the newline. Tue Jun 27 02:35:28 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Makefile: Inserted $(archpfx) where appropriate. Wed May 17 20:18:43 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff3.c [USG]: Include fcntl.h. * diff.h [USG]: New compilation flags HAVE_NDIR, HAVE_DIRECT. Wed Apr 26 15:35:57 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * dir.c (diff_dirs): Two new args, NONEX1 and NONEX2, say to pretend nonex dirs are empty. (dir_sort): New arg NONEX, likewise. * diff.c (compare_files): Pass those args. Sometimes call diff_dirs if subdir exists in just one place. Wed Apr 12 01:10:27 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * io.c (find_identical_ends): Set END0 *after* last char during backward scan for suffix. Sat Apr 8 15:49:49 1989 Randall Smith (randy at apple-gunkies.ai.mit.edu) * diff3.c (using_to_diff3_block): Now find high marks in files 1 and 2 through mapping off of the last difference instead of the first. * diff3.c: Many trivial changes to spelling inside comments. Fri Feb 24 12:38:03 1989 Randall Smith (randy at gluteus.ai.mit.edu) * util.c, normal.c, io.c, ed.c, dir.c, diff.h, diff.c, context.c, analyze.c, Makefile: Changed copyright header to conform with new GNU General Public license. * diff3.c: Changed copyright header to conform with new GNU General Public license. * COPYING: Made a hard link to /gp/rms/COPYING. Fri Feb 24 10:01:58 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * io.c (slurp): Leave 2 chars space at end of buffer, not one. (find_identical_ends): Special case if either file is empty; don't try to make a sentinel since could crash. Wed Feb 15 14:24:48 1989 Jay Fenlason (hack at apple-gunkies.ai.mit.edu) * diff3.c (message) Re-wrote routine to avoid using alloca() Wed Feb 15 06:19:14 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * io.c (find_identical_ends): Delete the variable `bytes'. Sun Feb 12 11:50:36 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * io.c (slurp): ->bufsize is nominal amount we have room for; add room for sentinel when calling xmalloc or xrealloc. * io.c (find_identical_ends): Do need overrun check in finding suffix. Fri Feb 10 01:28:15 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.c (main): -C now takes arg to specify context length. Now -p to show C function name--Damned IEEE! Fatal error if context length spec'd twice. * ed.c (print_ed_hunk): Now special treatment only for lines containing precisely a dot and nothing else. Output `..', end the insert, substitute that one line, then resume the insert if nec. * io.c (find_and_hash_lines): When backing up over starting context, don't move past buffer-beg. * io.c (find_identical_ends): Use sentinels to make the loops faster. If files are identical, skip the 2nd loop and return quickly. (slurp): Leave 1 char extra space after each buffer. * analyze.c (diff_2_files): Mention difference in final newlines. Wed Jan 25 22:44:44 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * dir.c (diff_dirs): Use * when calling fcn ptr variable. Sat Dec 17 14:12:06 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * Makefile: New vars INSTALL and LIBS used in some rules; provide default defns plus commented-put defns for sysV. Thu Nov 17 16:42:53 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * dir.c (dir_sort): Open-trouble not fatal; just say # files is -1. (diff_dirs): If dir_sort does that, give up and return 2. * diff.c (compare_files): Don't open directories. Don't close them specially either. Cross-propagate inf[i].dir_p sooner. Sun Nov 13 11:19:36 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu) * diff.h: Declare index, rindex. * diff.c (compare_files): If comparing foodir with b/f, use foodir/f, not foodir/b/f. * diff.c (compare_files): Don't print "are identical" msg for 2 dirs. Status now 1 if one file is a dir and the other isn't, etc. Thu Nov 3 16:30:24 1988 Randall Smith (randy at gluteus.ai.mit.edu) * Makefile: Added a define for diff3 to define DIFF_PROGRAM. * util.c: Added hack to make sure that perror was not called with a null pointer. * diff.c: Changed S_IFDIR to S_IFMT in masking type of file bits out. * diff3.c: Included USG compatibility defines. * diff.h: Moved sys/file.h into #else USG section (not needed or wanted on System V). * ed.c, analyze.c, context.c: Shortened names to 12 characters for the sake of System V (too simple not to do). Local Variables: mode: indented-text left-margin: 8 version-control: never End: diffutils-2.4/diff.texi100666 74720 14 442755 5445364053 14136 0ustar eggertguest\input texinfo @c -*-texinfo-*- @c %**start of header @setfilename diff.info @settitle Comparing and Merging Files @setchapternewpage odd @c %**end of header @ifinfo This file documents the the GNU @code{diff}, @code{diff3}, @code{sdiff}, and @code{cmp} commands for showing the differences between text files and the @code{patch} command for using their output to update files. Copyright (C) 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. @ignore Permission is granted to process this file through TeX and print the results, provided the printed document carries copying permission notice identical to this one except for the removal of this paragraph (this paragraph not being relevant to the printed manual). @end ignore Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. @end ifinfo @titlepage @title Comparing and Merging Files @subtitle @code{diff}, @code{diff3}, @code{sdiff}, @code{cmp}, and @code{patch} @subtitle Edition 1.2, for @code{diff} 2.4 and @code{patch} 2.1 @subtitle September 1993 @author by David MacKenzie, Paul Eggert, and Richard Stallman @page @vskip 0pt plus 1filll Copyright @copyright{} 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. @end titlepage @node Top, , , (dir) @ifinfo This file documents the the GNU @code{diff}, @code{diff3}, @code{sdiff}, and @code{cmp} commands for showing the differences between text files and the @code{patch} command for using their output to update files. This is Edition 1.2, for @code{diff} 2.4 and @code{patch} 2.1. @end ifinfo @menu * Overview:: Preliminary information. * Comparison:: What file comparison means. * Output Formats:: Formats for difference reports. * Comparing Directories:: Comparing files and directories. * Adjusting Output:: Making @code{diff} output prettier. * diff Performance:: Making @code{diff} smarter or faster. * Comparing Three Files:: Formats for three-way difference reports. * diff3 Merging:: Merging from a common ancestor. * Interactive Merging:: Interactive merging with @code{sdiff}. * Merging with patch:: Using @code{patch} to change old files into new ones. * Making Patches:: Tips for making patch distributions. * Invoking cmp:: How to run @code{cmp} and a summary of its options. * Invoking diff:: How to run @code{diff} and a summary of its options. * Invoking diff3:: How to run @code{diff3} and a summary of its options. * Invoking patch:: How to run @code{patch} and a summary of its options. * Invoking sdiff:: How to run @code{sdiff} and a summary of its options. * Incomplete Lines:: Lines that lack trailing newlines. * Projects:: If you think you've found a bug or other shortcoming. * Concept Index:: Index of concepts. @end menu @node Overview, Comparison, , Top @unnumbered Overview @cindex overview of @code{diff} and @code{patch} Computer users often find occasion to ask how two files differ. Perhaps one file is a newer version of the other file. Or maybe the two files started out as identical copies but were changed by different people. You can use the @code{diff} command to show differences between two files, or each corresponding file in two directories. @code{diff} outputs differences between files line by line in any of several formats, selectable by command line options. This set of differences is often called a @dfn{diff} or @dfn{patch}. For files that are identical, @code{diff} normally produces no output; for binary (non-text) files, @code{diff} normally reports only that they are different. You can use the @code{cmp} command to show the offsets and line numbers where two files differ. @code{cmp} can also show all the characters that differ between the two files, side by side. Another way to compare two files character by character is the Emacs command @kbd{M-x compare-windows}. @xref{Other Window, , Other Window, emacs, The GNU Emacs Manual}, for more information on that command. You can use the @code{diff3} command to show differences among three files. When two people have made independent changes to a common original, @code{diff3} can report the differences between the original and the two changed versions, and can produce a merged file that contains both persons' changes together with warnings about conflicts. You can use the @code{sdiff} command to merge two files interactively. You can use the set of differences produced by @code{diff} to distribute updates to text files (such as program source code) to other people. This method is especially useful when the differences are small compared to the complete files. Given @code{diff} output, you can use the @code{patch} program to update, or @dfn{patch}, a copy of the file. If you think of @code{diff} as subtracting one file from another to produce their difference, you can think of @code{patch} as adding the difference to one file to reproduce the other. This manual first concentrates on making diffs, and later shows how to use diffs to update files. GNU @code{diff} was written by Mike Haertel, David Hayes, Richard Stallman, Len Tower, and Paul Eggert. Wayne Davison designed and implemented the unified output format. The basic algorithm is described in ``An O(ND) Difference Algorithm and its Variations'', Eugene Myers, @cite{Algorithmica} Vol. 1 No. 2, 1986, p. 251; and in ``A File Comparison Program'', W. Miller and E. Myers, @cite{Software Practice and Experience} Vol. 15 No. 11, 1985, p. 1025. @c From: "Gene Myers" @c They are about the same basic algorithm; the Algorithmica @c paper gives a rigorous treatment and the sub-algorithm for @c delivering scripts and should be the primary reference, but @c both should be mentioned. GNU @code{diff3} was written by Randy Smith. GNU @code{sdiff} was written by Thomas Lord. GNU @code{cmp} was written by Torbjorn Granlund and David MacKenzie. @code{patch} was written mainly by Larry Wall; the GNU enhancements were written mainly by Wayne Davison and David MacKenzie. Parts of this manual are adapted from a manual page written by Larry Wall, with his permission. @node Comparison, Output Formats, Overview, Top @chapter What Comparison Means @cindex introduction There are several ways to think about the differences between two files. One way to think of the differences is as a series of lines that were deleted from, inserted in, or changed in one file to produce the other file. @code{diff} compares two files line by line, finds groups of lines that differ, and reports each group of differing lines. It can report the differing lines in several formats, which have different purposes. GNU @code{diff} can show whether files are different without detailing the differences. It also provides ways to suppress certain kinds of differences that are not important to you. Most commonly, such differences are changes in the amount of white space between words or lines. @code{diff} also provides ways to suppress differences in alphabetic case or in lines that match a regular expression that you provide. These options can accumulate; for example, you can ignore changes in both white space and alphabetic case. Another way to think of the differences between two files is as a sequence of pairs of characters that can be either identical or different. @code{cmp} reports the differences between two files character by character, instead of line by line. As a result, it is more useful than @code{diff} for comparing binary files. For text files, @code{cmp} is useful mainly when you want to know only whether two files are identical. For this purpose, it is better than @code{diff} because it is much faster. To illustrate the effect that considering changes character by character can have compared with considering them line by line, think of what happens if a single newline character is added to the beginning of a file. If that file is then compared with an otherwise identical file that lacks the newline at the beginning, @code{diff} will report that a blank line has been added to the file, while @code{cmp} will report that almost every character of the two files differs. @code{diff3} normally compares three input files line by line, finds groups of lines that differ, and reports each group of differing lines. Its output is designed to make it easy to inspect two different sets of changes to the same file. @menu * Hunks:: Groups of differing lines. * White Space:: Suppressing differences in white space. * Blank Lines:: Suppressing differences in blank lines. * Case Folding:: Suppressing differences in alphabetic case. * Specified Folding:: Suppressing differences that match regular expressions. * Brief:: Summarizing which files are different. * Binary:: Comparing binary files or forcing text comparisons. @end menu @node Hunks, White Space, , Comparison @section Hunks @cindex hunks When comparing two files, @code{diff} finds sequences of lines common to both files, interspersed with groups of differing lines called @dfn{hunks}. Comparing two identical files yields one sequence of common lines and no hunks, because no lines differ. Comparing two entirely different files yields no common lines and one large hunk that contains all lines of both files. In general, there are many ways to match up lines between two given files. @code{diff} tries to minimize the total hunk size by finding large sequences of common lines interspersed with small hunks of differing lines. For example, suppose the file @file{F} contains the three lines @samp{a}, @samp{b}, @samp{c}, and the file @file{G} contains the same three lines in reverse order @samp{c}, @samp{b}, @samp{a}. If @code{diff} finds the line @samp{c} as common, then the command @samp{diff F G} produces this output: @example 1,2d0 < a < b 3a2,3 > b > a @end example @noindent But if @code{diff} notices the common line @samp{b} instead, it produces this output: @example 1c1 < a --- > c 3c3 < c --- > a @end example @noindent It is also possible to find @samp{a} as the common line. @code{diff} does not always find an optimal matching between the files; it takes shortcuts to run faster. But its output is usually close to the shortest possible. You can adjust this tradeoff with the @samp{--minimal} option (@pxref{diff Performance}). @node White Space, Blank Lines, Hunks, Comparison @section Suppressing Differences in Blank and Tab Spacing @cindex blank and tab difference suppression @cindex tab and blank difference suppression The @samp{-b} and @samp{--ignore-space-change} options ignore white space at line end, and considers all other sequences of one or more white space characters to be equivalent. With these options, @code{diff} considers the following two lines to be equivalent, where @samp{$} denotes the line end: @example Here lyeth muche rychnesse in lytell space. -- John Heywood$ Here lyeth muche rychnesse in lytell space. -- John Heywood $ @end example The @samp{-w} and @samp{--ignore-all-space} options are stronger than @samp{-b}. They ignore difference even if one file has white space where the other file has none. @dfn{White space} characters include tab, vertical tab, form feed, carriage return, and space; some locales may define additional characters to be white space. With these options, @code{diff} considers the following two lines to be equivalent, where @samp{$} denotes the line end and @samp{^M} denotes a carriage return: @example Here lyeth muche rychnesse in lytell space.-- John Heywood$ He relyeth much erychnes seinly tells pace. --John Heywood ^M$ @end example @node Blank Lines, Case Folding, White Space, Comparison @section Suppressing Differences in Blank Lines @cindex blank line difference suppression The @samp{-B} and @samp{--ignore-blank-lines} options ignore insertions or deletions of blank lines. These options normally affect only lines that are completely empty; they do not affect lines that look empty but contain space or tab characters. With these options, for example, a file containing @example 1. A point is that which has no part. 2. A line is breadthless length. -- Euclid, The Elements, I @end example @noindent is considered identical to a file containing @example 1. A point is that which has no part. 2. A line is breadthless length. -- Euclid, The Elements, I @end example @node Case Folding, Specified Folding, Blank Lines, Comparison @section Suppressing Case Differences @cindex case difference suppression GNU @code{diff} can treat lowercase letters as equivalent to their uppercase counterparts, so that, for example, it considers @samp{Funky Stuff}, @samp{funky STUFF}, and @samp{fUNKy stuFf} to all be the same. To request this, use the @samp{-i} or @samp{--ignore-case} option. @node Specified Folding, Brief, Case Folding, Comparison @section Suppressing Lines Matching a Regular Expression @cindex regular expression suppression To ignore insertions and deletions of lines that match a regular expression, use the @samp{-I @var{regexp}} or @samp{--ignore-matching-lines=@var{regexp}} option. You should escape regular expressions that contain shell metacharacters to prevent the shell from expanding them. For example, @samp{diff -I '^[0-9]'} ignores all changes to lines beginning with a digit. However, @samp{-I} only ignores the insertion or deletion of lines that contain the regular expression if every changed line in the hunk---every insertion and every deletion---matches the regular expression. In other words, for each nonignorable change, @code{diff} prints the complete set of changes in its vicinity, including the ignorable ones. You can specify more than one regular expression for lines to ignore by using more than one @samp{-I} option. @code{diff} tries to match each line against each regular expression, starting with the last one given. @node Brief, Binary, Specified Folding, Comparison @section Summarizing Which Files Differ @cindex summarizing which files differ @cindex brief difference reports When you only want to find out whether files are different, and you don't care what the differences are, you can use the summary output format. In this format, instead of showing the differences between the files, @code{diff} simply reports whether files differ. The @samp{-q} and @samp{--brief} options select this output format. This format is especially useful when comparing the contents of two directories. It is also much faster than doing the normal line by line comparisons, because @code{diff} can stop analyzing the files as soon as it knows that there are any differences. You can also get a brief indication of whether two files differ by using @code{cmp}. For files that are identical, @code{cmp} produces no output. When the files differ, by default, @code{cmp} outputs the byte offset and line number where the first difference occurs. You can use the @samp{-s} option to suppress that information, so that @code{cmp} produces no output and reports whether the files differ using only its exit status (@pxref{Invoking cmp}). @c Fix this. Unlike @code{diff}, @code{cmp} cannot compare directories; it can only compare two files. @node Binary, , Brief, Comparison @section Binary Files and Forcing Text Comparisons @cindex binary file diff @cindex text versus binary diff If @code{diff} thinks that either of the two files it is comparing is binary (a non-text file), it normally treats that pair of files much as if the summary output format had been selected (@pxref{Brief}), and reports only that the binary files are different. This is because line by line comparisons are usually not meaningful for binary files. @code{diff} determines whether a file is text or binary by checking the first few bytes in the file; the exact number of bytes is system dependent, but it is typically several thousand. If every character in that part of the file is non-null, @code{diff} considers the file to be text; otherwise it considers the file to be binary. Sometimes you might want to force @code{diff} to consider files to be text. For example, you might be comparing text files that contain null characters; @code{diff} would erroneously decide that those are non-text files. Or you might be comparing documents that are in a format used by a word processing system that uses null characters to indicate special formatting. You can force @code{diff} to consider all files to be text files, and compare them line by line, by using the @samp{-a} or @samp{--text} option. If the files you compare using this option do not in fact contain text, they will probably contain few newline characters, and the @code{diff} output will consist of hunks showing differences between long lines of whatever characters the files contain. You can also force @code{diff} to consider all files to be binary files, and report only whether they differ (but not how). Use the @samp{--brief} option for this. If you want to compare two files byte by byte, you can use the @code{cmp} program with the @samp{-l} option to show the values of each differing byte in the two files. With GNU @code{cmp}, you can also use the @samp{-c} option to show the ASCII representation of those bytes. @xref{Invoking cmp}, for more information. If @code{diff3} thinks that any of the files it is comparing is binary (a non-text file), it normally reports an error, because such comparisons are usually not useful. @code{diff3} uses the same test as @code{diff} to decide whether a file is binary. As with @code{diff}, if the input files contain a few non-text characters but otherwise are like text files, you can force @code{diff3} to consider all files to be text files and compare them line by line by using the @samp{-a} or @samp{--text} options. @node Output Formats, Comparing Directories, Comparison, Top @chapter @code{diff} Output Formats @cindex output formats @cindex format of @code{diff} output @code{diff} has several mutually exclusive options for output format. The following sections describe each format, illustrating how @code{diff} reports the differences between two sample input files. @menu * Sample diff Input:: Sample @code{diff} input files for examples. * Normal:: Showing differences without surrounding text. * Context:: Showing differences with the surrounding text. * Side by Side:: Showing differences in two columns. * Scripts:: Generating scripts for other programs. * If-then-else:: Merging files with if-then-else. @end menu @node Sample diff Input, Normal, , Output Formats @section Two Sample Input Files @cindex @code{diff} sample input @cindex sample input for @code{diff} Here are two sample files that we will use in numerous examples to illustrate the output of @code{diff} and how various options can change it. This is the file @file{lao}: @example The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; The Named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their outcome. The two are the same, But after they are produced, they have different names. @end example This is the file @file{tzu}: @example The Nameless is the origin of Heaven and Earth; The named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their outcome. The two are the same, But after they are produced, they have different names. They both may be called deep and profound. Deeper and more profound, The door of all subtleties! @end example In this example, the first hunk contains just the first two lines of @file{lao}, the second hunk contains the fourth line of @file{lao} opposing the second and third lines of @file{tzu}, and the last hunk contains just the last three lines of @file{tzu}. @node Normal, Context, Sample diff Input, Output Formats @section Showing Differences Without Context @cindex normal output format @cindex @samp{<} output format The ``normal'' @code{diff} output format shows each hunk of differences without any surrounding context. Sometimes such output is the clearest way to see how lines have changed, without the clutter of nearby unchanged lines (although you can get similar results with the context or unified formats by using 0 lines of context). However, this format is no longer widely used for sending out patches; for that purpose, the context format (@pxref{Context Format}) and the unified format (@pxref{Unified Format}) are superior. Normal format is the default for compatibility with older versions of @code{diff} and the Posix standard. @menu * Detailed Normal:: A detailed description of normal output format. * Example Normal:: Sample output in the normal format. @end menu @node Detailed Normal, Example Normal, , Normal @subsection Detailed Description of Normal Format The normal output format consists of one or more hunks of differences; each hunk shows one area where the files differ. Normal format hunks look like this: @example @var{change-command} < @var{from-file-line} < @var{from-file-line}@dots{} --- > @var{to-file-line} > @var{to-file-line}@dots{} @end example There are three types of change commands. Each consists of a line number or comma-separated range of lines in the first file, a single character indicating the kind of change to make, and a line number or comma-separated range of lines in the second file. All line numbers are the original line numbers in each file. The types of change commands are: @table @samp @item @var{l}a@var{r} Add the lines in range @var{r} of the second file after line @var{l} of the first file. For example, @samp{8a12,15} means append lines 12--15 of file 2 after line 8 of file 1; or, if changing file 2 into file 1, delete lines 12--15 of file 2. @item @var{f}c@var{t} Replace the lines in range @var{f} of the first file with lines in range @var{t} of the second file. This is like a combined add and delete, but more compact. For example, @samp{5,7c8,10} means change lines 5--7 of file 1 to read as lines 8--10 of file 2; or, if changing file 2 into file 1, change lines 8--10 of file 2 to read as lines 5--7 of file 1. @item @var{r}d@var{l} Delete the lines in range @var{r} from the first file; line @var{l} is where they would have appeared in the second file had they not been deleted. For example, @samp{5,7d3} means delete lines 5--7 of file 1; or, if changing file 2 into file 1, append lines 5--7 of file 1 after line 3 of file 2. @end table @node Example Normal, , Detailed Normal, Normal @subsection An Example of Normal Format Here is the output of the command @samp{diff lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files). Notice that it shows only the lines that are different between the two files. @example 1,2d0 < The Way that can be told of is not the eternal Way; < The name that can be named is not the eternal name. 4c2,3 < The Named is the mother of all things. --- > The named is the mother of all things. > 11a11,13 > They both may be called deep and profound. > Deeper and more profound, > The door of all subtleties! @end example @node Context, Side by Side, Normal, Output Formats @section Showing Differences in Their Context @cindex context output format @cindex @samp{!} output format Usually, when you are looking at the differences between files, you will also want to see the parts of the files near the lines that differ, to help you understand exactly what has changed. These nearby parts of the files are called the @dfn{context}. GNU @code{diff} provides two output formats that show context around the differing lines: @dfn{context format} and @dfn{unified format}. It can optionally show in which function or section of the file the differing lines are found. If you are distributing new versions of files to other people in the form of @code{diff} output, you should use one of the output formats that show context so that they can apply the diffs even if they have made small changes of their own to the files. @code{patch} can apply the diffs in this case by searching in the files for the lines of context around the differing lines; if those lines are actually a few lines away from where the diff says they are, @code{patch} can adjust the line numbers accordingly and still apply the diff correctly. @xref{Imperfect}, for more information on using @code{patch} to apply imperfect diffs. @menu * Context Format:: An output format that shows surrounding lines. * Unified Format:: A more compact output format that shows context. * Sections:: Showing which sections of the files differences are in. * Alternate Names:: Showing alternate file names in context headers. @end menu @node Context Format, Unified Format, , Context @subsection Context Format The context output format shows several lines of context around the lines that differ. It is the standard format for distributing updates to source code. To select this output format, use the @samp{-C @var{lines}}, @samp{--context@r{[}=@var{lines}@r{]}}, or @samp{-c} option. The argument @var{lines} that some of these options take is the number of lines of context to show. If you do not specify @var{lines}, it defaults to three. For proper operation, @code{patch} typically needs at least two lines of context. @menu * Detailed Context:: A detailed description of the context output format. * Example Context:: Sample output in context format. * Less Context:: Another sample with less context. @end menu @node Detailed Context, Example Context, , Context Format @subsubsection Detailed Description of Context Format The context output format starts with a two-line header, which looks like this: @example *** @var{from-file} @var{from-file-modification-time} --- @var{to-file} @var{to-file-modification time} @end example @noindent You can change the header's content with the @samp{-L @var{label}} or @samp{--label=@var{label}} option; see @ref{Alternate Names}. Next come one or more hunks of differences; each hunk shows one area where the files differ. Context format hunks look like this: @example *************** *** @var{from-file-line-range} **** @var{from-file-line} @var{from-file-line}@dots{} --- @var{to-file-line-range} ---- @var{to-file-line} @var{to-file-line}@dots{} @end example The lines of context around the lines that differ start with two space characters. The lines that differ between the two files start with one of the following indicator characters, followed by a space character: @table @samp @item ! A line that is part of a group of one or more lines that changed between the two files. There is a corresponding group of lines marked with @samp{!} in the part of this hunk for the other file. @item + An ``inserted'' line in the second file that corresponds to nothing in the first file. @item - A ``deleted'' line in the first file that corresponds to nothing in the second file. @end table If all of the changes in a hunk are insertions, the lines of @var{from-file} are omitted. If all of the changes are deletions, the lines of @var{to-file} are omitted. @node Example Context, Less Context, Detailed Context, Context Format @subsubsection An Example of Context Format Here is the output of @samp{diff -c lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files). Notice that up to three lines that are not different are shown around each line that is different; they are the context lines. Also notice that the first two hunks have run together, because their contents overlap. @example *** lao Sat Jan 26 23:30:39 1991 --- tzu Sat Jan 26 23:30:50 1991 *************** *** 1,7 **** - The Way that can be told of is not the eternal Way; - The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; ! The Named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, --- 1,6 ---- The Nameless is the origin of Heaven and Earth; ! The named is the mother of all things. ! Therefore let there always be non-being, so we may see their subtlety, And let there always be being, *************** *** 9,11 **** --- 8,13 ---- The two are the same, But after they are produced, they have different names. + They both may be called deep and profound. + Deeper and more profound, + The door of all subtleties! @end example @node Less Context, , Example Context, Context Format @subsubsection An Example of Context Format with Less Context Here is the output of @samp{diff --context=1 lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files). Notice that at most one context line is reported here. @example *** lao Sat Jan 26 23:30:39 1991 --- tzu Sat Jan 26 23:30:50 1991 *************** *** 1,5 **** - The Way that can be told of is not the eternal Way; - The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; ! The Named is the mother of all things. Therefore let there always be non-being, --- 1,4 ---- The Nameless is the origin of Heaven and Earth; ! The named is the mother of all things. ! Therefore let there always be non-being, *************** *** 11 **** --- 10,13 ---- they have different names. + They both may be called deep and profound. + Deeper and more profound, + The door of all subtleties! @end example @node Unified Format, Sections, Context Format, Context @subsection Unified Format @cindex unified output format @cindex @samp{+-} output format The unified output format is a variation on the context format that is more compact because it omits redundant context lines. To select this output format, use the @samp{-U @var{lines}}, @samp{--unified@r{[}=@var{lines}@r{]}}, or @samp{-u} option. The argument @var{lines} is the number of lines of context to show. When it is not given, it defaults to three. At present, only GNU @code{diff} can produce this format and only GNU @code{patch} can automatically apply diffs in this format. For proper operation, @code{patch} typically needs at least two lines of context. @menu * Detailed Unified:: A detailed description of unified format. * Example Unified:: Sample output in unified format. @end menu @node Detailed Unified, Example Unified, , Unified Format @subsubsection Detailed Description of Unified Format The unified output format starts with a two-line header, which looks like this: @example --- @var{from-file} @var{from-file-modification-time} +++ @var{to-file} @var{to-file-modification-time} @end example @noindent You can change the header's content with the @samp{-L @var{label}} or @samp{--label=@var{label}} option; see @xref{Alternate Names}. Next come one or more hunks of differences; each hunk shows one area where the files differ. Unified format hunks look like this: @example @@@@ @var{from-file-range} @var{to-file-range} @@@@ @var{line-from-either-file} @var{line-from-either-file}@dots{} @end example The lines common to both files begin with a space character. The lines that actually differ between the two files have one of the following indicator characters in the left column: @table @samp @item + A line was added here to the first file. @item - A line was removed here from the first file. @end table @node Example Unified, , Detailed Unified, Unified Format @subsubsection An Example of Unified Format Here is the output of the command @samp{diff -u lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files): @example --- lao Sat Jan 26 23:30:39 1991 +++ tzu Sat Jan 26 23:30:50 1991 @@@@ -1,7 +1,6 @@@@ -The Way that can be told of is not the eternal Way; -The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; -The Named is the mother of all things. +The named is the mother of all things. + Therefore let there always be non-being, so we may see their subtlety, And let there always be being, @@@@ -9,3 +8,6 @@@@ The two are the same, But after they are produced, they have different names. +They both may be called deep and profound. +Deeper and more profound, +The door of all subtleties! @end example @node Sections, Alternate Names, Unified Format, Context @subsection Showing Which Sections Differences Are in @cindex headings @cindex section headings Sometimes you might want to know which part of the files each change falls in. If the files are source code, this could mean which function was changed. If the files are documents, it could mean which chapter or appendix was changed. GNU @code{diff} can show this by displaying the nearest section heading line that precedes the differing lines. Which lines are ``section headings'' is determined by a regular expression. @menu * Specified Headings:: Showing headings that match regular expressions. * C Function Headings:: Showing headings of C functions. @end menu @node Specified Headings, C Function Headings, , Sections @subsubsection Showing Lines That Match Regular Expressions @cindex specified headings @cindex regular expression matching headings To show in which sections differences occur for files that are not source code for C or similar languages, use the @samp{-F @var{regexp}} or @samp{--show-function-line=@var{regexp}} option. @code{diff} considers lines that match the argument @var{regexp} to be the beginning of a section of the file. Here are suggested regular expressions for some common languages: @c Please add to this list, e.g. Fortran, Pascal. @table @samp @item ^[A-Za-z_] C, C++, Prolog @item ^( Lisp @item ^@@\(chapter\|appendix\|unnumbered\|chapheading\) Texinfo @end table This option does not automatically select an output format; in order to use it, you must select the context format (@pxref{Context Format}) or unified format (@pxref{Unified Format}). In other output formats it has no effect. The @samp{-F} and @samp{--show-function-line} options find the nearest unchanged line that precedes each hunk of differences and matches the given regular expression. Then they add that line to the end of the line of asterisks in the context format, or to the @samp{@@@@} line in unified format. If no matching line exists, they leave the output for that hunk unchanged. If that line is more than 40 characters long, they output only the first 40 characters. You can specify more than one regular expression for such lines; @code{diff} tries to match each line against each regular expression, starting with the last one given. This means that you can use @samp{-p} and @samp{-F} together, if you wish. @node C Function Headings, , Specified Headings, Sections @subsubsection Showing C Function Headings @cindex C function headings @cindex function headings, C To show in which functions differences occur for C and similar languages, you can use the @samp{-p} or @samp{--show-c-function} option. This option automatically selects the context output format (@pxref{Context Format}), with the default number of lines of context. You can override that number with @samp{-C @var{lines}} later in the command line. You can override both the format and the number with @samp{-U @var{lines}} later in the command line. The @samp{-p} and @samp{--show-c-function} options are equivalent to @samp{-c -F'^[_a-zA-Z$]'} (@pxref{Specified Headings}). GNU @code{diff} provides them for the sake of convenience. @node Alternate Names, , Sections, Context @subsection Showing Alternate File Names @cindex alternate file names @cindex file name alternates If you are comparing two files that have meaningless or uninformative names, you might want @code{diff} to show alternate names in the header of the context and unified output formats. To do this, use the @samp{-L @var{label}} or @samp{--label=@var{label}} option. The first time you give this option, its argument replaces the name and date of the first file in the header; the second time, its argument replaces the name and date of the second file. If you give this option more than twice, @code{diff} reports an error. The @samp{-L} option does not affect the file names in the @code{pr} header when the @samp{-l} or @samp{--paginate} option is used (@pxref{Pagination}). Here are the first two lines of the output from @samp{diff -C2 -Loriginal -Lmodified lao tzu}: @example *** original --- modified @end example @node Side by Side, Scripts, Context, Output Formats @section Showing Differences Side by Side @cindex side by side @cindex two-column output @cindex columnar output @code{diff} can produce a side by side difference listing of two files. The files are listed in two columns with a gutter between them. The gutter contains one of the following markers: @table @asis @item white space The corresponding lines are in common. That is, either the lines are identical, or the difference is ignored because of one of the @samp{--ignore} options (@pxref{White Space}). @item @samp{|} The corresponding lines differ, and they are either both complete or both incomplete. @item @samp{<} The files differ and only the first file contains the line. @item @samp{>} The files differ and only the second file contains the line. @item @samp{(} Only the first file contains the line, but the difference is ignored. @item @samp{)} Only the second file contains the line, but the difference is ignored. @item @samp{\} The corresponding lines differ, and only the first line is incomplete. @item @samp{/} The corresponding lines differ, and only the second line is incomplete. @end table Normally, an output line is incomplete if and only if the lines that it contains are incomplete; @xref{Incomplete Lines}. However, when an output line represents two differing lines, one might be incomplete while the other is not. In this case, the output line is complete, but its the gutter is marked @samp{\} if the first line is incomplete, @samp{/} if the second line is. Side by side format is sometimes easiest to read, but it has limitations. It generates much wider output than usual, and truncates lines that are too long to fit. Also, it relies on lining up output more heavily than usual, so its output looks particularly bad if you use varying width fonts, nonstandard tab stops, or nonprinting characters. You can use the @code{sdiff} command to interactively merge side by side differences. @xref{Interactive Merging}, for more information on merging files. @menu * Side by Side Format:: Controlling side by side output format. * Example Side by Side:: Sample side by side output. @end menu @node Side by Side Format, Example Side by Side, , Side by Side @section Controlling Side by Side Format @cindex side by side format The @samp{-y} or @samp{--side-by-side} option selects side by side format. Because side by side output lines contain two input lines, they are wider than usual. They are normally 130 columns, which can fit onto a traditional printer line. You can set the length of output lines with the @samp{-W @var{columns}} or @samp{--width=@var{columns}} option. The output line is split into two halves of equal length, separated by a small gutter to mark differences; the right half is aligned to a tab stop so that tabs line up. Input lines that are too long to fit in half of an output line are truncated for output. The @samp{--left-column} option prints only the left column of two common lines. The @samp{--suppress-common-lines} option suppresses common lines entirely. @node Example Side by Side, , Side by Side Format, Side by Side @subsection An Example of Side by Side Format Here is the output of the command @samp{diff -y -W 72 lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files). @example The Way that can be told of is n < The name that can be named is no < The Nameless is the origin of He The Nameless is the origin of He The Named is the mother of all t | The named is the mother of all t > Therefore let there always be no Therefore let there always be no so we may see their subtlety, so we may see their subtlety, And let there always be being, And let there always be being, so we may see their outcome. so we may see their outcome. The two are the same, The two are the same, But after they are produced, But after they are produced, they have different names. they have different names. > They both may be called deep and > Deeper and more profound, > The door of all subtleties! @end example @node Scripts, If-then-else, Side by Side, Output Formats @section Making Edit Scripts @cindex script output formats Several output modes produce command scripts for editing @var{from-file} to produce @var{to-file}. @menu * ed Scripts:: Using @code{diff} to produce commands for @code{ed}. * Forward ed:: Making forward @code{ed} scripts. * RCS:: A special @code{diff} output format used by RCS. @end menu @node ed Scripts, Forward ed, , Scripts @subsection @code{ed} Scripts @cindex @code{ed} script output format @code{diff} can produce commands that direct the @code{ed} text editor to change the first file into the second file. Long ago, this was the only output mode that was suitable for editing one file into another automatically; today, with @code{patch}, it is almost obsolete. Use the @samp{-e} or @samp{--ed} option to select this output format. Like the normal format (@pxref{Normal}), this output format does not show any context; unlike the normal format, it does not include the information necessary to apply the diff in reverse (to produce the first file if all you have is the second file and the diff). If the file @file{d} contains the output of @samp{diff -e old new}, then the command @samp{(cat d && echo w) | ed - old} edits @file{old} to make it a copy of @file{new}. More generally, if @file{d1}, @file{d2}, @dots{}, @file{dN} contain the outputs of @samp{diff -e old new1}, @samp{diff -e new1 new2}, @dots{}, @samp{diff -e newN-1 newN}, respectively, then the command @samp{(cat d1 d2 @dots{} dN && echo w) | ed - old} edits @file{old} to make it a copy of @file{newN}. @menu * Detailed ed:: A detailed description of @code{ed} format. * Example ed:: A sample @code{ed} script. @end menu @node Detailed ed, Example ed, , ed Scripts @subsubsection Detailed Description of @code{ed} Format The @code{ed} output format consists of one or more hunks of differences. The changes closest to the ends of the files come first so that commands that change the number of lines do not affect how @code{ed} interprets line numbers in succeeding commands. @code{ed} format hunks look like this: @example @var{change-command} @var{to-file-line} @var{to-file-line}@dots{} . @end example Because @code{ed} uses a single period on a line to indicate the end of input, GNU @code{diff} protects lines of changes that contain a single period on a line by writing two periods instead, then writing a subsequent @code{ed} command to change the two periods into one. The @code{ed} format cannot represent an incomplete line, so if the second file ends in a changed incomplete line, @code{diff} reports an error and then pretends that a newline was appended. There are three types of change commands. Each consists of a line number or comma-separated range of lines in the first file and a single character indicating the kind of change to make. All line numbers are the original line numbers in the file. The types of change commands are: @table @samp @item @var{l}a Add text from the second file after line @var{l} in the first file. For example, @samp{8a} means to add the following lines after line 8 of file 1. @item @var{r}c Replace the lines in range @var{r} in the first file with the following lines. Like a combined add and delete, but more compact. For example, @samp{5,7c} means change lines 5--7 of file 1 to read as the text file 2. @item @var{r}d Delete the lines in range @var{r} from the first file. For example, @samp{5,7d} means delete lines 5--7 of file 1. @end table @node Example ed, , Detailed ed, ed Scripts @subsubsection Example @code{ed} Script Here is the output of @samp{diff -e lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files): @example 11a They both may be called deep and profound. Deeper and more profound, The door of all subtleties! . 4c The named is the mother of all things. . 1,2d @end example @node Forward ed, RCS, ed Scripts, Scripts @subsection Forward @code{ed} Scripts @cindex forward @code{ed} script output format @code{diff} can produce output that is like an @code{ed} script, but with hunks in forward (front to back) order. The format of the commands is also changed slightly: command characters precede the lines they modify, spaces separate line numbers in ranges, and no attempt is made to disambiguate hunk lines consisting of a single period. Like @code{ed} format, forward @code{ed} format cannot represent incomplete lines. Forward @code{ed} format is not very useful, because neither @code{ed} nor @code{patch} can apply diffs in this format. It exists mainly for compatibility with older versions of @code{diff}. Use the @samp{-f} or @samp{--forward-ed} option to select it. @node RCS, , Forward ed, Scripts @subsection RCS Scripts @cindex RCS script output format The RCS output format is designed specifically for use by the Revision Control System, which is a set of free programs used for organizing different versions and systems of files. Use the @samp{-n} or @samp{--rcs} option to select this output format. It is like the forward @code{ed} format (@pxref{Forward ed}), but it can represent arbitrary changes to the contents of a file because it avoids the forward @code{ed} format's problems with lines consisting of a single period and with incomplete lines. Instead of ending text sections with a line consisting of a single period, each command specifies the number of lines it affects; a combination of the @samp{a} and @samp{d} commands are used instead of @samp{c}. Also, if the second file ends in a changed incomplete line, then the output also ends in an incomplete line. Here is the output of @samp{diff -n lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files): @example d1 2 d4 1 a4 2 The named is the mother of all things. a11 3 They both may be called deep and profound. Deeper and more profound, The door of all subtleties! @end example @node If-then-else, , Scripts, Output Formats @section Merging Files with If-then-else @cindex merged output format @cindex if-then-else output format @cindex C if-then-else output format @cindex @code{ifdef} output format You can use @code{diff} to merge two files of C source code. The output of @code{diff} in this format contains all the lines of both files. Lines common to both files are output just once; the differing parts are separated by the C preprocessor directives @code{#ifdef @var{name}} or @code{#ifndef @var{name}}, @code{#else}, and @code{#endif}. When compiling the output, you select which version to use by either defining or leaving undefined the macro @var{name}. To merge two files, use @code{diff} with the @samp{-D @var{name}} or @samp{--ifdef=@var{name}} option. The argument @var{name} is the C preprocessor identifier to use in the @code{#ifdef} and @code{#ifndef} directives. For example, if you change an instance of @code{wait (&s)} to @code{waitpid (-1, &s, 0)} and then merge the old and new files with the @samp{--ifdef=HAVE_WAITPID} option, then the affected part of your code might look like this: @example do @{ #ifndef HAVE_WAITPID if ((w = wait (&s)) < 0 && errno != EINTR) #else /* HAVE_WAITPID */ if ((w = waitpid (-1, &s, 0)) < 0 && errno != EINTR) #endif /* HAVE_WAITPID */ return w; @} while (w != child); @end example You can specify formats for languages other than C by using line group formats and line formats, as described in the next sections. @menu * Line Group Formats:: Formats for general if-then-else line groups. * Line Formats:: Formats for each line in a line group. * Detailed If-then-else:: A detailed description of if-then-else format. * Example If-then-else:: Sample if-then-else format output. @end menu @node Line Group Formats, Line Formats, , If-then-else @subsection Line Group Formats @cindex line group formats @cindex formats for if-then-else line groups Line group formats let you specify formats suitable for many applications that allow if-then-else input, including programming languages and text formatting languages. A line group format specifies the output format for a contiguous group of similar lines. For example, the following command compares the TeX files @file{old} and @file{new}, and outputs a merged file in which old regions are surrounded by @samp{\begin@{em@}}-@samp{\end@{em@}} lines, and new regions are surrounded by @samp{\begin@{bf@}}-@samp{\end@{bf@}} lines. @example diff \ --old-group-format='\begin@{em@} %<\end@{em@} ' \ --new-group-format='\begin@{bf@} %>\end@{bf@} ' \ old new @end example The following command is equivalent to the above example, but it is a little more verbose, because it spells out the default line group formats. @example diff \ --old-group-format='\begin@{em@} %<\end@{em@} ' \ --new-group-format='\begin@{bf@} %>\end@{bf@} ' \ --unchanged-group-format='%=' \ --changed-group-format='\begin@{em@} %<\end@{em@} \begin@{bf@} %>\end@{bf@} ' \ old new @end example Here is a more advanced example, which outputs a diff listing with headers containing line numbers in a ``plain English'' style. @example diff \ --unchanged-group-format='' \ --old-group-format='-------- %dn line%(n=1?:s) deleted at %df: %<' \ --new-group-format='-------- %dN line%(N=1?:s) added after %de: %>' \ --changed-group-format='-------- %dn line%(n=1?:s) changed at %df: %<-------- to: %>' \ old new @end example To specify a line group format, use @code{diff} with one of the options listed below. You can specify up to four line group formats, one for each kind of line group. You should quote @var{format}, because it typically contains shell metacharacters. @table @samp @item --old-group-format=@var{format} These line groups are hunks containing only lines from the first file. The default old group format is the same as the changed group format if it is specified; otherwise it is a format that outputs the line group as-is. @item --new-group-format=@var{format} These line groups are hunks containing only lines from the second file. The default new group format is same as the the changed group format if it is specified; otherwise it is a format that outputs the line group as-is. @item --changed-group-format=@var{format} These line groups are hunks containing lines from both files. The default changed group format is the concatenation of the old and new group formats. @item --unchanged-group-format=@var{format} These line groups contain lines common to both files. The default unchanged group format is a format that outputs the line group as-is. @end table In a line group format, ordinary characters represent themselves; conversion specifications start with @samp{%} and have one of the following forms. @table @samp @item %< stands for the lines from the first file, including the trailing newline. Each line is formatted according to the old line format (@pxref{Line Formats}). @item %> stands for the lines from the second file, including the trailing newline. Each line is formatted according to the new line format. @item %= stands for the lines common to both files, including the trailing newline. Each line is formatted according to the unchanged line format. @item %% stands for @samp{%}. @item %c'@var{C}' where @var{C} is a single character, stands for @var{C}. @var{C} may not be a backslash or an apostrophe. For example, @samp{%c':'} stands for a colon, even inside the then-part of an if-then-else format, which a colon would normally terminate. @item %c'\@var{O}' where @var{O} is a string of 1, 2, or 3 octal digits, stands for the character with octal code @var{O}. For example, @samp{%c'\0'} stands for a null character. @item @var{F}@var{n} where @var{F} is a @code{printf} conversion specification and @var{n} is one of the following letters, stands for @var{n}'s value formatted with @var{F}. @table @samp @item e The line number of the line just before the group in the old file. @item f The line number of the first line in the group in the old file; equals @var{e} + 1. @item l The line number of the last line in the group in the old file. @item m The line number of the line just after the group in the old file; equals @var{l} + 1. @item n The number of lines in the group in the old file; equals @var{l} - @var{f} + 1. @item E, F, L, M, N Likewise, for lines in the new file. @end table The @code{printf} conversion specification can be @samp{%d}, @samp{%o}, @samp{%x}, or @samp{%X}, specifying decimal, octal, lower case hexadecimal, or upper case hexadecimal output respectively. After the @samp{%} the following options can appear in sequence: a @samp{-} specifying left-justification; an integer specifying the minimum field width; and a period followed by an optional integer specifying the minimum number of digits. For example, @samp{%5dN} prints the number of new lines in the group in a field of width 5 characters, using the @code{printf} format @code{"%5d"}. @item (@var{A}=@var{B}?@var{T}:@var{E}) If @var{A} equals @var{B} then @var{T} else @var{E}. @var{A} and @var{B} are each either a decimal constant or a single letter interpreted as above. This format spec is equivalent to @var{T} if @var{A}'s value equals @var{B}'s; otherwise it is equivalent to @var{E}. For example, @samp{%(N=0?no:%dN) line%(N=1?:s)} is equivalent to @samp{no lines} if @var{N} (the number of lines in the group in the the new file) is 0, to @samp{1 line} if @var{N} is 1, and to @samp{%dN lines} otherwise. @end table @node Line Formats, Detailed If-then-else, Line Group Formats, If-then-else @subsection Line Formats @cindex line formats Line formats control how each line taken from an input file is output as part of a line group in if-then-else format. For example, the following command outputs text with a one-column change indicator to the left of the text. The first column of output is @samp{-} for deleted lines, @samp{|} for added lines, and a space for unchanged lines. The formats contain newline characters where newlines are desired on output. @example diff \ --old-line-format='-%l ' \ --new-line-format='|%l ' \ --unchanged-line-format=' %l ' \ old new @end example To specify a line format, use one of the following options. You should quote @var{format}, since it often contains shell metacharacters. @table @samp @item --old-line-format=@var{format} formats lines just from the first file. @item --new-line-format=@var{format} formats lines just from the second file. @item --unchanged-line-format=@var{format} formats lines common to both files. @item --line-format=@var{format} formats all lines; in effect, it sets all three above options simultaneously. @end table In a line format, ordinary characters represent themselves; conversion specifications start with @samp{%} and have one of the following forms. @table @samp @item %l stands for the the contents of the line, not counting its trailing newline (if any). This format ignores whether the line is incomplete; @xref{Incomplete Lines}. @item %L stands for the the contents of the line, including its trailing newline (if any). If a line is incomplete, this format preserves its incompleteness. @item %% stands for @samp{%}. @item %c'@var{C}' where @var{C} is a single character, stands for @var{C}. @var{C} may not be a backslash or an apostrophe. For example, @samp{%c':'} stands for a colon. @item %c'\@var{O}' where @var{O} is a string of 1, 2, or 3 octal digits, stands for the character with octal code @var{O}. For example, @samp{%c'\0'} stands for a null character. @item @var{F}n where @var{F} is a @code{printf} conversion specification, stands for the line number formatted with @var{F}. For example, @samp{%.5dn} prints the line number using the @code{printf} format @code{"%.5d"}. @xref{Line Group Formats}, for more about printf conversion specifications. @end table The default line format is @samp{%l} followed by a newline character. If the input contains tab characters and it is important that they line up on output, you should ensure that @samp{%l} or @samp{%L} in a line format is just after a tab stop (e.g. by preceding @samp{%l} or @samp{%L} with a tab character), or you should use the @samp{-t} or @samp{--expand-tabs} option. Taken together, the line and line group formats let you specify many different formats. For example, the following command uses a format similar to @code{diff}'s normal format. You can tailor this command to get fine control over @code{diff}'s output. @example diff \ --old-line-format='< %l ' \ --new-line-format='> %l ' \ --old-group-format='%df%(f=l?:,%dl)d%dE %<' \ --new-group-format='%dea%dF%(F=L?:,%dL) %>' \ --changed-group-format='%df%(f=l?:,%dl)c%dF%(F=L?:,%dL) %<--- %>' \ --unchanged-group-format='' \ old new @end example @node Detailed If-then-else, Example If-then-else, Line Formats, If-then-else @subsection Detailed Description of If-then-else Format For lines common to both files, @code{diff} uses the unchanged line group format. For each hunk of differences in the merged output format, if the hunk contains only lines from the first file, @code{diff} uses the old line group format; if the hunk contains only lines from the second file, @code{diff} uses the new group format; otherwise, @code{diff} uses the changed group format. The old, new, and unchanged line formats specify the output format of lines from the first file, lines from the second file, and lines common to both files, respectively. The option @samp{--ifdef=@var{name}} is equivalent to the following sequence of options using shell syntax: @example --old-group-format='#ifndef @var{name} %<#endif /* not @var{name} */ ' \ --new-group-format='#ifdef @var{name} %>#endif /* @var{name} */ ' \ --unchanged-group-format='%=' \ --changed-group-format='#ifndef @var{name} %<#else /* @var{name} */ %>#endif /* @var{name} */ ' @end example You should carefully check the @code{diff} output for proper nesting. For example, when using the the @samp{-D @var{name}} or @samp{--ifdef=@var{name}} option, you should check that if the differing lines contain any of the C preprocessor directives @samp{#ifdef}, @samp{#ifndef}, @samp{#else}, @samp{#elif}, or @samp{#endif}, they are nested properly and match. If they don't, you must make corrections manually. It is a good idea to carefully check the resulting code anyway to make sure that it really does what you want it to; depending on how the input files were produced, the output might contain duplicate or otherwise incorrect code. The @code{patch} @samp{-D @var{name}} option behaves just like the @code{diff} @samp{-D @var{name}} option, except it operates on a file and a diff to produce a merged file; @xref{patch Options}. @node Example If-then-else, , Detailed If-then-else, If-then-else @subsection An Example of If-then-else Format Here is the output of @samp{diff -DTWO lao tzu} (@pxref{Sample diff Input}, for the complete contents of the two files): @example #ifndef TWO The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. #endif /* not TWO */ The Nameless is the origin of Heaven and Earth; #ifndef TWO The Named is the mother of all things. #else /* TWO */ The named is the mother of all things. #endif /* TWO */ Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their outcome. The two are the same, But after they are produced, they have different names. #ifdef TWO They both may be called deep and profound. Deeper and more profound, The door of all subtleties! #endif /* TWO */ @end example @node Comparing Directories, Adjusting Output, Output Formats, Top @chapter Comparing Directories You can use @code{diff} to compare some or all of the files in two directory trees. When both file name arguments to @code{diff} are directories, it compares each file that is contained in both directories, examining file names in alphabetical order. Normally @code{diff} is silent about pairs of files that contain no differences, but if you use the @samp{-s} or @samp{--report-identical-files} option, it reports pairs of identical files. Normally @code{diff} reports subdirectories common to both directories without comparing subdirectories' files, but if you use the @samp{-r} or @samp{--recursive} option, it compares every corresponding pair of files in the directory trees, as many levels deep as they go. For file names that are in only one of the directories, @code{diff} normally does not show the contents of the file that exists; it reports only that the file exists in that directory and not in the other. You can make @code{diff} act as though the file existed but was empty in the other directory, so that it outputs the entire contents of the file that actually exists. (It is output as either an insertion or a deletion, depending on whether it is in the first or the second directory given.) To do this, use the @samp{-N} or @samp{--new-file} option. If the older directory contains one or more large files that are not in the newer directory, you can make the patch smaller by using the @samp{-P} or @samp{--unidirectional-new-file} option instead of @samp{-N}. This option is like @samp{-N} except that it only inserts the contents of files that appear in the second directory but not the first (that is, files that were added). At the top of the patch, write instructions for the user applying the patch to remove the files that were deleted before applying the patch. @xref{Making Patches}, for more discussion of making patches for distribution. To ignore some files while comparing directories, use the @samp{-x @var{pattern}} or @samp{--exclude=@var{pattern}} option. This option ignores any files or subdirectories whose base names match the shell pattern @var{pattern}. Unlike in the shell, a period at the start of the base of a file name matches a wildcard at the start of a pattern. You should enclose @var{pattern} in quotes so that the shell does not expand it. For example, the option @samp{-x '*.[ao]'} ignores any file whose name ends with @samp{.a} or @samp{.o}. This option accumulates if you specify it more than once. For example, using the options @samp{-x 'RCS' -x '*,v'} ignores any file or subdirectory whose base name is @samp{RCS} or ends with @samp{,v}. If you need to give this option many times, you can instead put the patterns in a file, one pattern per line, and use the @samp{-X @var{file}} or @samp{--exclude-from=@var{file}} option. If you have been comparing two directories and stopped partway through, later you might want to continue where you left off. You can do this by using the @samp{-S @var{file}} or @samp{--starting-file=@var{file}} option. This compares only the file @var{file} and all alphabetically later files in the topmost directory level. @node Adjusting Output, diff Performance, Comparing Directories, Top @chapter Making @code{diff} Output Prettier @code{diff} provides several ways to adjust the appearance of its output. These adjustments can be applied to any output format. @menu * Tabs:: Preserving the alignment of tabstops. * Pagination:: Page numbering and timestamping @code{diff} output. @end menu @node Tabs, Pagination, , Adjusting Output @section Preserving Tabstop Alignment @cindex tabstop alignment @cindex aligning tabstops The lines of text in some of the @code{diff} output formats are preceded by one or two characters that indicate whether the text is inserted, deleted, or changed. The addition of those characters can cause tabs to move to the next tabstop, throwing off the alignment of columns in the line. GNU @code{diff} provides two ways to make tab-aligned columns line up correctly. The first way is to have @code{diff} convert all tabs into the correct number of spaces before outputting them; select this method with the @samp{-t} or @samp{--expand-tabs} option. @code{diff} assumes that tabstops are set every 8 columns. To use this form of output with @code{patch}, you must give @code{patch} the @samp{-l} or @samp{--ignore-white-space} option (@pxref{Changed White Space}, for more information). The other method for making tabs line up correctly is to add a tab character instead of a space after the indicator character at the beginning of the line. This ensures that all following tab characters are in the same position relative to tabstops that they were in the original files, so that the output is aligned correctly. Its disadvantage is that it can make long lines too long to fit on one line of the screen or the paper. It also does not work with the unified output format, which does not have a space character after the change type indicator character. Select this method with the @samp{-T} or @samp{--initial-tab} option. @node Pagination, , Tabs, Adjusting Output @section Paginating @code{diff} Output @cindex paginating @code{diff} output It can be convenient to have long output page-numbered and time-stamped. The @samp{-l} and @samp{--paginate} options do this by sending the @code{diff} output through the @code{pr} program. Here is what the page header might look like for @samp{diff -lc lao tzu}: @example Mar 11 13:37 1991 diff -lc lao tzu Page 1 @end example @node diff Performance, Comparing Three Files, Adjusting Output, Top @chapter @code{diff} Performance Tradeoffs @cindex performance of @code{diff} GNU @code{diff} runs quite efficiently; however, in some circumstances you can cause it to run faster or produce a more compact set of changes. There are two ways that you can affect the performance of GNU @code{diff} by changing the way it compares files. Performance has more than one dimension. These options improve one aspect of performance at the cost of another, or they improve performance in some cases while hurting it in others. The way that GNU @code{diff} determines which lines have changed always comes up with a near-minimal set of differences. Usually it is good enough for practical purposes. If the @code{diff} output is large, you might want @code{diff} to use a modified algorithm that sometimes produces a smaller set of differences. The @samp{-d} or @samp{--minimal} option does this; however, it can also cause @code{diff} to run more slowly than usual, so it is not the default behavior. When the files you are comparing are large and have small groups of changes scattered throughout them, you can use the @samp{-H} or @samp{--speed-large-files} option to make a different modification to the algorithm that @code{diff} uses. If the input files have a constant small density of changes, this option speeds up the comparisons without changing the output. If not, @code{diff} might produce a larger set of differences; however, the output will still be correct. Normally @code{diff} discards the prefix and suffix that is common to both files before it attempts to find a minimal set of differences. This makes @code{diff} run faster, but occasionally it may produce non-minimal output. The @samp{--horizon-lines=@var{lines}} option prevents @code{diff} from discarding the last @var{lines} lines of the prefix and the first @var{lines} lines of the suffix. This gives @code{diff} further opportunities to find a minimal output. @node Comparing Three Files, diff3 Merging, diff Performance, Top @chapter Comparing Three Files @cindex comparing three files @cindex format of @code{diff3} output Use the program @code{diff3} to compare three files and show any differences among them. (@code{diff3} can also merge files; see @ref{diff3 Merging}). The ``normal'' @code{diff3} output format shows each hunk of differences without surrounding context. Hunks are labeled depending on whether they are two-way or three-way, and lines are annotated by their location in the input files. @xref{Invoking diff3}, for more information on how to run @code{diff3}. @menu * Sample diff3 Input:: Sample @code{diff3} input for examples. * Detailed diff3 Normal:: A detailed description of normal output format. * diff3 Hunks:: The format of normal output format. * Example diff3 Normal:: Sample output in the normal format. @end menu @node Sample diff3 Input, Detailed diff3 Normal, , Comparing Three Files @section A Third Sample Input File @cindex @code{diff3} sample input @cindex sample input for @code{diff3} Here is a third sample file that will be used in examples to illustrate the output of @code{diff3} and how various options can change it. The first two files are the same that we used for @code{diff} (@pxref{Sample diff Input}). This is the third sample file, called @file{tao}: @example The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; The named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their result. The two are the same, But after they are produced, they have different names. -- The Way of Lao-Tzu, tr. Wing-tsit Chan @end example @node Detailed diff3 Normal, diff3 Hunks, Sample diff3 Input, Comparing Three Files @section Detailed Description of @code{diff3} Normal Format Each hunk begins with a line marked @samp{====}. Three-way hunks have plain @samp{====} lines, and two-way hunks have @samp{1}, @samp{2}, or @samp{3} appended to specify which of the three input files differ in that hunk. The hunks contain copies of two or three sets of input lines each preceded by one or two commands identifying where the lines came from. Normally, two spaces precede each copy of an input line to distinguish it from the commands. But with the @samp{-T} or @samp{--initial-tab} option, @code{diff3} uses a tab instead of two spaces; this lines up tabs correctly. @xref{Tabs}, for more information. Commands take the following forms: @table @samp @item @var{file}:@var{l}a This hunk appears after line @var{l} of file @var{file}, and contains no lines in that file. To edit this file to yield the other files, one must append hunk lines taken from the other files. For example, @samp{1:11a} means that the hunk follows line 11 in the first file and contains no lines from that file. @item @var{file}:@var{r}c This hunk contains the lines in the range @var{r} of file @var{file}. The range @var{r} is a comma-separated pair of line numbers, or just one number if the range is a singleton. To edit this file to yield the other files, one must change the specified lines to be the lines taken from the other files. For example, @samp{2:11,13c} means that the hunk contains lines 11 through 13 from the second file. @end table If the last line in a set of input lines is incomplete (@pxref{Incomplete Lines}), it is distinguished on output from a full line by a following line that starts with @samp{\}. @node diff3 Hunks, Example diff3 Normal, Detailed diff3 Normal, Comparing Three Files @section @code{diff3} Hunks @cindex hunks for @code{diff3} @cindex @code{diff3} hunks Groups of lines that differ in two or three of the input files are called @dfn{diff3 hunks}, by analogy with @code{diff} hunks (@pxref{Hunks}). If all three input files differ in a @code{diff3} hunk, the hunk is called a @dfn{three-way hunk}; if just two input files differ, it is a @dfn{two-way hunk}. As with @code{diff}, several solutions are possible. When comparing the files @samp{A}, @samp{B}, and @samp{C}, @code{diff3} normally finds @code{diff3} hunks by merging the two-way hunks output by the two commands @samp{diff A B} and @samp{diff A C}. This does not necessarily minimize the size of the output, but exceptions should be rare. For example, suppose @file{F} contains the three lines @samp{a}, @samp{b}, @samp{f}, @file{G} contains the lines @samp{g}, @samp{b}, @samp{g}, and @file{H} contains the lines @samp{a}, @samp{b}, @samp{h}. @samp{diff3 F G H} might output the following: @example ====2 1:1c 3:1c a 2:1c g ==== 1:3c f 2:3c g 3:3c h @end example @noindent because it found a two-way hunk containing @samp{a} in the first and third files and @samp{g} in the second file, then the single line @samp{b} common to all three files, then a three-way hunk containing the last line of each file. @node Example diff3 Normal, , diff3 Hunks, Comparing Three Files @section An Example of @code{diff3} Normal Format Here is the output of the command @samp{diff3 lao tzu tao} (@pxref{Sample diff3 Input}, for the complete contents of the files). Notice that it shows only the lines that are different among the three files. @example ====2 1:1,2c 3:1,2c The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. 2:0a ====1 1:4c The Named is the mother of all things. 2:2,3c 3:4,5c The named is the mother of all things. ====3 1:8c 2:7c so we may see their outcome. 3:9c so we may see their result. ==== 1:11a 2:11,13c They both may be called deep and profound. Deeper and more profound, The door of all subtleties! 3:13,14c -- The Way of Lao-Tzu, tr. Wing-tsit Chan @end example @node diff3 Merging, Interactive Merging, Comparing Three Files, Top @chapter Merging From a Common Ancestor @cindex merging from a common ancestor When two people have made changes to copies of the same file, @code{diff3} can produce a merged output that contains both sets of changes together with warnings about conflicts. One might imagine programs with names like @code{diff4} and @code{diff5} to compare more than three files simultaneously, but in practice the need rarely arises. You can use @code{diff3} to merge three or more sets of changes to a file by merging two change sets at a time. @code{diff3} can incorporate changes from two modified versions into a common preceding version. This lets you merge the sets of changes represented by the two newer files. Specify the common ancestor version as the second argument and the two newer versions as the first and third arguments, like this: @example diff3 @var{mine} @var{older} @var{yours} @end example @noindent You can remember the order of the arguments by noting that they are in alphabetical order. @cindex conflict @cindex overlap You can think of this as subtracting @var{older} from @var{yours} and adding the result to @var{mine}, or as merging into @var{mine} the changes that would turn @var{older} into @var{yours}. This merging is well-defined as long as @var{mine} and @var{older} match in the neighborhood of each such change. This fails to be true when all three input files differ or when only @var{older} differs; we call this a @dfn{conflict}. When all three input files differ, we call the conflict an @dfn{overlap}. @code{diff3} gives you several ways to handle overlaps and conflicts. You can omit overlaps or conflicts, or select only overlaps, or mark conflicts with special @samp{<<<<<<<} and @samp{>>>>>>>} lines. @code{diff3} can output the merge results as an @code{ed} script that that can be applied to the first file to yield the merged output. However, it is usually better to have @code{diff3} generate the merged output directly; this bypasses some problems with @code{ed}. @menu * Which Changes:: Selecting changes to incorporate. * Marking Conflicts:: Marking conflicts. * Bypassing ed:: Generating merged output directly. * Merging Incomplete Lines:: How @code{diff3} merges incomplete lines. * Saving the Changed File:: Emulating System V behavior. @end menu @node Which Changes, Marking Conflicts, , diff3 Merging @section Selecting Which Changes to Incorporate @cindex overlapping change, selection of @cindex unmerged change You can select all unmerged changes from @var{older} to @var{yours} for merging into @var{mine} with the @samp{-e} or @samp{--ed} option. You can select only the nonoverlapping unmerged changes with @samp{-3} or @samp{--easy-only}, and you can select only the overlapping changes with @samp{-x} or @samp{--overlap-only}. The @samp{-e}, @samp{-3} and @samp{-x} options select only @dfn{unmerged changes}, i.e. changes where @var{mine} and @var{yours} differ; they ignore changes from @var{older} to @var{yours} where @var{mine} and @var{yours} are identical, because they assume that such changes have already been merged. If this assumption is not a safe one, you can use the @samp{-A} or @samp{--show-all} option (@pxref{Marking Conflicts}). Here is the output of the command @code{diff3} with each of these three options (@pxref{Sample diff3 Input}, for the complete contents of the files). Notice that @samp{-e} outputs the union of the disjoint sets of changes output by @samp{-3} and @samp{-x}. Output of @samp{diff3 -e lao tzu tao}: @example 11a -- The Way of Lao-Tzu, tr. Wing-tsit Chan . 8c so we may see their result. . @end example Output of @samp{diff3 -3 lao tzu tao}: @example 8c so we may see their result. . @end example Output of @samp{diff3 -x lao tzu tao}: @example 11a -- The Way of Lao-Tzu, tr. Wing-tsit Chan . @end example @node Marking Conflicts, Bypassing ed, Which Changes, diff3 Merging @section Marking Conflicts @cindex conflict marking @cindex @samp{<<<<<<<} for marking conflicts @code{diff3} can mark conflicts in the merged output by bracketing them with special marker lines. A conflict that comes from two files @var{A} and @var{B} is marked as follows: @example <<<<<<< @var{A} @r{lines from @var{A}} ======= @r{lines from @var{B}} >>>>>>> @var{B} @end example A conflict that comes from three files @var{A}, @var{B} and @var{C} is marked as follows: @example <<<<<<< @var{A} @r{lines from @var{A}} ||||||| @var{B} @r{lines from @var{B}} ======= @r{lines from @var{C}} >>>>>>> @var{C} @end example The @samp{-A} or @samp{--show-all} option acts like the @samp{-e} option, except that it brackets conflicts, and it outputs all changes from @var{older} to @var{yours}, not just the unmerged changes. Thus, given the sample input files (@pxref{Sample diff3 Input}), @samp{diff3 -A lao tzu tao} puts brackets around the conflict where only @file{tzu} differs: @example <<<<<<< tzu ======= The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. >>>>>>> tao @end example And it outputs the three-way conflict as follows: @example <<<<<<< lao ||||||| tzu They both may be called deep and profound. Deeper and more profound, The door of all subtleties! ======= -- The Way of Lao-Tzu, tr. Wing-tsit Chan >>>>>>> tao @end example The @samp{-E} or @samp{--show-overlap} option outputs less information than the @samp{-A} or @samp{--show-all} option, because it outputs only unmerged changes, and it never outputs the contents of the second file. Thus the @samp{-E} option acts like the @samp{-e} option, except that it brackets the first and third files from three-way overlapping changes. Similarly, @samp{-X} acts like @samp{-x}, except it brackets all its (necessarily overlapping) changes. For example, for the three-way overlapping change above, the @samp{-E} and @samp{-X} options output the following: @example <<<<<<< lao ======= -- The Way of Lao-Tzu, tr. Wing-tsit Chan >>>>>>> tao @end example If you are comparing files that have meaningless or uninformative names, you can use the @samp{-L @var{label}} or @samp{--label=@var{label}} option to show alternate names in the @samp{<<<<<<<}, @samp{|||||||} and @samp{>>>>>>>} brackets. This option can be given up to three times, once for each input file. Thus @samp{diff3 -A -L X -L Y -L Z A B C} acts like @samp{diff3 -A A B C}, except that the output looks like it came from files named @samp{X}, @samp{Y} and @samp{Z} rather than from files named @samp{A}, @samp{B} and @samp{C}. @node Bypassing ed, Merging Incomplete Lines, Marking Conflicts, diff3 Merging @section Generating the Merged Output Directly @cindex merged @code{diff3} format With the @samp{-m} or @samp{--merge} option, @code{diff3} outputs the merged file directly. This is more efficient than using @code{ed} to generate it, and works even with non-text files that @code{ed} would reject. If you specify @samp{-m} without an @code{ed} script option, @samp{-A} (@samp{--show-all}) is assumed. For example, the command @samp{diff3 -m lao tzu tao} (@pxref{Sample diff3 Input} for a copy of the input files) would output the following: @example <<<<<<< tzu ======= The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. >>>>>>> tao The Nameless is the origin of Heaven and Earth; The Named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their result. The two are the same, But after they are produced, they have different names. <<<<<<< lao ||||||| tzu They both may be called deep and profound. Deeper and more profound, The door of all subtleties! ======= -- The Way of Lao-Tzu, tr. Wing-tsit Chan >>>>>>> tao @end example @node Merging Incomplete Lines, Saving the Changed File, Bypassing ed, diff3 Merging @section How @code{diff3} Merges Incomplete Lines @cindex incomplete line merging With @samp{-m}, incomplete lines (@pxref{Incomplete Lines}) are simply copied to the output as they are found; if the merged output ends in an conflict and one of the input files ends in an incomplete line, succeeding @samp{|||||||}, @samp{=======} or @samp{>>>>>>>} brackets appear somewhere other than the start of a line because they are appended to the incomplete line. Without @samp{-m}, if an @code{ed} script option is specified and an incomplete line is found, @code{diff3} generates a warning and acts as if a newline had been present. @node Saving the Changed File, , Merging Incomplete Lines, diff3 Merging @section Saving the Changed File @cindex System V @code{diff3} compatibility Traditional Unix @code{diff3} generates an @code{ed} script without the trailing @samp{w} and and @samp{q} commands that save the changes. System V @code{diff3} generates these extra commands. GNU @code{diff3} normally behaves like traditional Unix @code{diff3}, but with the @samp{-i} option it behaves like System V @code{diff3} and appends the @samp{w} and @samp{q} commands. The @samp{-i} option requires one of the @code{ed} script options @samp{-AeExX3}, and is incompatible with the merged output option @samp{-m}. @node Interactive Merging, Merging with patch, diff3 Merging, Top @chapter Interactive Merging with @code{sdiff} @cindex diff merging @cindex interactive merging With @code{sdiff}, you can merge two files interactively based on a side-by-side @samp{-y} format comparison (@pxref{Side by Side}). Use @samp{-o @var{file}} or @samp{--output=@var{file}} to specify where to put the merged text. @xref{Invoking sdiff}, for more details on the options to @code{sdiff}. Another way to merge files interactively is to use the Emacs Lisp package @code{emerge}. @xref{emerge, , emerge, emacs, The GNU Emacs Manual}, for more information. @menu * sdiff Option Summary::Summary of @code{sdiff} options. * Merge Commands:: Merging two files interactively. @end menu @node sdiff Option Summary, Merge Commands, , Interactive Merging @section Specifying @code{diff} Options to @code{sdiff} @cindex @code{sdiff} output format The following @code{sdiff} options have the same meaning as for @code{diff}. @xref{diff Options}, for the use of these options. @example -a -b -d -i -t -v -B -H -I @var{regexp} --ignore-blank-lines --ignore-case --ignore-matching-lines=@var{regexp} --ignore-space-change --left-column --minimal --speed-large-files --suppress-common-lines --expand-tabs --text --version --width=@var{columns} @end example For historical reasons, @code{sdiff} has alternate names for some options. The @samp{-l} option is equivalent to the @samp{--left-column} option, and similarly @samp{-s} is equivalent to @samp{--suppress-common-lines}. The meaning of the @code{sdiff} @samp{-w} and @samp{-W} options is interchanged from that of @code{diff}: with @code{sdiff}, @samp{-w @var{columns}} is equivalent to @samp{--width=@var{columns}}, and @samp{-W} is equivalent to @samp{--ignore-all-space}. @code{sdiff} without the @samp{-o} option is equivalent to @code{diff} with the @samp{-y} or @samp{--side-by-side} option (@pxref{Side by Side}). @node Merge Commands, , sdiff Option Summary, Interactive Merging @section Merge Commands @cindex merge commands @cindex merging interactively Groups of common lines, with a blank gutter, are copied from the first file to the output. After each group of differing lines, @code{sdiff} prompts with @samp{%} and pauses, waiting for one of the following commands. Follow each command with @key{RET}. @table @samp @item e Discard both versions. Invoke a text editor on an empty temporary file, then copy the resulting file to the output. @item eb Concatenate the two versions, edit the result in a temporary file, then copy the edited result to the output. @item el Edit a copy of the left version, then copy the result to the output. @item er Edit a copy of the right version, then copy the result to the output. @item l Copy the left version to the output. @item q Quit. @item r Copy the right version to the output. @item s Silently copy common lines. @item v Verbosely copy common lines. This is the default. @end table The text editor invoked is specified by the @code{EDITOR} environment variable if it is set. The default is system-dependent. @node Merging with patch, Making Patches, Interactive Merging, Top @chapter Merging with @code{patch} @code{patch} takes comparison output produced by @code{diff} and applies the differences to a copy of the original file, producing a patched version. With @code{patch}, you can distribute just the changes to a set of files instead of distributing the entire file set; your correspondents can apply @code{patch} to update their copy of the files with your changes. @code{patch} automatically determines the diff format, skips any leading or trailing headers, and uses the headers to determine which file to patch. This lets your correspondents feed an article or message containing a difference listing directly to @code{patch}. @code{patch} detects and warns about common problems like forward patches. It saves the original version of the files it patches, and saves any patches that it could not apply. It can also maintain a @code{patchlevel.h} file to ensures that your correspondents apply diffs in the proper order. @code{patch} accepts a series of diffs in its standard input, usually separated by headers that specify which file to patch. It applies @code{diff} hunks (@pxref{Hunks}) one by one. If a hunk does not exactly match the original file, @code{patch} uses heuristics to try to patch the file as well as it can. If no approximate match can be found, @code{patch} rejects the hunk and skips to the next hunk. @code{patch} normally replaces each file @var{f} with its new version, saving the original file in @samp{@var{f}.orig}, and putting reject hunks (if any) into @samp{@var{f}.rej}. @xref{Invoking patch}, for detailed information on the options to @code{patch}. @xref{Backups}, for more information on how @code{patch} names backup files. @xref{Rejects}, for more information on where @code{patch} puts reject hunks. @menu * patch Input:: Selecting the type of @code{patch} input. * Imperfect:: Dealing with imperfect patches. * Empty Files:: Removing empty files after patching. * Multiple Patches:: Handling multiple patches in a file specially. * patch Messages:: Messages and questions @code{patch} can produce. @end menu @node patch Input, Imperfect, , Merging with patch @section Selecting the @code{patch} Input Format @cindex @code{patch} input format @code{patch} normally determines which @code{diff} format the patch file uses by examining its contents. For patch files that contain particularly confusing leading text, you might need to use one of the following options to force @code{patch} to interpret the patch file as a certain format of diff. The output formats listed here are the only ones that @code{patch} can understand. @table @samp @item -c @itemx --context context diff. @item -e @itemx --ed @code{ed} script. @item -n @itemx --normal normal diff. @item -u @itemx --unified unified diff. @end table @node Imperfect, Empty Files, patch Input, Merging with patch @section Applying Imperfect Patches @cindex imperfect patch application @code{patch} tries to skip any leading text in the patch file, apply the diff, and then skip any trailing text. Thus you can feed a news article or mail message directly to @code{patch}, and it should work. If the entire diff is indented by a constant amount of white space, @code{patch} automatically ignores the indentation. However, certain other types of imperfect input require user intervention. @menu * Changed White Space:: When tabs and spaces don't match exactly. * Reversed Patches:: Applying reversed patches correctly. * Inexact:: Helping @code{patch} find close matches. @end menu @node Changed White Space, Reversed Patches, , Imperfect @subsection Applying Patches with Changed White Space @cindex white space in patches Sometimes mailers, editors, or other programs change spaces into tabs, or vice versa. If this happens to a patch file or an input file, the files might look the same, but @code{patch} will not be able to match them properly. If this problem occurs, use the @samp{-l} or @samp{--ignore-white-space} option, which makes @code{patch} compare white space loosely so that any sequence of white space in the patch file matches any sequence of white space in the input files. Non-white-space characters must still match exactly. Each line of the context must still match a line in the input file. @node Reversed Patches, Inexact, Changed White Space, Imperfect @subsection Applying Reversed Patches @cindex reversed patches Sometimes people run @code{diff} with the new file first instead of second. This creates a diff that is ``reversed''. To apply such patches, give @code{patch} the @samp{-R} or @samp{--reverse} option. @code{patch} then attempts to swap each hunk around before applying it. Rejects come out in the swapped format. The @samp{-R} option does not work with @code{ed} scripts because there is too little information in them to reconstruct the reverse operation. Often @code{patch} can guess that the patch is reversed. If the first hunk of a patch fails, @code{patch} reverses the hunk to see if it can apply it that way. If it can, @code{patch} asks you if you want to have the @samp{-R} option set; if it can't, @code{patch} continues to apply the patch normally. This method cannot detect a reversed patch if it is a normal diff and the first command is an append (which should have been a delete) since appends always succeed, because a null context matches anywhere. But most patches add or change lines rather than delete them, so most reversed normal diffs begin with a delete, which fails, and @code{patch} notices. If you apply a patch that you have already applied, @code{patch} thinks it is a reversed patch and offers to un-apply the patch. This could be construed as a feature. If you did this inadvertently and you don't want to un-apply the patch, just answer @samp{n} to this offer and to the subsequent ``apply anyway'' question---or type @kbd{C-c} to kill the @code{patch} process. @node Inexact, , Reversed Patches, Imperfect @subsection Helping @code{patch} Find Inexact Matches @cindex inexact patches @cindex fuzz factor when patching For context diffs, and to a lesser extent normal diffs, @code{patch} can detect when the line numbers mentioned in the patch are incorrect, and it attempts to find the correct place to apply each hunk of the patch. As a first guess, it takes the line number mentioned in the hunk, plus or minus any offset used in applying the previous hunk. If that is not the correct place, @code{patch} scans both forward and backward for a set of lines matching the context given in the hunk. First @code{patch} looks for a place where all lines of the context match. If it cannot find such a place, and it is reading a context or unified diff, and the maximum fuzz factor is set to 1 or more, then @code{patch} makes another scan, ignoring the first and last line of context. If that fails, and the maximum fuzz factor is set to 2 or more, it makes another scan, ignoring the first two and last two lines of context are ignored. It continues similarly if the maximum fuzz factor is larger. The @samp{-F @var{lines}} or @samp{--fuzz=@var{lines}} option sets the maximum fuzz factor to @var{lines}. This option only applies to context and unified diffs; it ignores up to @var{lines} lines while looking for the place to install a hunk. Note that a larger fuzz factor increases the odds of making a faulty patch. The default fuzz factor is 2; it may not be set to more than the number of lines of context in the diff, ordinarily 3. If @code{patch} cannot find a place to install a hunk of the patch, it writes the hunk out to a reject file (@pxref{Rejects}, for information on how reject files are named). It writes out rejected hunks in context format no matter what form the input patch is in. If the input is a normal or @code{ed} diff, many of the contexts are simply null. The line numbers on the hunks in the reject file may be different from those in the patch file: they show the approximate location where @code{patch} thinks the failed hunks belong in the new file rather than in the old one. As it completes each hunk, @code{patch} tells you whether the hunk succeeded or failed, and if it failed, on which line (in the new file) @code{patch} thinks the hunk should go. If this is different from the line number specified in the diff, it tells you the offset. A single large offset @emph{may} indicate that @code{patch} installed a hunk in the wrong place. @code{patch} also tells you if it used a fuzz factor to make the match, in which case you should also be slightly suspicious. @code{patch} cannot tell if the line numbers are off in an @code{ed} script, and can only detect wrong line numbers in a normal diff when it finds a change or delete command. It may have the same problem with a context diff using a fuzz factor equal to or greater than the number of lines of context shown in the diff (typically 3). In these cases, you should probably look at a context diff between your original and patched input files to see if the changes make sense. Compiling without errors is a pretty good indication that the patch worked, but not a guarantee. @code{patch} usually produces the correct results, even when it must make many guesses. However, the results are guaranteed only when the patch is applied to an exact copy of the file that the patch was generated from. @node Empty Files, Multiple Patches, Imperfect, Merging with patch @section Removing Empty Files @cindex empty files, removing @cindex removing empty files Sometimes when comparing two directories, the first directory contains a file that the second directory does not. If you give @code{diff} the @samp{-N} or @samp{--new-file} option, it outputs a diff that deletes the contents of this file. By default, @code{patch} leaves an empty file after applying such a diff. The @samp{-E} or @samp{--remove-empty-files} option to @code{patch} deletes output files that are empty after applying the diff. @node Multiple Patches, patch Messages, Empty Files, Merging with patch @section Multiple Patches in a File @cindex multiple patches If the patch file contains more than one patch, @code{patch} tries to apply each of them as if they came from separate patch files. This means that it determines the name of the file to patch for each patch, and that it examines the leading text before each patch for file names and prerequisite revision level (@pxref{Making Patches}, for more on that topic). For the second and subsequent patches in the patch file, you can give options and another original file name by separating their argument lists with a @samp{+}. However, the argument list for a second or subsequent patch may not specify a new patch file, since that does not make sense. For example, to tell @code{patch} to strip the first three slashes from the name of the first patch in the patch file and none from subsequent patches, and to use @file{code.c} as the first input file, you can use: @example patch -p3 code.c + -p0 < patchfile @end example The @samp{-S} or @samp{--skip} option ignores the current patch from the patch file, but continue looking for the next patch in the file. Thus, to ignore the first and third patches in the patch file, you can use: @example patch -S + + -S + < patch file @end example @node patch Messages, , Multiple Patches, Merging with patch @section Messages and Questions from @code{patch} @cindex @code{patch} messages and questions @cindex diagnostics from @code{patch} @cindex messages from @code{patch} @code{patch} can produce a variety of messages, especially if it has trouble decoding its input. In a few situations where it's not sure how to proceed, @code{patch} normally prompts you for more information from the keyboard. There are options to suppress printing non-fatal messages and stopping for keyboard input. The message @samp{Hmm...} indicates that @code{patch} is reading text in the patch file, attempting to determine whether there is a patch in that text, and if so, what kind of patch it is. You can inhibit all terminal output from @code{patch}, unless an error occurs, by using the @samp{-s}, @samp{--quiet}, or @samp{--silent} option. There are two ways you can prevent @code{patch} from asking you any questions. The @samp{-f} or @samp{--force} option assumes that you know what you are doing. It assumes the following: @itemize @bullet @item skip patches that do not contain file names in their headers; @item patch files even though they have the wrong version for the @samp{Prereq:} line in the patch; @item assume that patches are not reversed even if they look like they are. @end itemize The @samp{-t} or @samp{--batch} option is similar to @samp{-f}, in that it suppresses questions, but it makes somewhat different assumptions: @itemize @bullet @item skip patches that do not contain file names in their headers (the same as @samp{-f}); @item skip patches for which the file has the wrong version for the @samp{Prereq:} line in the patch; @item assume that patches are reversed if they look like they are. @end itemize @code{patch} exits with a non-zero status if it creates any reject files. When applying a set of patches in a loop, you should check the exit status, so you don't apply a later patch to a partially patched file. @node Making Patches, Invoking cmp, Merging with patch, Top @chapter Tips for Making Patch Distributions @cindex patch making tips @cindex tips for patch making Here are some things you should keep in mind if you are going to distribute patches for updating a software package. Make sure you have specified the file names correctly, either in a context diff header or with an @samp{Index:} line. If you are patching files in a subdirectory, be sure to tell the patch user to specify a @samp{-p} or @samp{--strip} option as needed. Take care to not send out reversed patches, since these make people wonder whether they have already applied the patch. To save people from partially applying a patch before other patches that should have gone before it, you can make the first patch in the patch file update a file with a name like @file{patchlevel.h} or @file{version.c}, which contains a patch level or version number. If the input file contains the wrong version number, @code{patch} will complain immediately. An even clearer way to prevent this problem is to put a @samp{Prereq:} line before the patch. If the leading text in the patch file contains a line that starts with @samp{Prereq:}, @code{patch} takes the next word from that line (normally a version number) and checks whether the next input file contains that word, preceded and followed by either white space or a newline. If not, @code{patch} prompts you for confirmation before proceeding. This makes it difficult to accidentally apply patches in the wrong order. Since @code{patch} does not handle incomplete lines properly, make sure that all the source files in your program end with a newline whenever you release a version. To create a patch that changes an older version of a package into a newer version, first make a copy of the older version in a scratch directory. Typically you do that by unpacking a @code{tar} or @code{shar} archive of the older version. You might be able to reduce the size of the patch by renaming or removing some files before making the patch. If the older version of the package contains any files that the newer version does not, or if any files have been renamed between the two versions, make a list of @code{rm} and @code{mv} commands for the user to execute in the old version directory before applying the patch. Then run those commands yourself in the scratch directory. If there are any files that you don't need to include in the patch because they can easily be rebuilt from other files (for example, @file{TAGS} and output from @code{yacc} and @code{makeinfo}), replace the versions in the scratch directory with the newer versions, using @code{rm} and @code{ln} or @code{cp}. Now you can create the patch. The de-facto standard @code{diff} format for patch distributions is context format with two lines of context, produced by giving @code{diff} the @samp{-C 2} option. Do not use less than two lines of context, because @code{patch} typically needs at least two lines for proper operation. Give @code{diff} the @samp{-P} option in case the newer version of the package contains any files that the older one does not. Make sure to specify the scratch directory first and the newer directory second. Add to the top of the patch a note telling the user any @code{rm} and @code{mv} commands to run before applying the patch. Then you can remove the scratch directory. @node Invoking cmp, Invoking diff, Making Patches, Top @chapter Invoking @code{cmp} @cindex invoking @code{cmp} @cindex @code{cmp} invocation The @code{cmp} command compares two files, and if they differ, tells the first byte and line number where they differ. Its arguments are as follows: @example cmp @var{options}@dots{} @var{from-file} @r{[}@var{to-file}@var{]} @end example The file name @samp{-} is always the standard input. @code{cmp} also uses the standard input if one file name is omitted. An exit status of 0 means no differences were found, 1 means some differences were found, and 2 means trouble. @menu * cmp Options:: Summary of options to @code{cmp}. @end menu @node cmp Options, , , Invoking cmp @section Options to @code{cmp} @cindex @code{cmp} options @cindex options for @code{cmp} Below is a summary of all of the options that GNU @code{cmp} accepts. Most options have two equivalent names, one of which is a single letter preceded by @samp{-}, and the other of which is a long name preceded by @samp{--}. Multiple single letter options (unless they take an argument) can be combined into a single command line word: @samp{-cl} is equivalent to @samp{-c -l}. @table @samp @item -c Print the differing characters. Display control characters as a @samp{^} followed by a letter of the alphabet and precede characters that have the high bit set with @samp{M-} (which stands for ``meta''). @item --ignore-initial=@var{bytes} Ignore any differences in the the first @var{bytes} bytes of the input files. Treat files with fewer than @var{bytes} bytes as if they are empty. @item -l Print the (decimal) offsets and (octal) values of all differing bytes. @item --print-chars Print the differing characters. Display control characters as a @samp{^} followed by a letter of the alphabet and precede characters that have the high bit set with @samp{M-} (which stands for ``meta''). @item --quiet @itemx -s @itemx --silent Do not print anything; only return an exit status indicating whether the files differ. @item --verbose Print the (decimal) offsets and (octal) values of all differing bytes. @end table @node Invoking diff, Invoking diff3, Invoking cmp, Top @chapter Invoking @code{diff} @cindex invoking @code{diff} @cindex @code{diff} invocation The format for running the @code{diff} command is: @example diff @var{options}@dots{} @var{from-file} @var{to-file} @end example In the simplest case, @code{diff} compares the contents of the two files @var{from-file} and @var{to-file}. A file name of @samp{-} stands for text read from the standard input. As a special case, @samp{diff - -} compares a copy of standard input to itself. If @var{from-file} is a directory and @var{to-file} is not, @code{diff} compares the file in @var{from-file} whose file name is that of @var{to-file}, and vice versa. The non-directory file must not be @samp{-}. If both @var{from-file} and @var{to-file} are directories, @code{diff} compares corresponding files in both directories, in alphabetical order; this comparison is not recursive unless the @samp{-r} or @samp{--recursive} option is given. @code{diff} never compares the actual contents of a directory as if it were a file. The file that is fully specified may not be standard input, because standard input is nameless and the notion of ``file with the same name'' does not apply. @code{diff} options begin with @samp{-}, so normally @var{from-file} and @var{to-file} may not begin with @samp{-}. However, @samp{--} as an argument by itself treats the remaining arguments as file names even if they begin with @samp{-}. An exit status of 0 means no differences were found, 1 means some differences were found, and 2 means trouble. @menu * diff Options:: Summary of options to @code{diff}. @end menu @node diff Options, , , Invoking diff @section Options to @code{diff} @cindex @code{diff} options @cindex options for @code{diff} Below is a summary of all of the options that GNU @code{diff} accepts. Most options have two equivalent names, one of which is a single letter preceded by @samp{-}, and the other of which is a long name preceded by @samp{--}. Multiple single letter options (unless they take an argument) can be combined into a single command line word: @samp{-ac} is equivalent to @samp{-a -c}. Long named options can be abbreviated to any unique prefix of their name. Brackets ([ and ]) indicate that an option takes an optional argument. @table @samp @item -@var{lines} Show @var{lines} (an integer) lines of context. This option does not specify an output format by itself; it has no effect unless it is combined with @samp{-c} (@pxref{Context Format}) or @samp{-u} (@pxref{Unified Format}). This option is obsolete. For proper operation, @code{patch} typically needs at least two lines of context. @item -a Treat all files as text and compare them line-by-line, even if they do not seem to be text. @xref{Binary}. @item -b Ignore changes in amount of white space. @xref{White Space}. @item -B Ignore changes that just insert or delete blank lines. @xref{Blank Lines}. @item --brief Report only whether the files differ, not the details of the differences. @xref{Brief}. @item -c Use the context output format. @xref{Context Format}. @item -C @var{lines} @itemx --context@r{[}=@var{lines}@r{]} Use the context output format, showing @var{lines} (an integer) lines of context, or three if @var{lines} is not given. @xref{Context Format}. For proper operation, @code{patch} typically needs at least two lines of context. @item --changed-group-format=@var{format} Use @var{format} to output a line group containing differing lines from both files in if-then-else format. @xref{Line Group Formats}. @item -d Change the algorithm perhaps find a smaller set of changes. This makes @code{diff} slower (sometimes much slower). @xref{diff Performance}. @item -D @var{name} Make merged @samp{#ifdef} format output, conditional on the preprocessor macro @var{name}. @xref{If-then-else}. @item -e @itemx --ed Make output that is a valid @code{ed} script. @xref{ed Scripts}. @item --exclude=@var{pattern} When comparing directories, ignore files and subdirectories whose basenames match @var{pattern}. @xref{Comparing Directories}. @item --exclude-from=@var{file} When comparing directories, ignore files and subdirectories whose basenames match any pattern contained in @var{file}. @xref{Comparing Directories}. @item --expand-tabs Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files. @xref{Tabs}. @item -f Make output that looks vaguely like an @code{ed} script but has changes in the order they appear in the file. @xref{Forward ed}. @item -F @var{regexp} In context and unified format, for each hunk of differences, show some of the last preceding line that matches @var{regexp}. @xref{Specified Headings}. @item --forward-ed Make output that looks vaguely like an @code{ed} script but has changes in the order they appear in the file. @xref{Forward ed}. @item -h This option currently has no effect; it is present for Unix compatibility. @item -H Use heuristics to speed handling of large files that have numerous scattered small changes. @xref{diff Performance}. @item --horizon-lines=@var{lines} Do not discard the last @var{lines} lines of the common prefix and the first @var{lines} lines of the common suffix. @xref{diff Performance}. @item -i Ignore changes in case; consider upper- and lower-case letters equivalent. @xref{Case Folding}. @item -I @var{regexp} Ignore changes that just insert or delete lines that match @var{regexp}. @xref{Specified Folding}. @item --ifdef=@var{name} Make merged if-then-else output using @var{format}. @xref{If-then-else}. @item --ignore-all-space Ignore white space when comparing lines. @xref{White Space}. @item --ignore-blank-lines Ignore changes that just insert or delete blank lines. @xref{Blank Lines}. @item --ignore-case Ignore changes in case; consider upper- and lower-case to be the same. @xref{Case Folding}. @item --ignore-matching-lines=@var{regexp} Ignore changes that just insert or delete lines that match @var{regexp}. @xref{Specified Folding}. @item --ignore-space-change Ignore changes in amount of white space. @xref{White Space}. @item --initial-tab Output a tab rather than a space before the text of a line in normal or context format. This causes the alignment of tabs in the line to look normal. @xref{Tabs}. @item -l Pass the output through @code{pr} to paginate it. @xref{Pagination}. @item -L @var{label} Use @var{label} instead of the file name in the context format (@pxref{Context Format}) and unified format (@pxref{Unified Format}) headers. @xref{RCS}. @item --label=@var{label} Use @var{label} instead of the file name in the context format (@pxref{Context Format}) and unified format (@pxref{Unified Format}) headers. @item --left-column Print only the left column of two common lines in side by side format. @xref{Side by Side Format}. @item --line-format=@var{format} Use @var{format} to output all input lines in if-then-else format. @xref{Line Formats}. @item --minimal Change the algorithm to perhaps find a smaller set of changes. This makes @code{diff} slower (sometimes much slower). @xref{diff Performance}. @item -n Output RCS-format diffs; like @samp{-f} except that each command specifies the number of lines affected. @xref{RCS}. @item -N @itemx --new-file In directory comparison, if a file is found in only one directory, treat it as present but empty in the other directory. @xref{Comparing Directories}. @item --new-group-format=@var{format} Use @var{format} to output a group of lines taken from just the second file in if-then-else format. @xref{Line Group Formats}. @item --new-line-format=@var{format} Use @var{format} to output a line taken from just the second file in if-then-else format. @xref{Line Formats}. @item --old-group-format=@var{format} Use @var{format} to output a group of lines taken from just the first file in if-then-else format. @xref{Line Group Formats}. @item --old-line-format=@var{format} Use @var{format} to output a line taken from just the first file in if-then-else format. @xref{Line Formats}. @item -p Show which C function each change is in. @xref{C Function Headings}. @item -P When comparing directories, if a file appears only in the second directory of the two, treat it as present but empty in the other. @xref{Comparing Directories}. @item --paginate Pass the output through @code{pr} to paginate it. @xref{Pagination}. @item -q Report only whether the files differ, not the details of the differences. @xref{Brief}. @item -r When comparing directories, recursively compare any subdirectories found. @xref{Comparing Directories}. @item --rcs Output RCS-format diffs; like @samp{-f} except that each command specifies the number of lines affected. @xref{RCS}. @item --recursive When comparing directories, recursively compare any subdirectories found. @xref{Comparing Directories}. @item --report-identical-files Report when two files are the same. @xref{Comparing Directories}. @item -s Report when two files are the same. @xref{Comparing Directories}. @item -S @var{file} When comparing directories, start with the file @var{file}. This is used for resuming an aborted comparison. @xref{Comparing Directories}. @item --sdiff-merge-assist Print extra information to help @code{sdiff}. @code{sdiff} uses this option when it runs @code{diff}. This option is not intended for users to use directly. @item --show-c-function Show which C function each change is in. @xref{C Function Headings}. @item --show-function-line=@var{regexp} In context and unified format, for each hunk of differences, show some of the last preceding line that matches @var{regexp}. @xref{Specified Headings}. @item --side-by-side Use the side by side output format. @xref{Side by Side Format}. @item --speed-large-files Use heuristics to speed handling of large files that have numerous scattered small changes. @xref{diff Performance}. @item --starting-file=@var{file} When comparing directories, start with the file @var{file}. This is used for resuming an aborted comparison. @xref{Comparing Directories}. @item --suppress-common-lines Do not print common lines in side by side format. @xref{Side by Side Format}. @item -t Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files. @xref{Tabs}. @item -T Output a tab rather than a space before the text of a line in normal or context format. This causes the alignment of tabs in the line to look normal. @xref{Tabs}. @item --text Treat all files as text and compare them line-by-line, even if they do not appear to be text. @xref{Binary}. @item -u Use the unified output format. @xref{Unified Format}. @item --unchanged-group-format=@var{format} Use @var{format} to output a group of common lines taken from both files in if-then-else format. @xref{Line Group Formats}. @item --unchanged-line-format=@var{format} Use @var{format} to output a line common to both files in if-then-else format. @xref{Line Formats}. @item --unidirectional-new-file When comparing directories, if a file appears only in the second directory of the two, treat it as present but empty in the other. @xref{Comparing Directories}. @item -U @var{lines} @itemx --unified@r{[}=@var{lines}@r{]} Use the unified output format, showing @var{lines} (an integer) lines of context, or three if @var{lines} is not given. @xref{Unified Format}. For proper operation, @code{patch} typically needs at least two lines of context. @item -v @itemx --version Output the version number of @code{diff}. @item -w Ignore white space when comparing lines. @xref{White Space}. @item -W @var{columns} @itemx --width=@var{columns} Use an output width of @var{columns} in side by side format. @xref{Side by Side Format}. @item -x @var{pattern} When comparing directories, ignore files and subdirectories whose basenames match @var{pattern}. @xref{Comparing Directories}. @item -X @var{file} When comparing directories, ignore files and subdirectories whose basenames match any pattern contained in @var{file}. @xref{Comparing Directories}. @item -y Use the side by side output format. @xref{Side by Side Format}. @end table @node Invoking diff3, Invoking patch, Invoking diff, Top @chapter Invoking @code{diff3} @cindex invoking @code{diff3} @cindex @code{diff3} invocation The @code{diff3} command compares three files and outputs descriptions of their differences. Its arguments are as follows: @example diff3 @var{options}@dots{} @var{mine} @var{older} @var{yours} @end example The files to compare are @var{mine}, @var{older}, and @var{yours}. At most one of these three file names may be @samp{-}, which tells @code{diff3} to read the standard input for that file. An exit status of 0 means @code{diff3} was successful, 1 means some conflicts were found, and 2 means trouble. @menu * diff3 Options:: Summary of options to @code{diff3}. @end menu @node diff3 Options, , , Invoking diff3 @section Options to @code{diff3} @cindex @code{diff3} options @cindex options for @code{diff3} Below is a summary of all of the options that GNU @code{diff3} accepts. Multiple single letter options (unless they take an argument) can be combined into a single command line argument. @table @samp @item -a Treat all files as text and compare them line-by-line, even if they do not appear to be text. @xref{Binary}. @item -A Incorporate all changes from @var{older} to @var{yours} into @var{mine}, surrounding all conflicts with bracket lines. @xref{Marking Conflicts}. @item -e Generate an @code{ed} script that incorporates all the changes from @var{older} to @var{yours} into @var{mine}. @xref{Which Changes}. @item -E Like @samp{-e}, except bracket lines from overlapping changes' first and third files. @xref{Marking Conflicts}. With @samp{-e}, an overlapping change looks like this: @example <<<<<<< @var{mine} @r{lines from @var{mine}} ======= @r{lines from @var{yours}} >>>>>>> @var{yours} @end example @item --ed Generate an @code{ed} script that incorporates all the changes from @var{older} to @var{yours} into @var{mine}. @xref{Which Changes}. @item --easy-only Like @samp{-e}, except output only the nonoverlapping changes. @xref{Which Changes}. @item -i Generate @samp{w} and @samp{q} commands at the end of the @code{ed} script for System V compatibility. This option must be combined with one of the @samp{-AeExX3} options, and may not be combined with @samp{-m}. @xref{Saving the Changed File}. @item --initial-tab Output a tab rather than two spaces before the text of a line in normal format. This causes the alignment of tabs in the line to look normal. @xref{Tabs}. @item -L @var{label} @itemx --label=@var{label} Use the label @var{label} for the brackets output by the @samp{-A}, @samp{-E} and @samp{-X} options. This option may be given up to three times, one for each input file. The default labels are the names of the input files. Thus @samp{diff3 -L X -L Y -L Z -m A B C} acts like @samp{diff3 -m A B C}, except that the output looks like it came from files named @samp{X}, @samp{Y} and @samp{Z} rather than from files named @samp{A}, @samp{B} and @samp{C}. @xref{Marking Conflicts}. @item -m @itemx --merge Apply the edit script to the first file and send the result to standard output. Unlike piping the output from @code{diff3} to @code{ed}, this works even for binary files and incomplete lines. @samp{-A} is assumed if no edit script option is specified. @xref{Bypassing ed}. @item --overlap-only Like @samp{-e}, except output only the overlapping changes. @xref{Which Changes}. @item --show-all Incorporate all unmerged changes from @var{older} to @var{yours} into @var{mine}, surrounding all overlapping changes with bracket lines. @xref{Marking Conflicts}. @item --show-overlap Like @samp{-e}, except bracket lines from overlapping changes' first and third files. @xref{Marking Conflicts}. @item -T Output a tab rather than two spaces before the text of a line in normal format. This causes the alignment of tabs in the line to look normal. @xref{Tabs}. @item --text Treat all files as text and compare them line-by-line, even if they do not appear to be text. @xref{Binary}. @item -v @itemx --version Output the version number of @code{diff3}. @item -x Like @samp{-e}, except output only the overlapping changes. @xref{Which Changes}. @item -X Like @samp{-E}, except output only the overlapping changes. In other words, like @samp{-x}, except bracket changes as in @samp{-E}. @xref{Marking Conflicts}. @item -3 Like @samp{-e}, except output only the nonoverlapping changes. @xref{Which Changes}. @end table @node Invoking patch, Invoking sdiff, Invoking diff3, Top @chapter Invoking @code{patch} @cindex invoking @code{patch} @cindex @code{patch} invocation Normally @code{patch} is invoked like this: @example patch <@var{patchfile} @end example The full format for invoking @code{patch} is: @example patch @var{options}@dots{} @r{[}@var{origfile} @r{[}@var{patchfile}@r{]}@r{]} @r{[}+ @var{options}@dots{} @r{[}@var{origfile}@r{]}@r{]}@dots{} @end example If you do not specify @var{patchfile}, or if @var{patchfile} is @samp{-}, @code{patch} reads the patch (that is, the @code{diff} output) from the standard input. You can specify one or more of the original files as @var{orig} arguments; each one and options for interpreting it is separated from the others with a @samp{+}. @xref{Multiple Patches}, for more information. If you do not specify an input file on the command line, @code{patch} tries to figure out from the @dfn{leading text} (any text in the patch that comes before the @code{diff} output) which file to edit. In the header of a context or unified diff, @code{patch} looks in lines beginning with @samp{***}, @samp{---}, or @samp{+++}; among those, it chooses the shortest name of an existing file. Otherwise, if there is an @samp{Index:} line in the leading text, @code{patch} tries to use the file name from that line. If @code{patch} cannot figure out the name of an existing file from the leading text, it prompts you for the name of the file to patch. If the input file does not exist or is read-only, and a suitable RCS or SCCS file exists, @code{patch} attempts to check out or get the file before proceeding. By default, @code{patch} replaces the original input file with the patched version, after renaming the original file into a backup file (@pxref{Backups}, for a description of how @code{patch} names backup files). You can also specify where to put the output with the @samp{-o @var{output-file}} or @samp{--output=@var{output-file}} option. @menu * patch Directories:: Changing directory and stripping paths. * Backups:: Backup file names. * Rejects:: Reject file names. * patch Options:: Summary table of options to @code{patch}. @end menu @node patch Directories, Backups, , Invoking patch @section Applying Patches in Other Directories @cindex directories and patch @cindex patching directories The @samp{-d @var{directory}} or @samp{--directory=@var{directory}} option to @code{patch} makes directory @var{directory} the current directory for interpreting both file names in the patch file, and file names given as arguments to other options (such as @samp{-B} and @samp{-o}). For example, while in a news reading program, you can patch a file in the @file{/usr/src/emacs} directory directly from the article containing the patch like this: @example | patch -d /usr/src/emacs @end example Sometimes the file names given in a patch contain leading directories, but you keep your files in a directory different from the one given in the patch. In those cases, you can use the @samp{-p@r{[}@var{number}@r{]}} or @samp{--strip@r{[}=@var{number}@r{]}} option to set the file name strip count to @var{number}. The strip count tells @code{patch} how many slashes, along with the directory names between them, to strip from the front of file names. @samp{-p} with no @var{number} given is equivalent to @samp{-p0}. By default, @code{patch} strips off all leading paths, leaving just the base file names, except that when a file name given in the patch is a relative path and all of its leading directories already exist, @code{patch} does not strip off the leading path. (A @dfn{relative} path is one that does not start with a slash.) @code{patch} looks for each file (after any slashes have been stripped) in the current directory, or if you used the @samp{-d @var{directory}} option, in that directory. For example, suppose the file name in the patch file is @file{/gnu/src/emacs/etc/NEWS}. Using @samp{-p} or @samp{-p0} gives the entire file name unmodified, @samp{-p1} gives @file{gnu/src/emacs/etc/NEWS} (no leading slash), @samp{-p4} gives @file{etc/NEWS}, and not specifying @samp{-p} at all gives @file{NEWS}. @node Backups, Rejects, patch Directories, Invoking patch @section Backup File Names @cindex backup file names Normally, @code{patch} renames an original input file into a backup file by appending to its name the extension @samp{.orig}, or @samp{~} on systems that do not support long file names. The @samp{-b @var{backup-suffix}} or @samp{--suffix=@var{backup-suffix}} option uses @var{backup-suffix} as the backup extension instead. Alternately, you can specify the extension for backup files with the @code{SIMPLE_BACKUP_SUFFIX} environment variable, which the options override. @code{patch} can also create numbered backup files the way GNU Emacs does. With this method, instead of having a single backup of each file, @code{patch} makes a new backup file name each time it patches a file. For example, the backups of a file named @file{sink} would be called, successively, @file{sink.~1~}, @file{sink.~2~}, @file{sink.~3~}, etc. The @samp{-V @var{backup-style}} or @samp{--version-control=@var{backup-style}} option takes as an argument a method for creating backup file names. You can alternately control the type of backups that @code{patch} makes with the @code{VERSION_CONTROL} environment variable, which the @samp{-V} option overrides. The value of the @code{VERSION_CONTROL} environment variable and the argument to the @samp{-V} option are like the GNU Emacs @code{version-control} variable (@pxref{Backups, emacs, The GNU Emacs Manual}, for more information on backup versions in Emacs). They also recognize synonyms that are more descriptive. The valid values are listed below; unique abbreviations are acceptable. @table @samp @item t @itemx numbered Always make numbered backups. @item nil @itemx existing Make numbered backups of files that already have them, simple backups of the others. This is the default. @item never @itemx simple Always make simple backups. @end table Alternately, you can tell @code{patch} to prepend a prefix, such as a directory name, to produce backup file names. The @samp{-B @var{backup-prefix}} or @samp{--prefix=@var{backup-prefix}} option makes backup files by prepending @var{backup-prefix} to them. If you use this option, @code{patch} ignores any @samp{-b} option that you give. If the backup file already exists, @code{patch} creates a new backup file name by changing the first lowercase letter in the last component of the file name into uppercase. If there are no more lowercase letters in the name, it removes the first character from the name. It repeats this process until it comes up with a backup file name that does not already exist. If you specify the output file with the @samp{-o} option, that file is the one that is backed up, not the input file. @node Rejects, patch Options, Backups, Invoking patch @section Reject File Names @cindex reject file names The names for reject files (files containing patches that @code{patch} could not find a place to apply) are normally the name of the output file with @samp{.rej} appended (or @samp{#} on systems that do not support long file names). Alternatively, you can tell @code{patch} to place all of the rejected patches in a single file. The @samp{-r @var{reject-file}} or @samp{--reject-file=@var{reject-file}} option uses @var{reject-file} as the reject file name. @node patch Options, , Rejects, Invoking patch @section Options to @code{patch} @cindex @code{patch} options @cindex options for @code{patch} Here is a summary of all of the options that @code{patch} accepts. Older versions of @code{patch} do not accept long-named options or the @samp{-t}, @samp{-E}, or @samp{-V} options. Multiple single-letter options that do not take an argument can be combined into a single command line argument (with only one dash). Brackets ([ and ]) indicate that an option takes an optional argument. @table @samp @item -b @var{backup-suffix} Use @var{backup-suffix} as the backup extension instead of @samp{.orig} or @samp{~}. @xref{Backups}. @item -B @var{backup-prefix} Use @var{backup-prefix} as a prefix to the backup file name. If this option is specified, any @samp{-b} option is ignored. @xref{Backups}. @item --batch Do not ask any questions. @xref{patch Messages}. @item -c @itemx --context Interpret the patch file as a context diff. @xref{patch Input}. @item -d @var{directory} @itemx --directory=@var{directory} Makes directory @var{directory} the current directory for interpreting both file names in the patch file, and file names given as arguments to other options. @xref{patch Directories}. @item -D @var{name} Make merged if-then-else output using @var{format}. @xref{If-then-else}. @item --debug=@var{number} Set internal debugging flags. Of interest only to @code{patch} patchers. @item -e @itemx --ed Interpret the patch file as an @code{ed} script. @xref{patch Input}. @item -E Remove output files that are empty after the patches have been applied. @xref{Empty Files}. @item -f Assume that the user knows exactly what he or she is doing, and do not ask any questions. @xref{patch Messages}. @item -F @var{lines} Set the maximum fuzz factor to @var{lines}. @xref{Inexact}. @item --force Assume that the user knows exactly what he or she is doing, and do not ask any questions. @xref{patch Messages}. @item --forward Ignore patches that @code{patch} thinks are reversed or already applied. See also @samp{-R}. @xref{Reversed Patches}. @item --fuzz=@var{lines} Set the maximum fuzz factor to @var{lines}. @xref{Inexact}. @item --help Print a summary of the options that @code{patch} recognizes, then exit. @item --ifdef=@var{name} Make merged if-then-else output using @var{format}. @xref{If-then-else}. @item --ignore-white-space @itemx -l Let any sequence of white space in the patch file match any sequence of white space in the input file. @xref{Changed White Space}. @item -n @itemx --normal Interpret the patch file as a normal diff. @xref{patch Input}. @item -N Ignore patches that @code{patch} thinks are reversed or already applied. See also @samp{-R}. @xref{Reversed Patches}. @item -o @var{output-file} @itemx --output=@var{output-file} Use @var{output-file} as the output file name. @xref{patch Options}. @item -p@r{[}@var{number}@r{]} Set the file name strip count to @var{number}. @xref{patch Directories}. @item --prefix=@var{backup-prefix} Use @var{backup-prefix} as a prefix to the backup file name. If this option is specified, any @samp{-b} option is ignored. @xref{Backups}. @item --quiet Work silently unless an error occurs. @xref{patch Messages}. @item -r @var{reject-file} Use @var{reject-file} as the reject file name. @xref{Rejects}. @item -R Assume that this patch was created with the old and new files swapped. @xref{Reversed Patches}. @item --reject-file=@var{reject-file} Use @var{reject-file} as the reject file name. @xref{Rejects}. @item --remove-empty-files Remove output files that are empty after the patches have been applied. @xref{Empty Files}. @item --reverse Assume that this patch was created with the old and new files swapped. @xref{Reversed Patches}. @item -s Work silently unless an error occurs. @xref{patch Messages}. @item -S Ignore this patch from the patch file, but continue looking for the next patch in the file. @xref{Multiple Patches}. @item --silent Work silently unless an error occurs. @xref{patch Messages}. @item --skip Ignore this patch from the patch file, but continue looking for the next patch in the file. @xref{Multiple Patches}. @item --strip@r{[}=@var{number}@r{]} Set the file name strip count to @var{number}. @xref{patch Directories}. @item --suffix=@var{backup-suffix} Use @var{backup-suffix} as the backup extension instead of @samp{.orig} or @samp{~}. @xref{Backups}. @item -t Do not ask any questions. @xref{patch Messages}. @item -u @itemx --unified Interpret the patch file as a unified diff. @xref{patch Input}. @item -v Output the revision header and patch level of @code{patch}. @item -V @var{backup-style} Select the kind of backups to make. @xref{Backups}. @item --version Output the revision header and patch level of @code{patch}, then exit. @item --version=control=@var{backup-style} Select the kind of backups to make. @xref{Backups}. @item -x @var{number} Set internal debugging flags. Of interest only to @code{patch} patchers. @end table @node Invoking sdiff, Incomplete Lines, Invoking patch, Top @chapter Invoking @code{sdiff} @cindex invoking @code{sdiff} @cindex @code{sdiff} invocation The @code{sdiff} command merges two files and interactively outputs the results. Its arguments are as follows: @example sdiff -o @var{outfile} @var{options}@dots{} @var{from-file} @var{to-file} @end example This merges @var{from-file} with @var{to-file}, with output to @var{outfile}. If @var{from-file} is a directory and @var{to-file} is not, @code{sdiff} compares the file in @var{from-file} whose file name is that of @var{to-file}, and vice versa. @var{from-file} and @var{to-file} may not both be directories. @code{sdiff} options begin with @samp{-}, so normally @var{from-file} and @var{to-file} may not begin with @samp{-}. However, @samp{--} as an argument by itself treats the remaining arguments as file names even if they begin with @samp{-}. You may not use @samp{-} as an input file. An exit status of 0 means no differences were found, 1 means some differences were found, and 2 means trouble. @code{sdiff} without @samp{-o} (or @samp{--output}) produces a side-by-side difference. This usage is obsolete; use @samp{diff --side-by-side} instead. @menu * sdiff Options:: Summary of options to @code{diff}. @end menu @node sdiff Options, , , Invoking sdiff @section Options to @code{sdiff} @cindex @code{sdiff} options @cindex options for @code{sdiff} Below is a summary of all of the options that GNU @code{sdiff} accepts. Each option has two equivalent names, one of which is a single letter preceded by @samp{-}, and the other of which is a long name preceded by @samp{--}. Multiple single letter options (unless they take an argument) can be combined into a single command line argument. Long named options can be abbreviated to any unique prefix of their name. @table @samp @item -a Treat all files as text and compare them line-by-line, even if they do not appear to be text. @xref{Binary}. @item -b Ignore changes in amount of white space. @xref{White Space}. @item -B Ignore changes that just insert or delete blank lines. @xref{Blank Lines}. @item -d Change the algorithm to perhaps find a smaller set of changes. This makes @code{sdiff} slower (sometimes much slower). @xref{diff Performance}. @item -H Use heuristics to speed handling of large files that have numerous scattered small changes. @xref{diff Performance}. @item --expand-tabs Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files. @xref{Tabs}. @item -i Ignore changes in case; consider upper- and lower-case to be the same. @xref{Case Folding}. @item -I @var{regexp} Ignore changes that just insert or delete lines that match @var{regexp}. @xref{Specified Folding}. @item --ignore-all-space Ignore white space when comparing lines. @xref{White Space}. @item --ignore-blank-lines Ignore changes that just insert or delete blank lines. @xref{Blank Lines}. @item --ignore-case Ignore changes in case; consider upper- and lower-case to be the same. @xref{Case Folding}. @item --ignore-matching-lines=@var{regexp} Ignore changes that just insert or delete lines that match @var{regexp}. @xref{Specified Folding}. @item --ignore-space-change Ignore changes in amount of white space. @xref{White Space}. @item -l @itemx --left-column Print only the left column of two common lines. @xref{Side by Side Format}. @item --minimal Change the algorithm to perhaps find a smaller set of changes. This makes @code{sdiff} slower (sometimes much slower). @xref{diff Performance}. @item -o @var{file} @itemx --output=@var{file} Put merged output into @var{file}. This option is required for merging. @item -s @itemx --suppress-common-lines Do not print common lines. @xref{Side by Side Format}. @item --speed-large-files Use heuristics to speed handling of large files that have numerous scattered small changes. @xref{diff Performance}. @item -t Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files. @xref{Tabs}. @item --text Treat all files as text and compare them line-by-line, even if they do not appear to be text. @xref{Binary}. @item -v @itemx --version Output the version number of @code{sdiff}. @item -w @var{columns} @itemx --width=@var{columns} Use an output width of @var{columns}. @xref{Side by Side Format}. Note that for historical reasons, this option is @samp{-W} in @code{diff}, @samp{-w} in @code{sdiff}. @item -W Ignore horizontal white space when comparing lines. @xref{White Space}. Note that for historical reasons, this option is @samp{-w} in @code{diff}, @samp{-W} in @code{sdiff}. @end table @node Incomplete Lines, Projects, Invoking sdiff, Top @chapter Incomplete Lines @cindex incomplete lines @cindex full lines @cindex newline treatment by @code{diff} When an input file ends in a non-newline character, its last line is called an @dfn{incomplete line} because its last character is not a newline. All other lines are called @dfn{full lines} and end in a newline character. Incomplete lines do not match full lines unless differences in blank lines are ignored (@pxref{Blank Lines}). An incomplete line is normally distinguished on output from a full line by a following line that starts with @samp{\}. However, the RCS format (@pxref{RCS}) outputs the incomplete line as-is, without any trailing newline or following line. The side by side format normally represents incomplete lines as-is, but in some cases uses a @samp{\} or @samp{/} gutter marker; @xref{Side by Side}. The if-then-else line format preserves a line's incompleteness with @samp{%L}, and discards the newline with @samp{%l}; @xref{Line Formats}. Finally, with the @code{ed} and forward @code{ed} output formats (@pxref{Output Formats}) @code{diff} cannot represent an incomplete line, so it pretends there was a newline and reports an error. For example, suppose @file{F} and @file{G} are one-byte files that contain just @samp{f} and @samp{g}, respectively. Then @samp{diff F G} outputs @example 1c1 < f \ No newline at end of file --- > g \ No newline at end of file @end example @noindent (The exact message may differ in non-English locales.) @samp{diff -n F G} outputs the following without a trailing newline: @example d1 1 a1 1 g @end example @samp{diff -e F G} reports two errors and outputs the following: @example 1c g . @end example @node Projects, Concept Index, Incomplete Lines, Top @chapter Future Projects Here are some ideas for improving GNU @code{diff} and @code{patch}. The GNU project has identified some improvements as potential programming projects for volunteers. You can also help by reporting any bugs that you find. If you are a programmer and would like to contribute something to the GNU project, please consider volunteering for one of these projects. If you are seriously contemplating work, please write to @samp{gnu@@prep.ai.mit.edu} to coordinate with other volunteers. @menu * Shortcomings:: Suggested projects for improvements. * Bugs:: Reporting bugs. @end menu @node Shortcomings, Bugs, , Projects @section Suggested Projects for Improving GNU @code{diff} and @code{patch} @cindex projects for directories One should be able to use GNU @code{diff} to generate a patch from any pair of directory trees, and given the patch and a copy of one such tree, use @code{patch} to generate a faithful copy of the other. Unfortunately, some changes to directory trees cannot be expressed using current patch formats; also, @code{patch} does not handle some of the existing formats. These shortcomings motivate the following suggested projects. @menu * Changing Structure:: Handling changes to the directory structure. * Special Files:: Handling symbolic links, device special files, etc. * Unusual File Names:: Handling file names that contain unusual characters. * Arbitrary Limits:: Patching non-text files. * Large Files:: Handling files that do not fit in memory. * Ignoring Changes:: Ignoring certain changes while showing others. @end menu @node Changing Structure, Special Files, , Shortcomings @subsection Handling Changes to the Directory Structure @cindex directory structure changes @code{diff} and @code{patch} do not handle some changes to directory structure. For example, suppose one directory tree contains a directory named @samp{D} with some subsidiary files, and another contains a file with the same name @samp{D}. @samp{diff -r} does not output enough information for @code{patch} to transform the the directory subtree into the file. There should be a way to specify that a file has been deleted without having to include its entire contents in the patch file. There should also be a way to tell @code{patch} that a file was renamed, even if there is no way for @code{diff} to generate such information. These problems can be fixed by extending the @code{diff} output format to represent changes in directory structure, and extending @code{patch} to understand these extensions. @node Special Files, Unusual File Names, Changing Structure, Shortcomings @subsection Files that are Neither Directories Nor Regular Files @cindex special files Some files are neither directories nor regular files: they are unusual files like symbolic links, device special files, named pipes, and sockets. Currently, @code{diff} treats symbolic links like regular files; it treats other special files like regular files if they are specified at the top level, but simply reports their presence when comparing directories. This means that @code{patch} cannot represent changes to such files. For example, if you change which file a symbolic link points to, @code{diff} outputs the difference between the two files, instead of the change to the symbolic link. @c This might not be a good idea; is it wise for root to install devices @c this way? @code{diff} should optionally report changes to special files specially, and @code{patch} should be extended to understand these extensions. @node Unusual File Names, Arbitrary Limits, Special Files, Shortcomings @subsection File Names that Contain Unusual Characters @cindex file names with unusual characters When a file name contains an unusual character like a newline or white space, @samp{diff -r} generates a patch that @code{patch} cannot parse. The problem is with format of @code{diff} output, not just with @code{patch}, because with odd enough file names one can cause @code{diff} to generate a patch that is syntactically correct but patches the wrong files. The format of @code{diff} output should be extended to handle all possible file names. @node Arbitrary Limits, Large Files, Unusual File Names, Shortcomings @subsection Arbitrary Limits @cindex binary file patching GNU @code{diff} can analyze files with arbitrarily long lines and files that end in incomplete lines. However, @code{patch} cannot patch such files. The @code{patch} internal limits on line lengths should be removed, and @code{patch} should be extended to parse @code{diff} reports of incomplete lines. @node Large Files, Ignoring Changes, Arbitrary Limits, Shortcomings @subsection Handling Files that Do Not Fit in Memory @cindex large files @code{diff} operates by reading both files into memory. This method fails if the files are too large, and @code{diff} should have a fallback. One way to do this is to scan the files sequentially to compute hash codes of the lines and put the lines in equivalence classes based only on hash code. Then compare the files normally. This does produce some false matches. Then scan the two files sequentially again, checking each match to see whether it is real. When a match is not real, mark both the ``matching'' lines as changed. Then build an edit script as usual. The output routines would have to be changed to scan the files sequentially looking for the text to print. @node Ignoring Changes,, Large Files, Shortcomings @subsection Ignoring Certain Changes It would be nice to have a feature for specifying two strings, one in @var{from-file} and one in @var{to-file}, which should be considered to match. Thus, if the two strings are @samp{foo} and @samp{bar}, then if two lines differ only in that @samp{foo} in file 1 corresponds to @samp{bar} in file 2, the lines are treated as identical. It is not clear how general this feature can or should be, or what syntax should be used for it. @node Bugs, , Shortcomings, Projects @section Reporting Bugs @cindex bug reports @cindex reporting bugs If you think you have found a bug in GNU @code{cmp}, @code{diff}, @code{diff3}, @code{sdiff}, or @code{patch}, please report it by electronic mail to @samp{bug-gnu-utils@@prep.ai.mit.edu}. Send as precise a description of the problem as you can, including sample input files that produce the bug, if applicable. Because Larry Wall has not released a new version of @code{patch} since mid 1988 and the GNU version of @code{patch} has been changed since then, please send bug reports for @code{patch} by electronic mail to both @samp{bug-gnu-utils@@prep.ai.mit.edu} and @samp{lwall@@netlabs.com}. @node Concept Index, , Projects, Top @unnumbered Concept Index @printindex cp @shortcontents @contents @bye diffutils-2.4/diff.info100666 21641 13 7057 5445723623 14202 0ustar friedmanuserThis is Info file diff.info, produced by Makeinfo-1.55 from the input file ./diff.texi. This file documents the the GNU `diff', `diff3', `sdiff', and `cmp' commands for showing the differences between text files and the `patch' command for using their output to update files. Copyright (C) 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.  Indirect: diff.info-1: 1001 diff.info-2: 47238 diff.info-3: 97039 diff.info-4: 142971  Tag Table: (Indirect) Node: Top1001 Node: Overview2406 Node: Comparison5355 Node: Hunks8044 Node: White Space9470 Node: Blank Lines10686 Node: Case Folding11450 Node: Specified Folding11863 Node: Brief12953 Node: Binary14204 Node: Output Formats16715 Node: Sample diff Input17407 Node: Normal18900 Node: Detailed Normal19829 Node: Example Normal21554 Node: Context22277 Node: Context Format23825 Node: Detailed Context24598 Node: Example Context26154 Node: Less Context27647 Node: Unified Format28779 Node: Detailed Unified29558 Node: Example Unified30542 Node: Sections31541 Node: Specified Headings32285 Node: C Function Headings33832 Node: Alternate Names34576 Node: Side by Side35473 Node: Side by Side Format37613 Node: Example Side by Side38510 Node: Scripts39837 Node: ed Scripts40235 Node: Detailed ed41430 Node: Example ed43171 Node: Forward ed43609 Node: RCS44371 Node: If-then-else45581 Node: Line Group Formats47238 Node: Line Formats52920 Node: Detailed If-then-else56182 Node: Example If-then-else58083 Node: Comparing Directories59135 Node: Adjusting Output62250 Node: Tabs62669 Node: Pagination64191 Node: diff Performance64610 Node: Comparing Three Files66556 Node: Sample diff3 Input67417 Node: Detailed diff3 Normal68366 Node: diff3 Hunks70146 Node: Example diff3 Normal71432 Node: diff3 Merging72456 Node: Which Changes74666 Node: Marking Conflicts76072 Node: Bypassing ed78529 Node: Merging Incomplete Lines79884 Node: Saving the Changed File80601 Node: Interactive Merging81211 Node: sdiff Option Summary81909 Node: Merge Commands83009 Node: Merging with patch84145 Node: patch Input86252 Node: Imperfect86915 Node: Changed White Space87652 Node: Reversed Patches88403 Node: Inexact89988 Node: Empty Files93342 Node: Multiple Patches93906 Node: patch Messages95218 Node: Making Patches97039 Node: Invoking cmp100337 Node: cmp Options100941 Node: Invoking diff102312 Node: diff Options103778 Node: Invoking diff3114311 Node: diff3 Options114942 Node: Invoking patch118544 Node: patch Directories120478 Node: Backups122272 Node: Rejects124819 Node: patch Options125369 Node: Invoking sdiff130226 Node: sdiff Options131336 Node: Incomplete Lines134653 Node: Projects136276 Node: Shortcomings136970 Node: Changing Structure137965 Node: Special Files138913 Node: Unusual File Names139859 Node: Arbitrary Limits140481 Node: Large Files140910 Node: Ignoring Changes141782 Node: Bugs142326 Node: Concept Index142971  End Tag Table diffutils-2.4/diff.info-1100666 21641 13 134206 5445723621 14373 0ustar friedmanuserThis is Info file diff.info, produced by Makeinfo-1.55 from the input file ./diff.texi. This file documents the the GNU `diff', `diff3', `sdiff', and `cmp' commands for showing the differences between text files and the `patch' command for using their output to update files. Copyright (C) 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.  File: diff.info, Node: Top, Up: (dir) This file documents the the GNU `diff', `diff3', `sdiff', and `cmp' commands for showing the differences between text files and the `patch' command for using their output to update files. This is Edition 1.2, for `diff' 2.4 and `patch' 2.1. * Menu: * Overview:: Preliminary information. * Comparison:: What file comparison means. * Output Formats:: Formats for difference reports. * Comparing Directories:: Comparing files and directories. * Adjusting Output:: Making `diff' output prettier. * diff Performance:: Making `diff' smarter or faster. * Comparing Three Files:: Formats for three-way difference reports. * diff3 Merging:: Merging from a common ancestor. * Interactive Merging:: Interactive merging with `sdiff'. * Merging with patch:: Using `patch' to change old files into new ones. * Making Patches:: Tips for making patch distributions. * Invoking cmp:: How to run `cmp' and a summary of its options. * Invoking diff:: How to run `diff' and a summary of its options. * Invoking diff3:: How to run `diff3' and a summary of its options. * Invoking patch:: How to run `patch' and a summary of its options. * Invoking sdiff:: How to run `sdiff' and a summary of its options. * Incomplete Lines:: Lines that lack trailing newlines. * Projects:: If you think you've found a bug or other shortcoming. * Concept Index:: Index of concepts.  File: diff.info, Node: Overview, Next: Comparison, Up: Top Overview ******** Computer users often find occasion to ask how two files differ. Perhaps one file is a newer version of the other file. Or maybe the two files started out as identical copies but were changed by different people. You can use the `diff' command to show differences between two files, or each corresponding file in two directories. `diff' outputs differences between files line by line in any of several formats, selectable by command line options. This set of differences is often called a "diff" or "patch". For files that are identical, `diff' normally produces no output; for binary (non-text) files, `diff' normally reports only that they are different. You can use the `cmp' command to show the offsets and line numbers where two files differ. `cmp' can also show all the characters that differ between the two files, side by side. Another way to compare two files character by character is the Emacs command `M-x compare-windows'. *Note Other Window: (emacs)Other Window, for more information on that command. You can use the `diff3' command to show differences among three files. When two people have made independent changes to a common original, `diff3' can report the differences between the original and the two changed versions, and can produce a merged file that contains both persons' changes together with warnings about conflicts. You can use the `sdiff' command to merge two files interactively. You can use the set of differences produced by `diff' to distribute updates to text files (such as program source code) to other people. This method is especially useful when the differences are small compared to the complete files. Given `diff' output, you can use the `patch' program to update, or "patch", a copy of the file. If you think of `diff' as subtracting one file from another to produce their difference, you can think of `patch' as adding the difference to one file to reproduce the other. This manual first concentrates on making diffs, and later shows how to use diffs to update files. GNU `diff' was written by Mike Haertel, David Hayes, Richard Stallman, Len Tower, and Paul Eggert. Wayne Davison designed and implemented the unified output format. The basic algorithm is described in "An O(ND) Difference Algorithm and its Variations", Eugene Myers, `Algorithmica' Vol. 1 No. 2, 1986, p. 251; and in "A File Comparison Program", W. Miller and E. Myers, `Software Practice and Experience' Vol. 15 No. 11, 1985, p. 1025. GNU `diff3' was written by Randy Smith. GNU `sdiff' was written by Thomas Lord. GNU `cmp' was written by Torbjorn Granlund and David MacKenzie. `patch' was written mainly by Larry Wall; the GNU enhancements were written mainly by Wayne Davison and David MacKenzie. Parts of this manual are adapted from a manual page written by Larry Wall, with his permission.  File: diff.info, Node: Comparison, Next: Output Formats, Prev: Overview, Up: Top What Comparison Means ********************* There are several ways to think about the differences between two files. One way to think of the differences is as a series of lines that were deleted from, inserted in, or changed in one file to produce the other file. `diff' compares two files line by line, finds groups of lines that differ, and reports each group of differing lines. It can report the differing lines in several formats, which have different purposes. GNU `diff' can show whether files are different without detailing the differences. It also provides ways to suppress certain kinds of differences that are not important to you. Most commonly, such differences are changes in the amount of white space between words or lines. `diff' also provides ways to suppress differences in alphabetic case or in lines that match a regular expression that you provide. These options can accumulate; for example, you can ignore changes in both white space and alphabetic case. Another way to think of the differences between two files is as a sequence of pairs of characters that can be either identical or different. `cmp' reports the differences between two files character by character, instead of line by line. As a result, it is more useful than `diff' for comparing binary files. For text files, `cmp' is useful mainly when you want to know only whether two files are identical. For this purpose, it is better than `diff' because it is much faster. To illustrate the effect that considering changes character by character can have compared with considering them line by line, think of what happens if a single newline character is added to the beginning of a file. If that file is then compared with an otherwise identical file that lacks the newline at the beginning, `diff' will report that a blank line has been added to the file, while `cmp' will report that almost every character of the two files differs. `diff3' normally compares three input files line by line, finds groups of lines that differ, and reports each group of differing lines. Its output is designed to make it easy to inspect two different sets of changes to the same file. * Menu: * Hunks:: Groups of differing lines. * White Space:: Suppressing differences in white space. * Blank Lines:: Suppressing differences in blank lines. * Case Folding:: Suppressing differences in alphabetic case. * Specified Folding:: Suppressing differences that match regular expressions. * Brief:: Summarizing which files are different. * Binary:: Comparing binary files or forcing text comparisons.  File: diff.info, Node: Hunks, Next: White Space, Up: Comparison Hunks ===== When comparing two files, `diff' finds sequences of lines common to both files, interspersed with groups of differing lines called "hunks". Comparing two identical files yields one sequence of common lines and no hunks, because no lines differ. Comparing two entirely different files yields no common lines and one large hunk that contains all lines of both files. In general, there are many ways to match up lines between two given files. `diff' tries to minimize the total hunk size by finding large sequences of common lines interspersed with small hunks of differing lines. For example, suppose the file `F' contains the three lines `a', `b', `c', and the file `G' contains the same three lines in reverse order `c', `b', `a'. If `diff' finds the line `c' as common, then the command `diff F G' produces this output: 1,2d0 < a < b 3a2,3 > b > a But if `diff' notices the common line `b' instead, it produces this output: 1c1 < a --- > c 3c3 < c --- > a It is also possible to find `a' as the common line. `diff' does not always find an optimal matching between the files; it takes shortcuts to run faster. But its output is usually close to the shortest possible. You can adjust this tradeoff with the `--minimal' option (*note diff Performance::.).  File: diff.info, Node: White Space, Next: Blank Lines, Prev: Hunks, Up: Comparison Suppressing Differences in Blank and Tab Spacing ================================================ The `-b' and `--ignore-space-change' options ignore white space at line end, and considers all other sequences of one or more white space characters to be equivalent. With these options, `diff' considers the following two lines to be equivalent, where `$' denotes the line end: Here lyeth muche rychnesse in lytell space. -- John Heywood$ Here lyeth muche rychnesse in lytell space. -- John Heywood $ The `-w' and `--ignore-all-space' options are stronger than `-b'. They ignore difference even if one file has white space where the other file has none. "White space" characters include tab, vertical tab, form feed, carriage return, and space; some locales may define additional characters to be white space. With these options, `diff' considers the following two lines to be equivalent, where `$' denotes the line end and `^M' denotes a carriage return: Here lyeth muche rychnesse in lytell space.-- John Heywood$ He relyeth much erychnes seinly tells pace. --John Heywood ^M$  File: diff.info, Node: Blank Lines, Next: Case Folding, Prev: White Space, Up: Comparison Suppressing Differences in Blank Lines ====================================== The `-B' and `--ignore-blank-lines' options ignore insertions or deletions of blank lines. These options normally affect only lines that are completely empty; they do not affect lines that look empty but contain space or tab characters. With these options, for example, a file containing 1. A point is that which has no part. 2. A line is breadthless length. -- Euclid, The Elements, I is considered identical to a file containing 1. A point is that which has no part. 2. A line is breadthless length. -- Euclid, The Elements, I  File: diff.info, Node: Case Folding, Next: Specified Folding, Prev: Blank Lines, Up: Comparison Suppressing Case Differences ============================ GNU `diff' can treat lowercase letters as equivalent to their uppercase counterparts, so that, for example, it considers `Funky Stuff', `funky STUFF', and `fUNKy stuFf' to all be the same. To request this, use the `-i' or `--ignore-case' option.  File: diff.info, Node: Specified Folding, Next: Brief, Prev: Case Folding, Up: Comparison Suppressing Lines Matching a Regular Expression =============================================== To ignore insertions and deletions of lines that match a regular expression, use the `-I REGEXP' or `--ignore-matching-lines=REGEXP' option. You should escape regular expressions that contain shell metacharacters to prevent the shell from expanding them. For example, `diff -I '^[0-9]'' ignores all changes to lines beginning with a digit. However, `-I' only ignores the insertion or deletion of lines that contain the regular expression if every changed line in the hunk--every insertion and every deletion--matches the regular expression. In other words, for each nonignorable change, `diff' prints the complete set of changes in its vicinity, including the ignorable ones. You can specify more than one regular expression for lines to ignore by using more than one `-I' option. `diff' tries to match each line against each regular expression, starting with the last one given.  File: diff.info, Node: Brief, Next: Binary, Prev: Specified Folding, Up: Comparison Summarizing Which Files Differ ============================== When you only want to find out whether files are different, and you don't care what the differences are, you can use the summary output format. In this format, instead of showing the differences between the files, `diff' simply reports whether files differ. The `-q' and `--brief' options select this output format. This format is especially useful when comparing the contents of two directories. It is also much faster than doing the normal line by line comparisons, because `diff' can stop analyzing the files as soon as it knows that there are any differences. You can also get a brief indication of whether two files differ by using `cmp'. For files that are identical, `cmp' produces no output. When the files differ, by default, `cmp' outputs the byte offset and line number where the first difference occurs. You can use the `-s' option to suppress that information, so that `cmp' produces no output and reports whether the files differ using only its exit status (*note Invoking cmp::.). Unlike `diff', `cmp' cannot compare directories; it can only compare two files.  File: diff.info, Node: Binary, Prev: Brief, Up: Comparison Binary Files and Forcing Text Comparisons ========================================= If `diff' thinks that either of the two files it is comparing is binary (a non-text file), it normally treats that pair of files much as if the summary output format had been selected (*note Brief::.), and reports only that the binary files are different. This is because line by line comparisons are usually not meaningful for binary files. `diff' determines whether a file is text or binary by checking the first few bytes in the file; the exact number of bytes is system dependent, but it is typically several thousand. If every character in that part of the file is non-null, `diff' considers the file to be text; otherwise it considers the file to be binary. Sometimes you might want to force `diff' to consider files to be text. For example, you might be comparing text files that contain null characters; `diff' would erroneously decide that those are non-text files. Or you might be comparing documents that are in a format used by a word processing system that uses null characters to indicate special formatting. You can force `diff' to consider all files to be text files, and compare them line by line, by using the `-a' or `--text' option. If the files you compare using this option do not in fact contain text, they will probably contain few newline characters, and the `diff' output will consist of hunks showing differences between long lines of whatever characters the files contain. You can also force `diff' to consider all files to be binary files, and report only whether they differ (but not how). Use the `--brief' option for this. If you want to compare two files byte by byte, you can use the `cmp' program with the `-l' option to show the values of each differing byte in the two files. With GNU `cmp', you can also use the `-c' option to show the ASCII representation of those bytes. *Note Invoking cmp::, for more information. If `diff3' thinks that any of the files it is comparing is binary (a non-text file), it normally reports an error, because such comparisons are usually not useful. `diff3' uses the same test as `diff' to decide whether a file is binary. As with `diff', if the input files contain a few non-text characters but otherwise are like text files, you can force `diff3' to consider all files to be text files and compare them line by line by using the `-a' or `--text' options.  File: diff.info, Node: Output Formats, Next: Comparing Directories, Prev: Comparison, Up: Top `diff' Output Formats ********************* `diff' has several mutually exclusive options for output format. The following sections describe each format, illustrating how `diff' reports the differences between two sample input files. * Menu: * Sample diff Input:: Sample `diff' input files for examples. * Normal:: Showing differences without surrounding text. * Context:: Showing differences with the surrounding text. * Side by Side:: Showing differences in two columns. * Scripts:: Generating scripts for other programs. * If-then-else:: Merging files with if-then-else.  File: diff.info, Node: Sample diff Input, Next: Normal, Up: Output Formats Two Sample Input Files ====================== Here are two sample files that we will use in numerous examples to illustrate the output of `diff' and how various options can change it. This is the file `lao': The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; The Named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their outcome. The two are the same, But after they are produced, they have different names. This is the file `tzu': The Nameless is the origin of Heaven and Earth; The named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their outcome. The two are the same, But after they are produced, they have different names. They both may be called deep and profound. Deeper and more profound, The door of all subtleties! In this example, the first hunk contains just the first two lines of `lao', the second hunk contains the fourth line of `lao' opposing the second and third lines of `tzu', and the last hunk contains just the last three lines of `tzu'.  File: diff.info, Node: Normal, Next: Context, Prev: Sample diff Input, Up: Output Formats Showing Differences Without Context =================================== The "normal" `diff' output format shows each hunk of differences without any surrounding context. Sometimes such output is the clearest way to see how lines have changed, without the clutter of nearby unchanged lines (although you can get similar results with the context or unified formats by using 0 lines of context). However, this format is no longer widely used for sending out patches; for that purpose, the context format (*note Context Format::.) and the unified format (*note Unified Format::.) are superior. Normal format is the default for compatibility with older versions of `diff' and the Posix standard. * Menu: * Detailed Normal:: A detailed description of normal output format. * Example Normal:: Sample output in the normal format.  File: diff.info, Node: Detailed Normal, Next: Example Normal, Up: Normal Detailed Description of Normal Format ------------------------------------- The normal output format consists of one or more hunks of differences; each hunk shows one area where the files differ. Normal format hunks look like this: CHANGE-COMMAND < FROM-FILE-LINE < FROM-FILE-LINE... --- > TO-FILE-LINE > TO-FILE-LINE... There are three types of change commands. Each consists of a line number or comma-separated range of lines in the first file, a single character indicating the kind of change to make, and a line number or comma-separated range of lines in the second file. All line numbers are the original line numbers in each file. The types of change commands are: `LaR' Add the lines in range R of the second file after line L of the first file. For example, `8a12,15' means append lines 12-15 of file 2 after line 8 of file 1; or, if changing file 2 into file 1, delete lines 12-15 of file 2. `FcT' Replace the lines in range F of the first file with lines in range T of the second file. This is like a combined add and delete, but more compact. For example, `5,7c8,10' means change lines 5-7 of file 1 to read as lines 8-10 of file 2; or, if changing file 2 into file 1, change lines 8-10 of file 2 to read as lines 5-7 of file 1. `RdL' Delete the lines in range R from the first file; line L is where they would have appeared in the second file had they not been deleted. For example, `5,7d3' means delete lines 5-7 of file 1; or, if changing file 2 into file 1, append lines 5-7 of file 1 after line 3 of file 2.  File: diff.info, Node: Example Normal, Prev: Detailed Normal, Up: Normal An Example of Normal Format --------------------------- Here is the output of the command `diff lao tzu' (*note Sample diff Input::., for the complete contents of the two files). Notice that it shows only the lines that are different between the two files. 1,2d0 < The Way that can be told of is not the eternal Way; < The name that can be named is not the eternal name. 4c2,3 < The Named is the mother of all things. --- > The named is the mother of all things. > 11a11,13 > They both may be called deep and profound. > Deeper and more profound, > The door of all subtleties!  File: diff.info, Node: Context, Next: Side by Side, Prev: Normal, Up: Output Formats Showing Differences in Their Context ==================================== Usually, when you are looking at the differences between files, you will also want to see the parts of the files near the lines that differ, to help you understand exactly what has changed. These nearby parts of the files are called the "context". GNU `diff' provides two output formats that show context around the differing lines: "context format" and "unified format". It can optionally show in which function or section of the file the differing lines are found. If you are distributing new versions of files to other people in the form of `diff' output, you should use one of the output formats that show context so that they can apply the diffs even if they have made small changes of their own to the files. `patch' can apply the diffs in this case by searching in the files for the lines of context around the differing lines; if those lines are actually a few lines away from where the diff says they are, `patch' can adjust the line numbers accordingly and still apply the diff correctly. *Note Imperfect::, for more information on using `patch' to apply imperfect diffs. * Menu: * Context Format:: An output format that shows surrounding lines. * Unified Format:: A more compact output format that shows context. * Sections:: Showing which sections of the files differences are in. * Alternate Names:: Showing alternate file names in context headers.  File: diff.info, Node: Context Format, Next: Unified Format, Up: Context Context Format -------------- The context output format shows several lines of context around the lines that differ. It is the standard format for distributing updates to source code. To select this output format, use the `-C LINES', `--context[=LINES]', or `-c' option. The argument LINES that some of these options take is the number of lines of context to show. If you do not specify LINES, it defaults to three. For proper operation, `patch' typically needs at least two lines of context. * Menu: * Detailed Context:: A detailed description of the context output format. * Example Context:: Sample output in context format. * Less Context:: Another sample with less context.  File: diff.info, Node: Detailed Context, Next: Example Context, Up: Context Format Detailed Description of Context Format ...................................... The context output format starts with a two-line header, which looks like this: *** FROM-FILE FROM-FILE-MODIFICATION-TIME --- TO-FILE TO-FILE-MODIFICATION TIME You can change the header's content with the `-L LABEL' or `--label=LABEL' option; see *Note Alternate Names::. Next come one or more hunks of differences; each hunk shows one area where the files differ. Context format hunks look like this: *************** *** FROM-FILE-LINE-RANGE **** FROM-FILE-LINE FROM-FILE-LINE... --- TO-FILE-LINE-RANGE ---- TO-FILE-LINE TO-FILE-LINE... The lines of context around the lines that differ start with two space characters. The lines that differ between the two files start with one of the following indicator characters, followed by a space character: `!' A line that is part of a group of one or more lines that changed between the two files. There is a corresponding group of lines marked with `!' in the part of this hunk for the other file. `+' An "inserted" line in the second file that corresponds to nothing in the first file. `-' A "deleted" line in the first file that corresponds to nothing in the second file. If all of the changes in a hunk are insertions, the lines of FROM-FILE are omitted. If all of the changes are deletions, the lines of TO-FILE are omitted.  File: diff.info, Node: Example Context, Next: Less Context, Prev: Detailed Context, Up: Context Format An Example of Context Format ............................ Here is the output of `diff -c lao tzu' (*note Sample diff Input::., for the complete contents of the two files). Notice that up to three lines that are not different are shown around each line that is different; they are the context lines. Also notice that the first two hunks have run together, because their contents overlap. *** lao Sat Jan 26 23:30:39 1991 --- tzu Sat Jan 26 23:30:50 1991 *************** *** 1,7 **** - The Way that can be told of is not the eternal Way; - The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; ! The Named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, --- 1,6 ---- The Nameless is the origin of Heaven and Earth; ! The named is the mother of all things. ! Therefore let there always be non-being, so we may see their subtlety, And let there always be being, *************** *** 9,11 **** --- 8,13 ---- The two are the same, But after they are produced, they have different names. + They both may be called deep and profound. + Deeper and more profound, + The door of all subtleties!  File: diff.info, Node: Less Context, Prev: Example Context, Up: Context Format An Example of Context Format with Less Context .............................................. Here is the output of `diff --context=1 lao tzu' (*note Sample diff Input::., for the complete contents of the two files). Notice that at most one context line is reported here. *** lao Sat Jan 26 23:30:39 1991 --- tzu Sat Jan 26 23:30:50 1991 *************** *** 1,5 **** - The Way that can be told of is not the eternal Way; - The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; ! The Named is the mother of all things. Therefore let there always be non-being, --- 1,4 ---- The Nameless is the origin of Heaven and Earth; ! The named is the mother of all things. ! Therefore let there always be non-being, *************** *** 11 **** --- 10,13 ---- they have different names. + They both may be called deep and profound. + Deeper and more profound, + The door of all subtleties!  File: diff.info, Node: Unified Format, Next: Sections, Prev: Context Format, Up: Context Unified Format -------------- The unified output format is a variation on the context format that is more compact because it omits redundant context lines. To select this output format, use the `-U LINES', `--unified[=LINES]', or `-u' option. The argument LINES is the number of lines of context to show. When it is not given, it defaults to three. At present, only GNU `diff' can produce this format and only GNU `patch' can automatically apply diffs in this format. For proper operation, `patch' typically needs at least two lines of context. * Menu: * Detailed Unified:: A detailed description of unified format. * Example Unified:: Sample output in unified format.  File: diff.info, Node: Detailed Unified, Next: Example Unified, Up: Unified Format Detailed Description of Unified Format ...................................... The unified output format starts with a two-line header, which looks like this: --- FROM-FILE FROM-FILE-MODIFICATION-TIME +++ TO-FILE TO-FILE-MODIFICATION-TIME You can change the header's content with the `-L LABEL' or `--label=LABEL' option; see *Note Alternate Names::. Next come one or more hunks of differences; each hunk shows one area where the files differ. Unified format hunks look like this: @@ FROM-FILE-RANGE TO-FILE-RANGE @@ LINE-FROM-EITHER-FILE LINE-FROM-EITHER-FILE... The lines common to both files begin with a space character. The lines that actually differ between the two files have one of the following indicator characters in the left column: `+' A line was added here to the first file. `-' A line was removed here from the first file.  File: diff.info, Node: Example Unified, Prev: Detailed Unified, Up: Unified Format An Example of Unified Format ............................ Here is the output of the command `diff -u lao tzu' (*note Sample diff Input::., for the complete contents of the two files): --- lao Sat Jan 26 23:30:39 1991 +++ tzu Sat Jan 26 23:30:50 1991 @@ -1,7 +1,6 @@ -The Way that can be told of is not the eternal Way; -The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; -The Named is the mother of all things. +The named is the mother of all things. + Therefore let there always be non-being, so we may see their subtlety, And let there always be being, @@ -9,3 +8,6 @@ The two are the same, But after they are produced, they have different names. +They both may be called deep and profound. +Deeper and more profound, +The door of all subtleties!  File: diff.info, Node: Sections, Next: Alternate Names, Prev: Unified Format, Up: Context Showing Which Sections Differences Are in ----------------------------------------- Sometimes you might want to know which part of the files each change falls in. If the files are source code, this could mean which function was changed. If the files are documents, it could mean which chapter or appendix was changed. GNU `diff' can show this by displaying the nearest section heading line that precedes the differing lines. Which lines are "section headings" is determined by a regular expression. * Menu: * Specified Headings:: Showing headings that match regular expressions. * C Function Headings:: Showing headings of C functions.  File: diff.info, Node: Specified Headings, Next: C Function Headings, Up: Sections Showing Lines That Match Regular Expressions ............................................ To show in which sections differences occur for files that are not source code for C or similar languages, use the `-F REGEXP' or `--show-function-line=REGEXP' option. `diff' considers lines that match the argument REGEXP to be the beginning of a section of the file. Here are suggested regular expressions for some common languages: `^[A-Za-z_]' C, C++, Prolog `^(' Lisp `^@\(chapter\|appendix\|unnumbered\|chapheading\)' Texinfo This option does not automatically select an output format; in order to use it, you must select the context format (*note Context Format::.) or unified format (*note Unified Format::.). In other output formats it has no effect. The `-F' and `--show-function-line' options find the nearest unchanged line that precedes each hunk of differences and matches the given regular expression. Then they add that line to the end of the line of asterisks in the context format, or to the `@@' line in unified format. If no matching line exists, they leave the output for that hunk unchanged. If that line is more than 40 characters long, they output only the first 40 characters. You can specify more than one regular expression for such lines; `diff' tries to match each line against each regular expression, starting with the last one given. This means that you can use `-p' and `-F' together, if you wish.  File: diff.info, Node: C Function Headings, Prev: Specified Headings, Up: Sections Showing C Function Headings ........................... To show in which functions differences occur for C and similar languages, you can use the `-p' or `--show-c-function' option. This option automatically selects the context output format (*note Context Format::.), with the default number of lines of context. You can override that number with `-C LINES' later in the command line. You can override both the format and the number with `-U LINES' later in the command line. The `-p' and `--show-c-function' options are equivalent to `-c -F'^[_a-zA-Z$]'' (*note Specified Headings::.). GNU `diff' provides them for the sake of convenience.  File: diff.info, Node: Alternate Names, Prev: Sections, Up: Context Showing Alternate File Names ---------------------------- If you are comparing two files that have meaningless or uninformative names, you might want `diff' to show alternate names in the header of the context and unified output formats. To do this, use the `-L LABEL' or `--label=LABEL' option. The first time you give this option, its argument replaces the name and date of the first file in the header; the second time, its argument replaces the name and date of the second file. If you give this option more than twice, `diff' reports an error. The `-L' option does not affect the file names in the `pr' header when the `-l' or `--paginate' option is used (*note Pagination::.). Here are the first two lines of the output from `diff -C2 -Loriginal -Lmodified lao tzu': *** original --- modified  File: diff.info, Node: Side by Side, Next: Scripts, Prev: Context, Up: Output Formats Showing Differences Side by Side ================================ `diff' can produce a side by side difference listing of two files. The files are listed in two columns with a gutter between them. The gutter contains one of the following markers: white space The corresponding lines are in common. That is, either the lines are identical, or the difference is ignored because of one of the `--ignore' options (*note White Space::.). `|' The corresponding lines differ, and they are either both complete or both incomplete. `<' The files differ and only the first file contains the line. `>' The files differ and only the second file contains the line. `(' Only the first file contains the line, but the difference is ignored. `)' Only the second file contains the line, but the difference is ignored. `\' The corresponding lines differ, and only the first line is incomplete. `/' The corresponding lines differ, and only the second line is incomplete. Normally, an output line is incomplete if and only if the lines that it contains are incomplete; *Note Incomplete Lines::. However, when an output line represents two differing lines, one might be incomplete while the other is not. In this case, the output line is complete, but its the gutter is marked `\' if the first line is incomplete, `/' if the second line is. Side by side format is sometimes easiest to read, but it has limitations. It generates much wider output than usual, and truncates lines that are too long to fit. Also, it relies on lining up output more heavily than usual, so its output looks particularly bad if you use varying width fonts, nonstandard tab stops, or nonprinting characters. You can use the `sdiff' command to interactively merge side by side differences. *Note Interactive Merging::, for more information on merging files. * Menu: * Side by Side Format:: Controlling side by side output format. * Example Side by Side:: Sample side by side output.  File: diff.info, Node: Side by Side Format, Next: Example Side by Side, Up: Side by Side Controlling Side by Side Format =============================== The `-y' or `--side-by-side' option selects side by side format. Because side by side output lines contain two input lines, they are wider than usual. They are normally 130 columns, which can fit onto a traditional printer line. You can set the length of output lines with the `-W COLUMNS' or `--width=COLUMNS' option. The output line is split into two halves of equal length, separated by a small gutter to mark differences; the right half is aligned to a tab stop so that tabs line up. Input lines that are too long to fit in half of an output line are truncated for output. The `--left-column' option prints only the left column of two common lines. The `--suppress-common-lines' option suppresses common lines entirely.  File: diff.info, Node: Example Side by Side, Prev: Side by Side Format, Up: Side by Side An Example of Side by Side Format --------------------------------- Here is the output of the command `diff -y -W 72 lao tzu' (*note Sample diff Input::., for the complete contents of the two files). The Way that can be told of is n < The name that can be named is no < The Nameless is the origin of He The Nameless is the origin of He The Named is the mother of all t | The named is the mother of all t > Therefore let there always be no Therefore let there always be no so we may see their subtlety, so we may see their subtlety, And let there always be being, And let there always be being, so we may see their outcome. so we may see their outcome. The two are the same, The two are the same, But after they are produced, But after they are produced, they have different names. they have different names. > They both may be called deep and > Deeper and more profound, > The door of all subtleties!  File: diff.info, Node: Scripts, Next: If-then-else, Prev: Side by Side, Up: Output Formats Making Edit Scripts =================== Several output modes produce command scripts for editing FROM-FILE to produce TO-FILE. * Menu: * ed Scripts:: Using `diff' to produce commands for `ed'. * Forward ed:: Making forward `ed' scripts. * RCS:: A special `diff' output format used by RCS.  File: diff.info, Node: ed Scripts, Next: Forward ed, Up: Scripts `ed' Scripts ------------ `diff' can produce commands that direct the `ed' text editor to change the first file into the second file. Long ago, this was the only output mode that was suitable for editing one file into another automatically; today, with `patch', it is almost obsolete. Use the `-e' or `--ed' option to select this output format. Like the normal format (*note Normal::.), this output format does not show any context; unlike the normal format, it does not include the information necessary to apply the diff in reverse (to produce the first file if all you have is the second file and the diff). If the file `d' contains the output of `diff -e old new', then the command `(cat d && echo w) | ed - old' edits `old' to make it a copy of `new'. More generally, if `d1', `d2', ..., `dN' contain the outputs of `diff -e old new1', `diff -e new1 new2', ..., `diff -e newN-1 newN', respectively, then the command `(cat d1 d2 ... dN && echo w) | ed - old' edits `old' to make it a copy of `newN'. * Menu: * Detailed ed:: A detailed description of `ed' format. * Example ed:: A sample `ed' script.  File: diff.info, Node: Detailed ed, Next: Example ed, Up: ed Scripts Detailed Description of `ed' Format ................................... The `ed' output format consists of one or more hunks of differences. The changes closest to the ends of the files come first so that commands that change the number of lines do not affect how `ed' interprets line numbers in succeeding commands. `ed' format hunks look like this: CHANGE-COMMAND TO-FILE-LINE TO-FILE-LINE... . Because `ed' uses a single period on a line to indicate the end of input, GNU `diff' protects lines of changes that contain a single period on a line by writing two periods instead, then writing a subsequent `ed' command to change the two periods into one. The `ed' format cannot represent an incomplete line, so if the second file ends in a changed incomplete line, `diff' reports an error and then pretends that a newline was appended. There are three types of change commands. Each consists of a line number or comma-separated range of lines in the first file and a single character indicating the kind of change to make. All line numbers are the original line numbers in the file. The types of change commands are: `La' Add text from the second file after line L in the first file. For example, `8a' means to add the following lines after line 8 of file 1. `Rc' Replace the lines in range R in the first file with the following lines. Like a combined add and delete, but more compact. For example, `5,7c' means change lines 5-7 of file 1 to read as the text file 2. `Rd' Delete the lines in range R from the first file. For example, `5,7d' means delete lines 5-7 of file 1.  File: diff.info, Node: Example ed, Prev: Detailed ed, Up: ed Scripts Example `ed' Script ................... Here is the output of `diff -e lao tzu' (*note Sample diff Input::., for the complete contents of the two files): 11a They both may be called deep and profound. Deeper and more profound, The door of all subtleties! . 4c The named is the mother of all things. . 1,2d  File: diff.info, Node: Forward ed, Next: RCS, Prev: ed Scripts, Up: Scripts Forward `ed' Scripts -------------------- `diff' can produce output that is like an `ed' script, but with hunks in forward (front to back) order. The format of the commands is also changed slightly: command characters precede the lines they modify, spaces separate line numbers in ranges, and no attempt is made to disambiguate hunk lines consisting of a single period. Like `ed' format, forward `ed' format cannot represent incomplete lines. Forward `ed' format is not very useful, because neither `ed' nor `patch' can apply diffs in this format. It exists mainly for compatibility with older versions of `diff'. Use the `-f' or `--forward-ed' option to select it.  File: diff.info, Node: RCS, Prev: Forward ed, Up: Scripts RCS Scripts ----------- The RCS output format is designed specifically for use by the Revision Control System, which is a set of free programs used for organizing different versions and systems of files. Use the `-n' or `--rcs' option to select this output format. It is like the forward `ed' format (*note Forward ed::.), but it can represent arbitrary changes to the contents of a file because it avoids the forward `ed' format's problems with lines consisting of a single period and with incomplete lines. Instead of ending text sections with a line consisting of a single period, each command specifies the number of lines it affects; a combination of the `a' and `d' commands are used instead of `c'. Also, if the second file ends in a changed incomplete line, then the output also ends in an incomplete line. Here is the output of `diff -n lao tzu' (*note Sample diff Input::., for the complete contents of the two files): d1 2 d4 1 a4 2 The named is the mother of all things. a11 3 They both may be called deep and profound. Deeper and more profound, The door of all subtleties!  File: diff.info, Node: If-then-else, Prev: Scripts, Up: Output Formats Merging Files with If-then-else =============================== You can use `diff' to merge two files of C source code. The output of `diff' in this format contains all the lines of both files. Lines common to both files are output just once; the differing parts are separated by the C preprocessor directives `#ifdef NAME' or `#ifndef NAME', `#else', and `#endif'. When compiling the output, you select which version to use by either defining or leaving undefined the macro NAME. To merge two files, use `diff' with the `-D NAME' or `--ifdef=NAME' option. The argument NAME is the C preprocessor identifier to use in the `#ifdef' and `#ifndef' directives. For example, if you change an instance of `wait (&s)' to `waitpid (-1, &s, 0)' and then merge the old and new files with the `--ifdef=HAVE_WAITPID' option, then the affected part of your code might look like this: do { #ifndef HAVE_WAITPID if ((w = wait (&s)) < 0 && errno != EINTR) #else /* HAVE_WAITPID */ if ((w = waitpid (-1, &s, 0)) < 0 && errno != EINTR) #endif /* HAVE_WAITPID */ return w; } while (w != child); You can specify formats for languages other than C by using line group formats and line formats, as described in the next sections. * Menu: * Line Group Formats:: Formats for general if-then-else line groups. * Line Formats:: Formats for each line in a line group. * Detailed If-then-else:: A detailed description of if-then-else format. * Example If-then-else:: Sample if-then-else format output. diffutils-2.4/diff.info-2100666 21641 13 143162 5445723621 14375 0ustar friedmanuserThis is Info file diff.info, produced by Makeinfo-1.55 from the input file ./diff.texi. This file documents the the GNU `diff', `diff3', `sdiff', and `cmp' commands for showing the differences between text files and the `patch' command for using their output to update files. Copyright (C) 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.  File: diff.info, Node: Line Group Formats, Next: Line Formats, Up: If-then-else Line Group Formats ------------------ Line group formats let you specify formats suitable for many applications that allow if-then-else input, including programming languages and text formatting languages. A line group format specifies the output format for a contiguous group of similar lines. For example, the following command compares the TeX files `old' and `new', and outputs a merged file in which old regions are surrounded by `\begin{em}'-`\end{em}' lines, and new regions are surrounded by `\begin{bf}'-`\end{bf}' lines. diff \ --old-group-format='\begin{em} %<\end{em} ' \ --new-group-format='\begin{bf} %>\end{bf} ' \ old new The following command is equivalent to the above example, but it is a little more verbose, because it spells out the default line group formats. diff \ --old-group-format='\begin{em} %<\end{em} ' \ --new-group-format='\begin{bf} %>\end{bf} ' \ --unchanged-group-format='%=' \ --changed-group-format='\begin{em} %<\end{em} \begin{bf} %>\end{bf} ' \ old new Here is a more advanced example, which outputs a diff listing with headers containing line numbers in a "plain English" style. diff \ --unchanged-group-format='' \ --old-group-format='-------- %dn line%(n=1?:s) deleted at %df: %<' \ --new-group-format='-------- %dN line%(N=1?:s) added after %de: %>' \ --changed-group-format='-------- %dn line%(n=1?:s) changed at %df: %<-------- to: %>' \ old new To specify a line group format, use `diff' with one of the options listed below. You can specify up to four line group formats, one for each kind of line group. You should quote FORMAT, because it typically contains shell metacharacters. `--old-group-format=FORMAT' These line groups are hunks containing only lines from the first file. The default old group format is the same as the changed group format if it is specified; otherwise it is a format that outputs the line group as-is. `--new-group-format=FORMAT' These line groups are hunks containing only lines from the second file. The default new group format is same as the the changed group format if it is specified; otherwise it is a format that outputs the line group as-is. `--changed-group-format=FORMAT' These line groups are hunks containing lines from both files. The default changed group format is the concatenation of the old and new group formats. `--unchanged-group-format=FORMAT' These line groups contain lines common to both files. The default unchanged group format is a format that outputs the line group as-is. In a line group format, ordinary characters represent themselves; conversion specifications start with `%' and have one of the following forms. `%<' stands for the lines from the first file, including the trailing newline. Each line is formatted according to the old line format (*note Line Formats::.). `%>' stands for the lines from the second file, including the trailing newline. Each line is formatted according to the new line format. `%=' stands for the lines common to both files, including the trailing newline. Each line is formatted according to the unchanged line format. `%%' stands for `%'. `%c'C'' where C is a single character, stands for C. C may not be a backslash or an apostrophe. For example, `%c':'' stands for a colon, even inside the then-part of an if-then-else format, which a colon would normally terminate. `%c'\O'' where O is a string of 1, 2, or 3 octal digits, stands for the character with octal code O. For example, `%c'\0'' stands for a null character. `FN' where F is a `printf' conversion specification and N is one of the following letters, stands for N's value formatted with F. `e' The line number of the line just before the group in the old file. `f' The line number of the first line in the group in the old file; equals E + 1. `l' The line number of the last line in the group in the old file. `m' The line number of the line just after the group in the old file; equals L + 1. `n' The number of lines in the group in the old file; equals L - F + 1. `E, F, L, M, N' Likewise, for lines in the new file. The `printf' conversion specification can be `%d', `%o', `%x', or `%X', specifying decimal, octal, lower case hexadecimal, or upper case hexadecimal output respectively. After the `%' the following options can appear in sequence: a `-' specifying left-justification; an integer specifying the minimum field width; and a period followed by an optional integer specifying the minimum number of digits. For example, `%5dN' prints the number of new lines in the group in a field of width 5 characters, using the `printf' format `"%5d"'. `(A=B?T:E)' If A equals B then T else E. A and B are each either a decimal constant or a single letter interpreted as above. This format spec is equivalent to T if A's value equals B's; otherwise it is equivalent to E. For example, `%(N=0?no:%dN) line%(N=1?:s)' is equivalent to `no lines' if N (the number of lines in the group in the the new file) is 0, to `1 line' if N is 1, and to `%dN lines' otherwise.  File: diff.info, Node: Line Formats, Next: Detailed If-then-else, Prev: Line Group Formats, Up: If-then-else Line Formats ------------ Line formats control how each line taken from an input file is output as part of a line group in if-then-else format. For example, the following command outputs text with a one-column change indicator to the left of the text. The first column of output is `-' for deleted lines, `|' for added lines, and a space for unchanged lines. The formats contain newline characters where newlines are desired on output. diff \ --old-line-format='-%l ' \ --new-line-format='|%l ' \ --unchanged-line-format=' %l ' \ old new To specify a line format, use one of the following options. You should quote FORMAT, since it often contains shell metacharacters. `--old-line-format=FORMAT' formats lines just from the first file. `--new-line-format=FORMAT' formats lines just from the second file. `--unchanged-line-format=FORMAT' formats lines common to both files. `--line-format=FORMAT' formats all lines; in effect, it sets all three above options simultaneously. In a line format, ordinary characters represent themselves; conversion specifications start with `%' and have one of the following forms. `%l' stands for the the contents of the line, not counting its trailing newline (if any). This format ignores whether the line is incomplete; *Note Incomplete Lines::. `%L' stands for the the contents of the line, including its trailing newline (if any). If a line is incomplete, this format preserves its incompleteness. `%%' stands for `%'. `%c'C'' where C is a single character, stands for C. C may not be a backslash or an apostrophe. For example, `%c':'' stands for a colon. `%c'\O'' where O is a string of 1, 2, or 3 octal digits, stands for the character with octal code O. For example, `%c'\0'' stands for a null character. `Fn' where F is a `printf' conversion specification, stands for the line number formatted with F. For example, `%.5dn' prints the line number using the `printf' format `"%.5d"'. *Note Line Group Formats::, for more about printf conversion specifications. The default line format is `%l' followed by a newline character. If the input contains tab characters and it is important that they line up on output, you should ensure that `%l' or `%L' in a line format is just after a tab stop (e.g. by preceding `%l' or `%L' with a tab character), or you should use the `-t' or `--expand-tabs' option. Taken together, the line and line group formats let you specify many different formats. For example, the following command uses a format similar to `diff''s normal format. You can tailor this command to get fine control over `diff''s output. diff \ --old-line-format='< %l ' \ --new-line-format='> %l ' \ --old-group-format='%df%(f=l?:,%dl)d%dE %<' \ --new-group-format='%dea%dF%(F=L?:,%dL) %>' \ --changed-group-format='%df%(f=l?:,%dl)c%dF%(F=L?:,%dL) %<--- %>' \ --unchanged-group-format='' \ old new  File: diff.info, Node: Detailed If-then-else, Next: Example If-then-else, Prev: Line Formats, Up: If-then-else Detailed Description of If-then-else Format ------------------------------------------- For lines common to both files, `diff' uses the unchanged line group format. For each hunk of differences in the merged output format, if the hunk contains only lines from the first file, `diff' uses the old line group format; if the hunk contains only lines from the second file, `diff' uses the new group format; otherwise, `diff' uses the changed group format. The old, new, and unchanged line formats specify the output format of lines from the first file, lines from the second file, and lines common to both files, respectively. The option `--ifdef=NAME' is equivalent to the following sequence of options using shell syntax: --old-group-format='#ifndef NAME %<#endif /* not NAME */ ' \ --new-group-format='#ifdef NAME %>#endif /* NAME */ ' \ --unchanged-group-format='%=' \ --changed-group-format='#ifndef NAME %<#else /* NAME */ %>#endif /* NAME */ ' You should carefully check the `diff' output for proper nesting. For example, when using the the `-D NAME' or `--ifdef=NAME' option, you should check that if the differing lines contain any of the C preprocessor directives `#ifdef', `#ifndef', `#else', `#elif', or `#endif', they are nested properly and match. If they don't, you must make corrections manually. It is a good idea to carefully check the resulting code anyway to make sure that it really does what you want it to; depending on how the input files were produced, the output might contain duplicate or otherwise incorrect code. The `patch' `-D NAME' option behaves just like the `diff' `-D NAME' option, except it operates on a file and a diff to produce a merged file; *Note patch Options::.  File: diff.info, Node: Example If-then-else, Prev: Detailed If-then-else, Up: If-then-else An Example of If-then-else Format --------------------------------- Here is the output of `diff -DTWO lao tzu' (*note Sample diff Input::., for the complete contents of the two files): #ifndef TWO The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. #endif /* not TWO */ The Nameless is the origin of Heaven and Earth; #ifndef TWO The Named is the mother of all things. #else /* TWO */ The named is the mother of all things. #endif /* TWO */ Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their outcome. The two are the same, But after they are produced, they have different names. #ifdef TWO They both may be called deep and profound. Deeper and more profound, The door of all subtleties! #endif /* TWO */  File: diff.info, Node: Comparing Directories, Next: Adjusting Output, Prev: Output Formats, Up: Top Comparing Directories ********************* You can use `diff' to compare some or all of the files in two directory trees. When both file name arguments to `diff' are directories, it compares each file that is contained in both directories, examining file names in alphabetical order. Normally `diff' is silent about pairs of files that contain no differences, but if you use the `-s' or `--report-identical-files' option, it reports pairs of identical files. Normally `diff' reports subdirectories common to both directories without comparing subdirectories' files, but if you use the `-r' or `--recursive' option, it compares every corresponding pair of files in the directory trees, as many levels deep as they go. For file names that are in only one of the directories, `diff' normally does not show the contents of the file that exists; it reports only that the file exists in that directory and not in the other. You can make `diff' act as though the file existed but was empty in the other directory, so that it outputs the entire contents of the file that actually exists. (It is output as either an insertion or a deletion, depending on whether it is in the first or the second directory given.) To do this, use the `-N' or `--new-file' option. If the older directory contains one or more large files that are not in the newer directory, you can make the patch smaller by using the `-P' or `--unidirectional-new-file' option instead of `-N'. This option is like `-N' except that it only inserts the contents of files that appear in the second directory but not the first (that is, files that were added). At the top of the patch, write instructions for the user applying the patch to remove the files that were deleted before applying the patch. *Note Making Patches::, for more discussion of making patches for distribution. To ignore some files while comparing directories, use the `-x PATTERN' or `--exclude=PATTERN' option. This option ignores any files or subdirectories whose base names match the shell pattern PATTERN. Unlike in the shell, a period at the start of the base of a file name matches a wildcard at the start of a pattern. You should enclose PATTERN in quotes so that the shell does not expand it. For example, the option `-x '*.[ao]'' ignores any file whose name ends with `.a' or `.o'. This option accumulates if you specify it more than once. For example, using the options `-x 'RCS' -x '*,v'' ignores any file or subdirectory whose base name is `RCS' or ends with `,v'. If you need to give this option many times, you can instead put the patterns in a file, one pattern per line, and use the `-X FILE' or `--exclude-from=FILE' option. If you have been comparing two directories and stopped partway through, later you might want to continue where you left off. You can do this by using the `-S FILE' or `--starting-file=FILE' option. This compares only the file FILE and all alphabetically later files in the topmost directory level.  File: diff.info, Node: Adjusting Output, Next: diff Performance, Prev: Comparing Directories, Up: Top Making `diff' Output Prettier ***************************** `diff' provides several ways to adjust the appearance of its output. These adjustments can be applied to any output format. * Menu: * Tabs:: Preserving the alignment of tabstops. * Pagination:: Page numbering and timestamping `diff' output.  File: diff.info, Node: Tabs, Next: Pagination, Up: Adjusting Output Preserving Tabstop Alignment ============================ The lines of text in some of the `diff' output formats are preceded by one or two characters that indicate whether the text is inserted, deleted, or changed. The addition of those characters can cause tabs to move to the next tabstop, throwing off the alignment of columns in the line. GNU `diff' provides two ways to make tab-aligned columns line up correctly. The first way is to have `diff' convert all tabs into the correct number of spaces before outputting them; select this method with the `-t' or `--expand-tabs' option. `diff' assumes that tabstops are set every 8 columns. To use this form of output with `patch', you must give `patch' the `-l' or `--ignore-white-space' option (*note Changed White Space::., for more information). The other method for making tabs line up correctly is to add a tab character instead of a space after the indicator character at the beginning of the line. This ensures that all following tab characters are in the same position relative to tabstops that they were in the original files, so that the output is aligned correctly. Its disadvantage is that it can make long lines too long to fit on one line of the screen or the paper. It also does not work with the unified output format, which does not have a space character after the change type indicator character. Select this method with the `-T' or `--initial-tab' option.  File: diff.info, Node: Pagination, Prev: Tabs, Up: Adjusting Output Paginating `diff' Output ======================== It can be convenient to have long output page-numbered and time-stamped. The `-l' and `--paginate' options do this by sending the `diff' output through the `pr' program. Here is what the page header might look like for `diff -lc lao tzu': Mar 11 13:37 1991 diff -lc lao tzu Page 1  File: diff.info, Node: diff Performance, Next: Comparing Three Files, Prev: Adjusting Output, Up: Top `diff' Performance Tradeoffs **************************** GNU `diff' runs quite efficiently; however, in some circumstances you can cause it to run faster or produce a more compact set of changes. There are two ways that you can affect the performance of GNU `diff' by changing the way it compares files. Performance has more than one dimension. These options improve one aspect of performance at the cost of another, or they improve performance in some cases while hurting it in others. The way that GNU `diff' determines which lines have changed always comes up with a near-minimal set of differences. Usually it is good enough for practical purposes. If the `diff' output is large, you might want `diff' to use a modified algorithm that sometimes produces a smaller set of differences. The `-d' or `--minimal' option does this; however, it can also cause `diff' to run more slowly than usual, so it is not the default behavior. When the files you are comparing are large and have small groups of changes scattered throughout them, you can use the `-H' or `--speed-large-files' option to make a different modification to the algorithm that `diff' uses. If the input files have a constant small density of changes, this option speeds up the comparisons without changing the output. If not, `diff' might produce a larger set of differences; however, the output will still be correct. Normally `diff' discards the prefix and suffix that is common to both files before it attempts to find a minimal set of differences. This makes `diff' run faster, but occasionally it may produce non-minimal output. The `--horizon-lines=LINES' option prevents `diff' from discarding the last LINES lines of the prefix and the first LINES lines of the suffix. This gives `diff' further opportunities to find a minimal output.  File: diff.info, Node: Comparing Three Files, Next: diff3 Merging, Prev: diff Performance, Up: Top Comparing Three Files ********************* Use the program `diff3' to compare three files and show any differences among them. (`diff3' can also merge files; see *Note diff3 Merging::). The "normal" `diff3' output format shows each hunk of differences without surrounding context. Hunks are labeled depending on whether they are two-way or three-way, and lines are annotated by their location in the input files. *Note Invoking diff3::, for more information on how to run `diff3'. * Menu: * Sample diff3 Input:: Sample `diff3' input for examples. * Detailed diff3 Normal:: A detailed description of normal output format. * diff3 Hunks:: The format of normal output format. * Example diff3 Normal:: Sample output in the normal format.  File: diff.info, Node: Sample diff3 Input, Next: Detailed diff3 Normal, Up: Comparing Three Files A Third Sample Input File ========================= Here is a third sample file that will be used in examples to illustrate the output of `diff3' and how various options can change it. The first two files are the same that we used for `diff' (*note Sample diff Input::.). This is the third sample file, called `tao': The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. The Nameless is the origin of Heaven and Earth; The named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their result. The two are the same, But after they are produced, they have different names. -- The Way of Lao-Tzu, tr. Wing-tsit Chan  File: diff.info, Node: Detailed diff3 Normal, Next: diff3 Hunks, Prev: Sample diff3 Input, Up: Comparing Three Files Detailed Description of `diff3' Normal Format ============================================= Each hunk begins with a line marked `===='. Three-way hunks have plain `====' lines, and two-way hunks have `1', `2', or `3' appended to specify which of the three input files differ in that hunk. The hunks contain copies of two or three sets of input lines each preceded by one or two commands identifying where the lines came from. Normally, two spaces precede each copy of an input line to distinguish it from the commands. But with the `-T' or `--initial-tab' option, `diff3' uses a tab instead of two spaces; this lines up tabs correctly. *Note Tabs::, for more information. Commands take the following forms: `FILE:La' This hunk appears after line L of file FILE, and contains no lines in that file. To edit this file to yield the other files, one must append hunk lines taken from the other files. For example, `1:11a' means that the hunk follows line 11 in the first file and contains no lines from that file. `FILE:Rc' This hunk contains the lines in the range R of file FILE. The range R is a comma-separated pair of line numbers, or just one number if the range is a singleton. To edit this file to yield the other files, one must change the specified lines to be the lines taken from the other files. For example, `2:11,13c' means that the hunk contains lines 11 through 13 from the second file. If the last line in a set of input lines is incomplete (*note Incomplete Lines::.), it is distinguished on output from a full line by a following line that starts with `\'.  File: diff.info, Node: diff3 Hunks, Next: Example diff3 Normal, Prev: Detailed diff3 Normal, Up: Comparing Three Files `diff3' Hunks ============= Groups of lines that differ in two or three of the input files are called "diff3 hunks", by analogy with `diff' hunks (*note Hunks::.). If all three input files differ in a `diff3' hunk, the hunk is called a "three-way hunk"; if just two input files differ, it is a "two-way hunk". As with `diff', several solutions are possible. When comparing the files `A', `B', and `C', `diff3' normally finds `diff3' hunks by merging the two-way hunks output by the two commands `diff A B' and `diff A C'. This does not necessarily minimize the size of the output, but exceptions should be rare. For example, suppose `F' contains the three lines `a', `b', `f', `G' contains the lines `g', `b', `g', and `H' contains the lines `a', `b', `h'. `diff3 F G H' might output the following: ====2 1:1c 3:1c a 2:1c g ==== 1:3c f 2:3c g 3:3c h because it found a two-way hunk containing `a' in the first and third files and `g' in the second file, then the single line `b' common to all three files, then a three-way hunk containing the last line of each file.  File: diff.info, Node: Example diff3 Normal, Prev: diff3 Hunks, Up: Comparing Three Files An Example of `diff3' Normal Format =================================== Here is the output of the command `diff3 lao tzu tao' (*note Sample diff3 Input::., for the complete contents of the files). Notice that it shows only the lines that are different among the three files. ====2 1:1,2c 3:1,2c The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. 2:0a ====1 1:4c The Named is the mother of all things. 2:2,3c 3:4,5c The named is the mother of all things. ====3 1:8c 2:7c so we may see their outcome. 3:9c so we may see their result. ==== 1:11a 2:11,13c They both may be called deep and profound. Deeper and more profound, The door of all subtleties! 3:13,14c -- The Way of Lao-Tzu, tr. Wing-tsit Chan  File: diff.info, Node: diff3 Merging, Next: Interactive Merging, Prev: Comparing Three Files, Up: Top Merging From a Common Ancestor ****************************** When two people have made changes to copies of the same file, `diff3' can produce a merged output that contains both sets of changes together with warnings about conflicts. One might imagine programs with names like `diff4' and `diff5' to compare more than three files simultaneously, but in practice the need rarely arises. You can use `diff3' to merge three or more sets of changes to a file by merging two change sets at a time. `diff3' can incorporate changes from two modified versions into a common preceding version. This lets you merge the sets of changes represented by the two newer files. Specify the common ancestor version as the second argument and the two newer versions as the first and third arguments, like this: diff3 MINE OLDER YOURS You can remember the order of the arguments by noting that they are in alphabetical order. You can think of this as subtracting OLDER from YOURS and adding the result to MINE, or as merging into MINE the changes that would turn OLDER into YOURS. This merging is well-defined as long as MINE and OLDER match in the neighborhood of each such change. This fails to be true when all three input files differ or when only OLDER differs; we call this a "conflict". When all three input files differ, we call the conflict an "overlap". `diff3' gives you several ways to handle overlaps and conflicts. You can omit overlaps or conflicts, or select only overlaps, or mark conflicts with special `<<<<<<<' and `>>>>>>>' lines. `diff3' can output the merge results as an `ed' script that that can be applied to the first file to yield the merged output. However, it is usually better to have `diff3' generate the merged output directly; this bypasses some problems with `ed'. * Menu: * Which Changes:: Selecting changes to incorporate. * Marking Conflicts:: Marking conflicts. * Bypassing ed:: Generating merged output directly. * Merging Incomplete Lines:: How `diff3' merges incomplete lines. * Saving the Changed File:: Emulating System V behavior.  File: diff.info, Node: Which Changes, Next: Marking Conflicts, Up: diff3 Merging Selecting Which Changes to Incorporate ====================================== You can select all unmerged changes from OLDER to YOURS for merging into MINE with the `-e' or `--ed' option. You can select only the nonoverlapping unmerged changes with `-3' or `--easy-only', and you can select only the overlapping changes with `-x' or `--overlap-only'. The `-e', `-3' and `-x' options select only "unmerged changes", i.e. changes where MINE and YOURS differ; they ignore changes from OLDER to YOURS where MINE and YOURS are identical, because they assume that such changes have already been merged. If this assumption is not a safe one, you can use the `-A' or `--show-all' option (*note Marking Conflicts::.). Here is the output of the command `diff3' with each of these three options (*note Sample diff3 Input::., for the complete contents of the files). Notice that `-e' outputs the union of the disjoint sets of changes output by `-3' and `-x'. Output of `diff3 -e lao tzu tao': 11a -- The Way of Lao-Tzu, tr. Wing-tsit Chan . 8c so we may see their result. . Output of `diff3 -3 lao tzu tao': 8c so we may see their result. . Output of `diff3 -x lao tzu tao': 11a -- The Way of Lao-Tzu, tr. Wing-tsit Chan .  File: diff.info, Node: Marking Conflicts, Next: Bypassing ed, Prev: Which Changes, Up: diff3 Merging Marking Conflicts ================= `diff3' can mark conflicts in the merged output by bracketing them with special marker lines. A conflict that comes from two files A and B is marked as follows: <<<<<<< A lines from A ======= lines from B >>>>>>> B A conflict that comes from three files A, B and C is marked as follows: <<<<<<< A lines from A ||||||| B lines from B ======= lines from C >>>>>>> C The `-A' or `--show-all' option acts like the `-e' option, except that it brackets conflicts, and it outputs all changes from OLDER to YOURS, not just the unmerged changes. Thus, given the sample input files (*note Sample diff3 Input::.), `diff3 -A lao tzu tao' puts brackets around the conflict where only `tzu' differs: <<<<<<< tzu ======= The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. >>>>>>> tao And it outputs the three-way conflict as follows: <<<<<<< lao ||||||| tzu They both may be called deep and profound. Deeper and more profound, The door of all subtleties! ======= -- The Way of Lao-Tzu, tr. Wing-tsit Chan >>>>>>> tao The `-E' or `--show-overlap' option outputs less information than the `-A' or `--show-all' option, because it outputs only unmerged changes, and it never outputs the contents of the second file. Thus the `-E' option acts like the `-e' option, except that it brackets the first and third files from three-way overlapping changes. Similarly, `-X' acts like `-x', except it brackets all its (necessarily overlapping) changes. For example, for the three-way overlapping change above, the `-E' and `-X' options output the following: <<<<<<< lao ======= -- The Way of Lao-Tzu, tr. Wing-tsit Chan >>>>>>> tao If you are comparing files that have meaningless or uninformative names, you can use the `-L LABEL' or `--label=LABEL' option to show alternate names in the `<<<<<<<', `|||||||' and `>>>>>>>' brackets. This option can be given up to three times, once for each input file. Thus `diff3 -A -L X -L Y -L Z A B C' acts like `diff3 -A A B C', except that the output looks like it came from files named `X', `Y' and `Z' rather than from files named `A', `B' and `C'.  File: diff.info, Node: Bypassing ed, Next: Merging Incomplete Lines, Prev: Marking Conflicts, Up: diff3 Merging Generating the Merged Output Directly ===================================== With the `-m' or `--merge' option, `diff3' outputs the merged file directly. This is more efficient than using `ed' to generate it, and works even with non-text files that `ed' would reject. If you specify `-m' without an `ed' script option, `-A' (`--show-all') is assumed. For example, the command `diff3 -m lao tzu tao' (*note Sample diff3 Input::. for a copy of the input files) would output the following: <<<<<<< tzu ======= The Way that can be told of is not the eternal Way; The name that can be named is not the eternal name. >>>>>>> tao The Nameless is the origin of Heaven and Earth; The Named is the mother of all things. Therefore let there always be non-being, so we may see their subtlety, And let there always be being, so we may see their result. The two are the same, But after they are produced, they have different names. <<<<<<< lao ||||||| tzu They both may be called deep and profound. Deeper and more profound, The door of all subtleties! ======= -- The Way of Lao-Tzu, tr. Wing-tsit Chan >>>>>>> tao  File: diff.info, Node: Merging Incomplete Lines, Next: Saving the Changed File, Prev: Bypassing ed, Up: diff3 Merging How `diff3' Merges Incomplete Lines =================================== With `-m', incomplete lines (*note Incomplete Lines::.) are simply copied to the output as they are found; if the merged output ends in an conflict and one of the input files ends in an incomplete line, succeeding `|||||||', `=======' or `>>>>>>>' brackets appear somewhere other than the start of a line because they are appended to the incomplete line. Without `-m', if an `ed' script option is specified and an incomplete line is found, `diff3' generates a warning and acts as if a newline had been present.  File: diff.info, Node: Saving the Changed File, Prev: Merging Incomplete Lines, Up: diff3 Merging Saving the Changed File ======================= Traditional Unix `diff3' generates an `ed' script without the trailing `w' and and `q' commands that save the changes. System V `diff3' generates these extra commands. GNU `diff3' normally behaves like traditional Unix `diff3', but with the `-i' option it behaves like System V `diff3' and appends the `w' and `q' commands. The `-i' option requires one of the `ed' script options `-AeExX3', and is incompatible with the merged output option `-m'.  File: diff.info, Node: Interactive Merging, Next: Merging with patch, Prev: diff3 Merging, Up: Top Interactive Merging with `sdiff' ******************************** With `sdiff', you can merge two files interactively based on a side-by-side `-y' format comparison (*note Side by Side::.). Use `-o FILE' or `--output=FILE' to specify where to put the merged text. *Note Invoking sdiff::, for more details on the options to `sdiff'. Another way to merge files interactively is to use the Emacs Lisp package `emerge'. *Note emerge: (emacs)emerge, for more information. * Menu: * sdiff Option Summary::Summary of `sdiff' options. * Merge Commands:: Merging two files interactively.  File: diff.info, Node: sdiff Option Summary, Next: Merge Commands, Up: Interactive Merging Specifying `diff' Options to `sdiff' ==================================== The following `sdiff' options have the same meaning as for `diff'. *Note diff Options::, for the use of these options. -a -b -d -i -t -v -B -H -I REGEXP --ignore-blank-lines --ignore-case --ignore-matching-lines=REGEXP --ignore-space-change --left-column --minimal --speed-large-files --suppress-common-lines --expand-tabs --text --version --width=COLUMNS For historical reasons, `sdiff' has alternate names for some options. The `-l' option is equivalent to the `--left-column' option, and similarly `-s' is equivalent to `--suppress-common-lines'. The meaning of the `sdiff' `-w' and `-W' options is interchanged from that of `diff': with `sdiff', `-w COLUMNS' is equivalent to `--width=COLUMNS', and `-W' is equivalent to `--ignore-all-space'. `sdiff' without the `-o' option is equivalent to `diff' with the `-y' or `--side-by-side' option (*note Side by Side::.).  File: diff.info, Node: Merge Commands, Prev: sdiff Option Summary, Up: Interactive Merging Merge Commands ============== Groups of common lines, with a blank gutter, are copied from the first file to the output. After each group of differing lines, `sdiff' prompts with `%' and pauses, waiting for one of the following commands. Follow each command with RET. `e' Discard both versions. Invoke a text editor on an empty temporary file, then copy the resulting file to the output. `eb' Concatenate the two versions, edit the result in a temporary file, then copy the edited result to the output. `el' Edit a copy of the left version, then copy the result to the output. `er' Edit a copy of the right version, then copy the result to the output. `l' Copy the left version to the output. `q' Quit. `r' Copy the right version to the output. `s' Silently copy common lines. `v' Verbosely copy common lines. This is the default. The text editor invoked is specified by the `EDITOR' environment variable if it is set. The default is system-dependent.  File: diff.info, Node: Merging with patch, Next: Making Patches, Prev: Interactive Merging, Up: Top Merging with `patch' ******************** `patch' takes comparison output produced by `diff' and applies the differences to a copy of the original file, producing a patched version. With `patch', you can distribute just the changes to a set of files instead of distributing the entire file set; your correspondents can apply `patch' to update their copy of the files with your changes. `patch' automatically determines the diff format, skips any leading or trailing headers, and uses the headers to determine which file to patch. This lets your correspondents feed an article or message containing a difference listing directly to `patch'. `patch' detects and warns about common problems like forward patches. It saves the original version of the files it patches, and saves any patches that it could not apply. It can also maintain a `patchlevel.h' file to ensures that your correspondents apply diffs in the proper order. `patch' accepts a series of diffs in its standard input, usually separated by headers that specify which file to patch. It applies `diff' hunks (*note Hunks::.) one by one. If a hunk does not exactly match the original file, `patch' uses heuristics to try to patch the file as well as it can. If no approximate match can be found, `patch' rejects the hunk and skips to the next hunk. `patch' normally replaces each file F with its new version, saving the original file in `F.orig', and putting reject hunks (if any) into `F.rej'. *Note Invoking patch::, for detailed information on the options to `patch'. *Note Backups::, for more information on how `patch' names backup files. *Note Rejects::, for more information on where `patch' puts reject hunks. * Menu: * patch Input:: Selecting the type of `patch' input. * Imperfect:: Dealing with imperfect patches. * Empty Files:: Removing empty files after patching. * Multiple Patches:: Handling multiple patches in a file specially. * patch Messages:: Messages and questions `patch' can produce.  File: diff.info, Node: patch Input, Next: Imperfect, Up: Merging with patch Selecting the `patch' Input Format ================================== `patch' normally determines which `diff' format the patch file uses by examining its contents. For patch files that contain particularly confusing leading text, you might need to use one of the following options to force `patch' to interpret the patch file as a certain format of diff. The output formats listed here are the only ones that `patch' can understand. `-c' `--context' context diff. `-e' `--ed' `ed' script. `-n' `--normal' normal diff. `-u' `--unified' unified diff.  File: diff.info, Node: Imperfect, Next: Empty Files, Prev: patch Input, Up: Merging with patch Applying Imperfect Patches ========================== `patch' tries to skip any leading text in the patch file, apply the diff, and then skip any trailing text. Thus you can feed a news article or mail message directly to `patch', and it should work. If the entire diff is indented by a constant amount of white space, `patch' automatically ignores the indentation. However, certain other types of imperfect input require user intervention. * Menu: * Changed White Space:: When tabs and spaces don't match exactly. * Reversed Patches:: Applying reversed patches correctly. * Inexact:: Helping `patch' find close matches.  File: diff.info, Node: Changed White Space, Next: Reversed Patches, Up: Imperfect Applying Patches with Changed White Space ----------------------------------------- Sometimes mailers, editors, or other programs change spaces into tabs, or vice versa. If this happens to a patch file or an input file, the files might look the same, but `patch' will not be able to match them properly. If this problem occurs, use the `-l' or `--ignore-white-space' option, which makes `patch' compare white space loosely so that any sequence of white space in the patch file matches any sequence of white space in the input files. Non-white-space characters must still match exactly. Each line of the context must still match a line in the input file.  File: diff.info, Node: Reversed Patches, Next: Inexact, Prev: Changed White Space, Up: Imperfect Applying Reversed Patches ------------------------- Sometimes people run `diff' with the new file first instead of second. This creates a diff that is "reversed". To apply such patches, give `patch' the `-R' or `--reverse' option. `patch' then attempts to swap each hunk around before applying it. Rejects come out in the swapped format. The `-R' option does not work with `ed' scripts because there is too little information in them to reconstruct the reverse operation. Often `patch' can guess that the patch is reversed. If the first hunk of a patch fails, `patch' reverses the hunk to see if it can apply it that way. If it can, `patch' asks you if you want to have the `-R' option set; if it can't, `patch' continues to apply the patch normally. This method cannot detect a reversed patch if it is a normal diff and the first command is an append (which should have been a delete) since appends always succeed, because a null context matches anywhere. But most patches add or change lines rather than delete them, so most reversed normal diffs begin with a delete, which fails, and `patch' notices. If you apply a patch that you have already applied, `patch' thinks it is a reversed patch and offers to un-apply the patch. This could be construed as a feature. If you did this inadvertently and you don't want to un-apply the patch, just answer `n' to this offer and to the subsequent "apply anyway" question--or type `C-c' to kill the `patch' process.  File: diff.info, Node: Inexact, Prev: Reversed Patches, Up: Imperfect Helping `patch' Find Inexact Matches ------------------------------------ For context diffs, and to a lesser extent normal diffs, `patch' can detect when the line numbers mentioned in the patch are incorrect, and it attempts to find the correct place to apply each hunk of the patch. As a first guess, it takes the line number mentioned in the hunk, plus or minus any offset used in applying the previous hunk. If that is not the correct place, `patch' scans both forward and backward for a set of lines matching the context given in the hunk. First `patch' looks for a place where all lines of the context match. If it cannot find such a place, and it is reading a context or unified diff, and the maximum fuzz factor is set to 1 or more, then `patch' makes another scan, ignoring the first and last line of context. If that fails, and the maximum fuzz factor is set to 2 or more, it makes another scan, ignoring the first two and last two lines of context are ignored. It continues similarly if the maximum fuzz factor is larger. The `-F LINES' or `--fuzz=LINES' option sets the maximum fuzz factor to LINES. This option only applies to context and unified diffs; it ignores up to LINES lines while looking for the place to install a hunk. Note that a larger fuzz factor increases the odds of making a faulty patch. The default fuzz factor is 2; it may not be set to more than the number of lines of context in the diff, ordinarily 3. If `patch' cannot find a place to install a hunk of the patch, it writes the hunk out to a reject file (*note Rejects::., for information on how reject files are named). It writes out rejected hunks in context format no matter what form the input patch is in. If the input is a normal or `ed' diff, many of the contexts are simply null. The line numbers on the hunks in the reject file may be different from those in the patch file: they show the approximate location where `patch' thinks the failed hunks belong in the new file rather than in the old one. As it completes each hunk, `patch' tells you whether the hunk succeeded or failed, and if it failed, on which line (in the new file) `patch' thinks the hunk should go. If this is different from the line number specified in the diff, it tells you the offset. A single large offset *may* indicate that `patch' installed a hunk in the wrong place. `patch' also tells you if it used a fuzz factor to make the match, in which case you should also be slightly suspicious. `patch' cannot tell if the line numbers are off in an `ed' script, and can only detect wrong line numbers in a normal diff when it finds a change or delete command. It may have the same problem with a context diff using a fuzz factor equal to or greater than the number of lines of context shown in the diff (typically 3). In these cases, you should probably look at a context diff between your original and patched input files to see if the changes make sense. Compiling without errors is a pretty good indication that the patch worked, but not a guarantee. `patch' usually produces the correct results, even when it must make many guesses. However, the results are guaranteed only when the patch is applied to an exact copy of the file that the patch was generated from.  File: diff.info, Node: Empty Files, Next: Multiple Patches, Prev: Imperfect, Up: Merging with patch Removing Empty Files ==================== Sometimes when comparing two directories, the first directory contains a file that the second directory does not. If you give `diff' the `-N' or `--new-file' option, it outputs a diff that deletes the contents of this file. By default, `patch' leaves an empty file after applying such a diff. The `-E' or `--remove-empty-files' option to `patch' deletes output files that are empty after applying the diff.  File: diff.info, Node: Multiple Patches, Next: patch Messages, Prev: Empty Files, Up: Merging with patch Multiple Patches in a File ========================== If the patch file contains more than one patch, `patch' tries to apply each of them as if they came from separate patch files. This means that it determines the name of the file to patch for each patch, and that it examines the leading text before each patch for file names and prerequisite revision level (*note Making Patches::., for more on that topic). For the second and subsequent patches in the patch file, you can give options and another original file name by separating their argument lists with a `+'. However, the argument list for a second or subsequent patch may not specify a new patch file, since that does not make sense. For example, to tell `patch' to strip the first three slashes from the name of the first patch in the patch file and none from subsequent patches, and to use `code.c' as the first input file, you can use: patch -p3 code.c + -p0 < patchfile The `-S' or `--skip' option ignores the current patch from the patch file, but continue looking for the next patch in the file. Thus, to ignore the first and third patches in the patch file, you can use: patch -S + + -S + < patch file  File: diff.info, Node: patch Messages, Prev: Multiple Patches, Up: Merging with patch Messages and Questions from `patch' =================================== `patch' can produce a variety of messages, especially if it has trouble decoding its input. In a few situations where it's not sure how to proceed, `patch' normally prompts you for more information from the keyboard. There are options to suppress printing non-fatal messages and stopping for keyboard input. The message `Hmm...' indicates that `patch' is reading text in the patch file, attempting to determine whether there is a patch in that text, and if so, what kind of patch it is. You can inhibit all terminal output from `patch', unless an error occurs, by using the `-s', `--quiet', or `--silent' option. There are two ways you can prevent `patch' from asking you any questions. The `-f' or `--force' option assumes that you know what you are doing. It assumes the following: * skip patches that do not contain file names in their headers; * patch files even though they have the wrong version for the `Prereq:' line in the patch; * assume that patches are not reversed even if they look like they are. The `-t' or `--batch' option is similar to `-f', in that it suppresses questions, but it makes somewhat different assumptions: * skip patches that do not contain file names in their headers (the same as `-f'); * skip patches for which the file has the wrong version for the `Prereq:' line in the patch; * assume that patches are reversed if they look like they are. `patch' exits with a non-zero status if it creates any reject files. When applying a set of patches in a loop, you should check the exit status, so you don't apply a later patch to a partially patched file. diffutils-2.4/diff.info-3100666 21641 13 133525 5445723622 14401 0ustar friedmanuserThis is Info file diff.info, produced by Makeinfo-1.55 from the input file ./diff.texi. This file documents the the GNU `diff', `diff3', `sdiff', and `cmp' commands for showing the differences between text files and the `patch' command for using their output to update files. Copyright (C) 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.  File: diff.info, Node: Making Patches, Next: Invoking cmp, Prev: Merging with patch, Up: Top Tips for Making Patch Distributions *********************************** Here are some things you should keep in mind if you are going to distribute patches for updating a software package. Make sure you have specified the file names correctly, either in a context diff header or with an `Index:' line. If you are patching files in a subdirectory, be sure to tell the patch user to specify a `-p' or `--strip' option as needed. Take care to not send out reversed patches, since these make people wonder whether they have already applied the patch. To save people from partially applying a patch before other patches that should have gone before it, you can make the first patch in the patch file update a file with a name like `patchlevel.h' or `version.c', which contains a patch level or version number. If the input file contains the wrong version number, `patch' will complain immediately. An even clearer way to prevent this problem is to put a `Prereq:' line before the patch. If the leading text in the patch file contains a line that starts with `Prereq:', `patch' takes the next word from that line (normally a version number) and checks whether the next input file contains that word, preceded and followed by either white space or a newline. If not, `patch' prompts you for confirmation before proceeding. This makes it difficult to accidentally apply patches in the wrong order. Since `patch' does not handle incomplete lines properly, make sure that all the source files in your program end with a newline whenever you release a version. To create a patch that changes an older version of a package into a newer version, first make a copy of the older version in a scratch directory. Typically you do that by unpacking a `tar' or `shar' archive of the older version. You might be able to reduce the size of the patch by renaming or removing some files before making the patch. If the older version of the package contains any files that the newer version does not, or if any files have been renamed between the two versions, make a list of `rm' and `mv' commands for the user to execute in the old version directory before applying the patch. Then run those commands yourself in the scratch directory. If there are any files that you don't need to include in the patch because they can easily be rebuilt from other files (for example, `TAGS' and output from `yacc' and `makeinfo'), replace the versions in the scratch directory with the newer versions, using `rm' and `ln' or `cp'. Now you can create the patch. The de-facto standard `diff' format for patch distributions is context format with two lines of context, produced by giving `diff' the `-C 2' option. Do not use less than two lines of context, because `patch' typically needs at least two lines for proper operation. Give `diff' the `-P' option in case the newer version of the package contains any files that the older one does not. Make sure to specify the scratch directory first and the newer directory second. Add to the top of the patch a note telling the user any `rm' and `mv' commands to run before applying the patch. Then you can remove the scratch directory.  File: diff.info, Node: Invoking cmp, Next: Invoking diff, Prev: Making Patches, Up: Top Invoking `cmp' ************** The `cmp' command compares two files, and if they differ, tells the first byte and line number where they differ. Its arguments are as follows: cmp OPTIONS... FROM-FILE [TO-FILE] The file name `-' is always the standard input. `cmp' also uses the standard input if one file name is omitted. An exit status of 0 means no differences were found, 1 means some differences were found, and 2 means trouble. * Menu: * cmp Options:: Summary of options to `cmp'.  File: diff.info, Node: cmp Options, Up: Invoking cmp Options to `cmp' ================ Below is a summary of all of the options that GNU `cmp' accepts. Most options have two equivalent names, one of which is a single letter preceded by `-', and the other of which is a long name preceded by `--'. Multiple single letter options (unless they take an argument) can be combined into a single command line word: `-cl' is equivalent to `-c -l'. `-c' Print the differing characters. Display control characters as a `^' followed by a letter of the alphabet and precede characters that have the high bit set with `M-' (which stands for "meta"). `--ignore-initial=BYTES' Ignore any differences in the the first BYTES bytes of the input files. Treat files with fewer than BYTES bytes as if they are empty. `-l' Print the (decimal) offsets and (octal) values of all differing bytes. `--print-chars' Print the differing characters. Display control characters as a `^' followed by a letter of the alphabet and precede characters that have the high bit set with `M-' (which stands for "meta"). `--quiet' `-s' `--silent' Do not print anything; only return an exit status indicating whether the files differ. `--verbose' Print the (decimal) offsets and (octal) values of all differing bytes.  File: diff.info, Node: Invoking diff, Next: Invoking diff3, Prev: Invoking cmp, Up: Top Invoking `diff' *************** The format for running the `diff' command is: diff OPTIONS... FROM-FILE TO-FILE In the simplest case, `diff' compares the contents of the two files FROM-FILE and TO-FILE. A file name of `-' stands for text read from the standard input. As a special case, `diff - -' compares a copy of standard input to itself. If FROM-FILE is a directory and TO-FILE is not, `diff' compares the file in FROM-FILE whose file name is that of TO-FILE, and vice versa. The non-directory file must not be `-'. If both FROM-FILE and TO-FILE are directories, `diff' compares corresponding files in both directories, in alphabetical order; this comparison is not recursive unless the `-r' or `--recursive' option is given. `diff' never compares the actual contents of a directory as if it were a file. The file that is fully specified may not be standard input, because standard input is nameless and the notion of "file with the same name" does not apply. `diff' options begin with `-', so normally FROM-FILE and TO-FILE may not begin with `-'. However, `--' as an argument by itself treats the remaining arguments as file names even if they begin with `-'. An exit status of 0 means no differences were found, 1 means some differences were found, and 2 means trouble. * Menu: * diff Options:: Summary of options to `diff'.  File: diff.info, Node: diff Options, Up: Invoking diff Options to `diff' ================= Below is a summary of all of the options that GNU `diff' accepts. Most options have two equivalent names, one of which is a single letter preceded by `-', and the other of which is a long name preceded by `--'. Multiple single letter options (unless they take an argument) can be combined into a single command line word: `-ac' is equivalent to `-a -c'. Long named options can be abbreviated to any unique prefix of their name. Brackets ([ and ]) indicate that an option takes an optional argument. `-LINES' Show LINES (an integer) lines of context. This option does not specify an output format by itself; it has no effect unless it is combined with `-c' (*note Context Format::.) or `-u' (*note Unified Format::.). This option is obsolete. For proper operation, `patch' typically needs at least two lines of context. `-a' Treat all files as text and compare them line-by-line, even if they do not seem to be text. *Note Binary::. `-b' Ignore changes in amount of white space. *Note White Space::. `-B' Ignore changes that just insert or delete blank lines. *Note Blank Lines::. `--brief' Report only whether the files differ, not the details of the differences. *Note Brief::. `-c' Use the context output format. *Note Context Format::. `-C LINES' `--context[=LINES]' Use the context output format, showing LINES (an integer) lines of context, or three if LINES is not given. *Note Context Format::. For proper operation, `patch' typically needs at least two lines of context. `--changed-group-format=FORMAT' Use FORMAT to output a line group containing differing lines from both files in if-then-else format. *Note Line Group Formats::. `-d' Change the algorithm perhaps find a smaller set of changes. This makes `diff' slower (sometimes much slower). *Note diff Performance::. `-D NAME' Make merged `#ifdef' format output, conditional on the preprocessor macro NAME. *Note If-then-else::. `-e' `--ed' Make output that is a valid `ed' script. *Note ed Scripts::. `--exclude=PATTERN' When comparing directories, ignore files and subdirectories whose basenames match PATTERN. *Note Comparing Directories::. `--exclude-from=FILE' When comparing directories, ignore files and subdirectories whose basenames match any pattern contained in FILE. *Note Comparing Directories::. `--expand-tabs' Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files. *Note Tabs::. `-f' Make output that looks vaguely like an `ed' script but has changes in the order they appear in the file. *Note Forward ed::. `-F REGEXP' In context and unified format, for each hunk of differences, show some of the last preceding line that matches REGEXP. *Note Specified Headings::. `--forward-ed' Make output that looks vaguely like an `ed' script but has changes in the order they appear in the file. *Note Forward ed::. `-h' This option currently has no effect; it is present for Unix compatibility. `-H' Use heuristics to speed handling of large files that have numerous scattered small changes. *Note diff Performance::. `--horizon-lines=LINES' Do not discard the last LINES lines of the common prefix and the first LINES lines of the common suffix. *Note diff Performance::. `-i' Ignore changes in case; consider upper- and lower-case letters equivalent. *Note Case Folding::. `-I REGEXP' Ignore changes that just insert or delete lines that match REGEXP. *Note Specified Folding::. `--ifdef=NAME' Make merged if-then-else output using FORMAT. *Note If-then-else::. `--ignore-all-space' Ignore white space when comparing lines. *Note White Space::. `--ignore-blank-lines' Ignore changes that just insert or delete blank lines. *Note Blank Lines::. `--ignore-case' Ignore changes in case; consider upper- and lower-case to be the same. *Note Case Folding::. `--ignore-matching-lines=REGEXP' Ignore changes that just insert or delete lines that match REGEXP. *Note Specified Folding::. `--ignore-space-change' Ignore changes in amount of white space. *Note White Space::. `--initial-tab' Output a tab rather than a space before the text of a line in normal or context format. This causes the alignment of tabs in the line to look normal. *Note Tabs::. `-l' Pass the output through `pr' to paginate it. *Note Pagination::. `-L LABEL' Use LABEL instead of the file name in the context format (*note Context Format::.) and unified format (*note Unified Format::.) headers. *Note RCS::. `--label=LABEL' Use LABEL instead of the file name in the context format (*note Context Format::.) and unified format (*note Unified Format::.) headers. `--left-column' Print only the left column of two common lines in side by side format. *Note Side by Side Format::. `--line-format=FORMAT' Use FORMAT to output all input lines in if-then-else format. *Note Line Formats::. `--minimal' Change the algorithm to perhaps find a smaller set of changes. This makes `diff' slower (sometimes much slower). *Note diff Performance::. `-n' Output RCS-format diffs; like `-f' except that each command specifies the number of lines affected. *Note RCS::. `-N' `--new-file' In directory comparison, if a file is found in only one directory, treat it as present but empty in the other directory. *Note Comparing Directories::. `--new-group-format=FORMAT' Use FORMAT to output a group of lines taken from just the second file in if-then-else format. *Note Line Group Formats::. `--new-line-format=FORMAT' Use FORMAT to output a line taken from just the second file in if-then-else format. *Note Line Formats::. `--old-group-format=FORMAT' Use FORMAT to output a group of lines taken from just the first file in if-then-else format. *Note Line Group Formats::. `--old-line-format=FORMAT' Use FORMAT to output a line taken from just the first file in if-then-else format. *Note Line Formats::. `-p' Show which C function each change is in. *Note C Function Headings::. `-P' When comparing directories, if a file appears only in the second directory of the two, treat it as present but empty in the other. *Note Comparing Directories::. `--paginate' Pass the output through `pr' to paginate it. *Note Pagination::. `-q' Report only whether the files differ, not the details of the differences. *Note Brief::. `-r' When comparing directories, recursively compare any subdirectories found. *Note Comparing Directories::. `--rcs' Output RCS-format diffs; like `-f' except that each command specifies the number of lines affected. *Note RCS::. `--recursive' When comparing directories, recursively compare any subdirectories found. *Note Comparing Directories::. `--report-identical-files' Report when two files are the same. *Note Comparing Directories::. `-s' Report when two files are the same. *Note Comparing Directories::. `-S FILE' When comparing directories, start with the file FILE. This is used for resuming an aborted comparison. *Note Comparing Directories::. `--sdiff-merge-assist' Print extra information to help `sdiff'. `sdiff' uses this option when it runs `diff'. This option is not intended for users to use directly. `--show-c-function' Show which C function each change is in. *Note C Function Headings::. `--show-function-line=REGEXP' In context and unified format, for each hunk of differences, show some of the last preceding line that matches REGEXP. *Note Specified Headings::. `--side-by-side' Use the side by side output format. *Note Side by Side Format::. `--speed-large-files' Use heuristics to speed handling of large files that have numerous scattered small changes. *Note diff Performance::. `--starting-file=FILE' When comparing directories, start with the file FILE. This is used for resuming an aborted comparison. *Note Comparing Directories::. `--suppress-common-lines' Do not print common lines in side by side format. *Note Side by Side Format::. `-t' Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files. *Note Tabs::. `-T' Output a tab rather than a space before the text of a line in normal or context format. This causes the alignment of tabs in the line to look normal. *Note Tabs::. `--text' Treat all files as text and compare them line-by-line, even if they do not appear to be text. *Note Binary::. `-u' Use the unified output format. *Note Unified Format::. `--unchanged-group-format=FORMAT' Use FORMAT to output a group of common lines taken from both files in if-then-else format. *Note Line Group Formats::. `--unchanged-line-format=FORMAT' Use FORMAT to output a line common to both files in if-then-else format. *Note Line Formats::. `--unidirectional-new-file' When comparing directories, if a file appears only in the second directory of the two, treat it as present but empty in the other. *Note Comparing Directories::. `-U LINES' `--unified[=LINES]' Use the unified output format, showing LINES (an integer) lines of context, or three if LINES is not given. *Note Unified Format::. For proper operation, `patch' typically needs at least two lines of context. `-v' `--version' Output the version number of `diff'. `-w' Ignore white space when comparing lines. *Note White Space::. `-W COLUMNS' `--width=COLUMNS' Use an output width of COLUMNS in side by side format. *Note Side by Side Format::. `-x PATTERN' When comparing directories, ignore files and subdirectories whose basenames match PATTERN. *Note Comparing Directories::. `-X FILE' When comparing directories, ignore files and subdirectories whose basenames match any pattern contained in FILE. *Note Comparing Directories::. `-y' Use the side by side output format. *Note Side by Side Format::.  File: diff.info, Node: Invoking diff3, Next: Invoking patch, Prev: Invoking diff, Up: Top Invoking `diff3' **************** The `diff3' command compares three files and outputs descriptions of their differences. Its arguments are as follows: diff3 OPTIONS... MINE OLDER YOURS The files to compare are MINE, OLDER, and YOURS. At most one of these three file names may be `-', which tells `diff3' to read the standard input for that file. An exit status of 0 means `diff3' was successful, 1 means some conflicts were found, and 2 means trouble. * Menu: * diff3 Options:: Summary of options to `diff3'.  File: diff.info, Node: diff3 Options, Up: Invoking diff3 Options to `diff3' ================== Below is a summary of all of the options that GNU `diff3' accepts. Multiple single letter options (unless they take an argument) can be combined into a single command line argument. `-a' Treat all files as text and compare them line-by-line, even if they do not appear to be text. *Note Binary::. `-A' Incorporate all changes from OLDER to YOURS into MINE, surrounding all conflicts with bracket lines. *Note Marking Conflicts::. `-e' Generate an `ed' script that incorporates all the changes from OLDER to YOURS into MINE. *Note Which Changes::. `-E' Like `-e', except bracket lines from overlapping changes' first and third files. *Note Marking Conflicts::. With `-e', an overlapping change looks like this: <<<<<<< MINE lines from MINE ======= lines from YOURS >>>>>>> YOURS `--ed' Generate an `ed' script that incorporates all the changes from OLDER to YOURS into MINE. *Note Which Changes::. `--easy-only' Like `-e', except output only the nonoverlapping changes. *Note Which Changes::. `-i' Generate `w' and `q' commands at the end of the `ed' script for System V compatibility. This option must be combined with one of the `-AeExX3' options, and may not be combined with `-m'. *Note Saving the Changed File::. `--initial-tab' Output a tab rather than two spaces before the text of a line in normal format. This causes the alignment of tabs in the line to look normal. *Note Tabs::. `-L LABEL' `--label=LABEL' Use the label LABEL for the brackets output by the `-A', `-E' and `-X' options. This option may be given up to three times, one for each input file. The default labels are the names of the input files. Thus `diff3 -L X -L Y -L Z -m A B C' acts like `diff3 -m A B C', except that the output looks like it came from files named `X', `Y' and `Z' rather than from files named `A', `B' and `C'. *Note Marking Conflicts::. `-m' `--merge' Apply the edit script to the first file and send the result to standard output. Unlike piping the output from `diff3' to `ed', this works even for binary files and incomplete lines. `-A' is assumed if no edit script option is specified. *Note Bypassing ed::. `--overlap-only' Like `-e', except output only the overlapping changes. *Note Which Changes::. `--show-all' Incorporate all unmerged changes from OLDER to YOURS into MINE, surrounding all overlapping changes with bracket lines. *Note Marking Conflicts::. `--show-overlap' Like `-e', except bracket lines from overlapping changes' first and third files. *Note Marking Conflicts::. `-T' Output a tab rather than two spaces before the text of a line in normal format. This causes the alignment of tabs in the line to look normal. *Note Tabs::. `--text' Treat all files as text and compare them line-by-line, even if they do not appear to be text. *Note Binary::. `-v' `--version' Output the version number of `diff3'. `-x' Like `-e', except output only the overlapping changes. *Note Which Changes::. `-X' Like `-E', except output only the overlapping changes. In other words, like `-x', except bracket changes as in `-E'. *Note Marking Conflicts::. `-3' Like `-e', except output only the nonoverlapping changes. *Note Which Changes::.  File: diff.info, Node: Invoking patch, Next: Invoking sdiff, Prev: Invoking diff3, Up: Top Invoking `patch' **************** Normally `patch' is invoked like this: patch g \ No newline at end of file (The exact message may differ in non-English locales.) `diff -n F G' outputs the following without a trailing newline: d1 1 a1 1 g `diff -e F G' reports two errors and outputs the following: 1c g .  File: diff.info, Node: Projects, Next: Concept Index, Prev: Incomplete Lines, Up: Top Future Projects *************** Here are some ideas for improving GNU `diff' and `patch'. The GNU project has identified some improvements as potential programming projects for volunteers. You can also help by reporting any bugs that you find. If you are a programmer and would like to contribute something to the GNU project, please consider volunteering for one of these projects. If you are seriously contemplating work, please write to `gnu@prep.ai.mit.edu' to coordinate with other volunteers. * Menu: * Shortcomings:: Suggested projects for improvements. * Bugs:: Reporting bugs.  File: diff.info, Node: Shortcomings, Next: Bugs, Up: Projects Suggested Projects for Improving GNU `diff' and `patch' ======================================================= One should be able to use GNU `diff' to generate a patch from any pair of directory trees, and given the patch and a copy of one such tree, use `patch' to generate a faithful copy of the other. Unfortunately, some changes to directory trees cannot be expressed using current patch formats; also, `patch' does not handle some of the existing formats. These shortcomings motivate the following suggested projects. * Menu: * Changing Structure:: Handling changes to the directory structure. * Special Files:: Handling symbolic links, device special files, etc. * Unusual File Names:: Handling file names that contain unusual characters. * Arbitrary Limits:: Patching non-text files. * Large Files:: Handling files that do not fit in memory. * Ignoring Changes:: Ignoring certain changes while showing others.  File: diff.info, Node: Changing Structure, Next: Special Files, Up: Shortcomings Handling Changes to the Directory Structure ------------------------------------------- `diff' and `patch' do not handle some changes to directory structure. For example, suppose one directory tree contains a directory named `D' with some subsidiary files, and another contains a file with the same name `D'. `diff -r' does not output enough information for `patch' to transform the the directory subtree into the file. There should be a way to specify that a file has been deleted without having to include its entire contents in the patch file. There should also be a way to tell `patch' that a file was renamed, even if there is no way for `diff' to generate such information. These problems can be fixed by extending the `diff' output format to represent changes in directory structure, and extending `patch' to understand these extensions.  File: diff.info, Node: Special Files, Next: Unusual File Names, Prev: Changing Structure, Up: Shortcomings Files that are Neither Directories Nor Regular Files ---------------------------------------------------- Some files are neither directories nor regular files: they are unusual files like symbolic links, device special files, named pipes, and sockets. Currently, `diff' treats symbolic links like regular files; it treats other special files like regular files if they are specified at the top level, but simply reports their presence when comparing directories. This means that `patch' cannot represent changes to such files. For example, if you change which file a symbolic link points to, `diff' outputs the difference between the two files, instead of the change to the symbolic link. `diff' should optionally report changes to special files specially, and `patch' should be extended to understand these extensions.  File: diff.info, Node: Unusual File Names, Next: Arbitrary Limits, Prev: Special Files, Up: Shortcomings File Names that Contain Unusual Characters ------------------------------------------ When a file name contains an unusual character like a newline or white space, `diff -r' generates a patch that `patch' cannot parse. The problem is with format of `diff' output, not just with `patch', because with odd enough file names one can cause `diff' to generate a patch that is syntactically correct but patches the wrong files. The format of `diff' output should be extended to handle all possible file names.  File: diff.info, Node: Arbitrary Limits, Next: Large Files, Prev: Unusual File Names, Up: Shortcomings Arbitrary Limits ---------------- GNU `diff' can analyze files with arbitrarily long lines and files that end in incomplete lines. However, `patch' cannot patch such files. The `patch' internal limits on line lengths should be removed, and `patch' should be extended to parse `diff' reports of incomplete lines.  File: diff.info, Node: Large Files, Next: Ignoring Changes, Prev: Arbitrary Limits, Up: Shortcomings Handling Files that Do Not Fit in Memory ---------------------------------------- `diff' operates by reading both files into memory. This method fails if the files are too large, and `diff' should have a fallback. One way to do this is to scan the files sequentially to compute hash codes of the lines and put the lines in equivalence classes based only on hash code. Then compare the files normally. This does produce some false matches. Then scan the two files sequentially again, checking each match to see whether it is real. When a match is not real, mark both the "matching" lines as changed. Then build an edit script as usual. The output routines would have to be changed to scan the files sequentially looking for the text to print.  File: diff.info, Node: Ignoring Changes, Prev: Large Files, Up: Shortcomings Ignoring Certain Changes ------------------------ It would be nice to have a feature for specifying two strings, one in FROM-FILE and one in TO-FILE, which should be considered to match. Thus, if the two strings are `foo' and `bar', then if two lines differ only in that `foo' in file 1 corresponds to `bar' in file 2, the lines are treated as identical. It is not clear how general this feature can or should be, or what syntax should be used for it.  File: diff.info, Node: Bugs, Prev: Shortcomings, Up: Projects Reporting Bugs ============== If you think you have found a bug in GNU `cmp', `diff', `diff3', `sdiff', or `patch', please report it by electronic mail to `bug-gnu-utils@prep.ai.mit.edu'. Send as precise a description of the problem as you can, including sample input files that produce the bug, if applicable. Because Larry Wall has not released a new version of `patch' since mid 1988 and the GNU version of `patch' has been changed since then, please send bug reports for `patch' by electronic mail to both `bug-gnu-utils@prep.ai.mit.edu' and `lwall@netlabs.com'. diffutils-2.4/diff.info-4100666 74720 14 16724 5445723622 14233 0ustar eggertguestThis is Info file diff.info, produced by Makeinfo-1.55 from the input file ./diff.texi. This file documents the the GNU `diff', `diff3', `sdiff', and `cmp' commands for showing the differences between text files and the `patch' command for using their output to update files. Copyright (C) 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.  File: diff.info, Node: Concept Index, Prev: Projects, Up: Top Concept Index ************* * Menu: * cmp invocation: Invoking cmp. * cmp options: cmp Options. * diff3 hunks: diff3 Hunks. * diff3 invocation: Invoking diff3. * diff3 options: diff3 Options. * diff3 sample input: Sample diff3 Input. * diff invocation: Invoking diff. * diff options: diff Options. * diff sample input: Sample diff Input. * ed script output format: ed Scripts. * ifdef output format: If-then-else. * patch input format: patch Input. * patch invocation: Invoking patch. * patch messages and questions: patch Messages. * patch options: patch Options. * sdiff invocation: Invoking sdiff. * sdiff options: sdiff Options. * sdiff output format: sdiff Option Summary. * ! output format: Context. * +- output format: Unified Format. * <<<<<<< for marking conflicts: Marking Conflicts. * < output format: Normal. * aligning tabstops: Tabs. * alternate file names: Alternate Names. * backup file names: Backups. * binary file diff: Binary. * binary file patching: Arbitrary Limits. * blank and tab difference suppression: White Space. * blank line difference suppression: Blank Lines. * brief difference reports: Brief. * bug reports: Bugs. * C function headings: C Function Headings. * C if-then-else output format: If-then-else. * case difference suppression: Case Folding. * columnar output: Side by Side. * comparing three files: Comparing Three Files. * conflict: diff3 Merging. * conflict marking: Marking Conflicts. * context output format: Context. * diagnostics from patch: patch Messages. * diff merging: Interactive Merging. * directories and patch: patch Directories. * directory structure changes: Changing Structure. * empty files, removing: Empty Files. * file name alternates: Alternate Names. * file names with unusual characters: Unusual File Names. * format of diff3 output: Comparing Three Files. * format of diff output: Output Formats. * formats for if-then-else line groups: Line Group Formats. * forward ed script output format: Forward ed. * full lines: Incomplete Lines. * function headings, C: C Function Headings. * fuzz factor when patching: Inexact. * headings: Sections. * hunks: Hunks. * hunks for diff3: diff3 Hunks. * if-then-else output format: If-then-else. * imperfect patch application: Imperfect. * incomplete line merging: Merging Incomplete Lines. * incomplete lines: Incomplete Lines. * inexact patches: Inexact. * interactive merging: Interactive Merging. * introduction: Comparison. * invoking cmp: Invoking cmp. * invoking diff3: Invoking diff3. * invoking diff: Invoking diff. * invoking patch: Invoking patch. * invoking sdiff: Invoking sdiff. * large files: Large Files. * line formats: Line Formats. * line group formats: Line Group Formats. * merge commands: Merge Commands. * merged diff3 format: Bypassing ed. * merged output format: If-then-else. * merging from a common ancestor: diff3 Merging. * merging interactively: Merge Commands. * messages from patch: patch Messages. * multiple patches: Multiple Patches. * newline treatment by diff: Incomplete Lines. * normal output format: Normal. * options for cmp: cmp Options. * options for diff3: diff3 Options. * options for diff: diff Options. * options for patch: patch Options. * options for sdiff: sdiff Options. * output formats: Output Formats. * overlap: diff3 Merging. * overlapping change, selection of: Which Changes. * overview of diff and patch: Overview. * paginating diff output: Pagination. * patch making tips: Making Patches. * patching directories: patch Directories. * performance of diff: diff Performance. * projects for directories: Shortcomings. * RCS script output format: RCS. * regular expression matching headings: Specified Headings. * regular expression suppression: Specified Folding. * reject file names: Rejects. * removing empty files: Empty Files. * reporting bugs: Bugs. * reversed patches: Reversed Patches. * sample input for diff3: Sample diff3 Input. * sample input for diff: Sample diff Input. * script output formats: Scripts. * section headings: Sections. * side by side: Side by Side. * side by side format: Side by Side Format. * special files: Special Files. * specified headings: Specified Headings. * summarizing which files differ: Brief. * System V diff3 compatibility: Saving the Changed File. * tab and blank difference suppression: White Space. * tabstop alignment: Tabs. * text versus binary diff: Binary. * tips for patch making: Making Patches. * two-column output: Side by Side. * unified output format: Unified Format. * unmerged change: Which Changes. * white space in patches: Changed White Space. diffutils-2.4/texinfo.tex100644 74507 0 402647 5445707270 13637 0ustar mycroft%% TeX macros to handle texinfo files % Copyright (C) 1985, 86, 88, 90, 91, 92, 1993 Free Software Foundation, Inc. %This texinfo.tex file is free software; you can redistribute it and/or %modify it under the terms of the GNU General Public License as %published by the Free Software Foundation; either version 2, or (at %your option) any later version. %This texinfo.tex file is distributed in the hope that it will be %useful, but WITHOUT ANY WARRANTY; without even the implied warranty %of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU %General Public License for more details. %You should have received a copy of the GNU General Public License %along with this texinfo.tex file; see the file COPYING. If not, write %to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, %USA. %In other words, you are welcome to use, share and improve this program. %You are forbidden to forbid anyone else to use, share and improve %what you give them. Help stamp out software-hoarding! \def\texinfoversion{2.112} \message{Loading texinfo package [Version \texinfoversion]:} % Print the version number if in a .fmt file. \everyjob{\message{[Texinfo version \texinfoversion]}\message{}} % Save some parts of plain tex whose names we will redefine. \let\ptexlbrace=\{ \let\ptexrbrace=\} \let\ptexdots=\dots \let\ptexdot=\. \let\ptexstar=\* \let\ptexend=\end \let\ptexbullet=\bullet \let\ptexb=\b \let\ptexc=\c \let\ptexi=\i \let\ptext=\t \let\ptexl=\l \let\ptexL=\L \def\tie{\penalty 10000\ } % Save plain tex definition of ~. \message{Basics,} \chardef\other=12 % If this character appears in an error message or help string, it % starts a new line in the output. \newlinechar = `^^J % Ignore a token. % \def\gobble#1{} \hyphenation{ap-pen-dix} \hyphenation{mini-buf-fer mini-buf-fers} \hyphenation{eshell} % Margin to add to right of even pages, to left of odd pages. \newdimen \bindingoffset \bindingoffset=0pt \newdimen \normaloffset \normaloffset=\hoffset \newdimen\pagewidth \newdimen\pageheight \pagewidth=\hsize \pageheight=\vsize % Sometimes it is convenient to have everything in the transcript file % and nothing on the terminal. We don't just call \tracingall here, % since that produces some useless output on the terminal. % \def\gloggingall{\begingroup \globaldefs = 1 \loggingall \endgroup}% \def\loggingall{\tracingcommands2 \tracingstats2 \tracingpages1 \tracingoutput1 \tracinglostchars1 \tracingmacros2 \tracingparagraphs1 \tracingrestores1 \showboxbreadth\maxdimen\showboxdepth\maxdimen }% %---------------------Begin change----------------------- % %%%% For @cropmarks command. % Dimensions to add cropmarks at corners Added by P. A. MacKay, 12 Nov. 1986 % \newdimen\cornerlong \newdimen\cornerthick \newdimen \topandbottommargin \newdimen \outerhsize \newdimen \outervsize \cornerlong=1pc\cornerthick=.3pt % These set size of cropmarks \outerhsize=7in %\outervsize=9.5in % Alternative @smallbook page size is 9.25in \outervsize=9.25in \topandbottommargin=.75in % %---------------------End change----------------------- % \onepageout takes a vbox as an argument. Note that \pagecontents % does insertions itself, but you have to call it yourself. \chardef\PAGE=255 \output={\onepageout{\pagecontents\PAGE}} \def\onepageout#1{\hoffset=\normaloffset \ifodd\pageno \advance\hoffset by \bindingoffset \else \advance\hoffset by -\bindingoffset\fi {\escapechar=`\\\relax % makes sure backslash is used in output files. \shipout\vbox{{\let\hsize=\pagewidth \makeheadline} \pagebody{#1}% {\let\hsize=\pagewidth \makefootline}}}% \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi} %%%% For @cropmarks command %%%% % Here is a modification of the main output routine for Near East Publications % This provides right-angle cropmarks at all four corners. % The contents of the page are centerlined into the cropmarks, % and any desired binding offset is added as an \hskip on either % site of the centerlined box. (P. A. MacKay, 12 November, 1986) % \def\croppageout#1{\hoffset=0pt % make sure this doesn't mess things up {\escapechar=`\\\relax % makes sure backslash is used in output files. \shipout \vbox to \outervsize{\hsize=\outerhsize \vbox{\line{\ewtop\hfill\ewtop}} \nointerlineskip \line{\vbox{\moveleft\cornerthick\nstop} \hfill \vbox{\moveright\cornerthick\nstop}} \vskip \topandbottommargin \centerline{\ifodd\pageno\hskip\bindingoffset\fi \vbox{ {\let\hsize=\pagewidth \makeheadline} \pagebody{#1} {\let\hsize=\pagewidth \makefootline}} \ifodd\pageno\else\hskip\bindingoffset\fi} \vskip \topandbottommargin plus1fill minus1fill \boxmaxdepth\cornerthick \line{\vbox{\moveleft\cornerthick\nsbot} \hfill \vbox{\moveright\cornerthick\nsbot}} \nointerlineskip \vbox{\line{\ewbot\hfill\ewbot}} }} \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi} % % Do @cropmarks to get crop marks \def\cropmarks{\let\onepageout=\croppageout } \def\pagebody#1{\vbox to\pageheight{\boxmaxdepth=\maxdepth #1}} {\catcode`\@ =11 \gdef\pagecontents#1{\ifvoid\topins\else\unvbox\topins\fi \dimen@=\dp#1 \unvbox#1 \ifvoid\footins\else\vskip\skip\footins\footnoterule \unvbox\footins\fi \ifr@ggedbottom \kern-\dimen@ \vfil \fi} } % % Here are the rules for the cropmarks. Note that they are % offset so that the space between them is truly \outerhsize or \outervsize % (P. A. MacKay, 12 November, 1986) % \def\ewtop{\vrule height\cornerthick depth0pt width\cornerlong} \def\nstop{\vbox {\hrule height\cornerthick depth\cornerlong width\cornerthick}} \def\ewbot{\vrule height0pt depth\cornerthick width\cornerlong} \def\nsbot{\vbox {\hrule height\cornerlong depth\cornerthick width\cornerthick}} % Parse an argument, then pass it to #1. The argument is the rest of % the input line (except we remove a trailing comment). #1 should be a % macro which expects an ordinary undelimited TeX argument. % \def\parsearg#1{% \let\next = #1% \begingroup \obeylines \futurelet\temp\parseargx } % If the next token is an obeyed space (from an @example environment or % the like), remove it and recurse. Otherwise, we're done. \def\parseargx{% % \obeyedspace is defined far below, after the definition of \sepspaces. \ifx\obeyedspace\temp \expandafter\parseargdiscardspace \else \expandafter\parseargline \fi } % Remove a single space (as the delimiter token to the macro call). {\obeyspaces % \gdef\parseargdiscardspace {\futurelet\temp\parseargx}} {\obeylines % \gdef\parseargline#1^^M{% \endgroup % End of the group started in \parsearg. % % First remove any @c comment, then any @comment. % Result of each macro is put in \toks0. \argremovec #1\c\relax % \expandafter\argremovecomment \the\toks0 \comment\relax % % % Call the caller's macro, saved as \next in \parsearg. \expandafter\next\expandafter{\the\toks0}% }% } % Since all \c{,omment} does is throw away the argument, we can let TeX % do that for us. The \relax here is matched by the \relax in the call % in \parseargline; it could be more or less anything, its purpose is % just to delimit the argument to the \c. \def\argremovec#1\c#2\relax{\toks0 = {#1}} \def\argremovecomment#1\comment#2\relax{\toks0 = {#1}} % \argremovec{,omment} might leave us with trailing spaces, though; e.g., % @end itemize @c foo % will have two active spaces as part of the argument with the % `itemize'. Here we remove all active spaces from #1, and assign the % result to \toks0. % % This loses if there are any *other* active characters besides spaces % in the argument -- _ ^ +, for example -- since they get expanded. % Fortunately, Texinfo does not define any such commands. (If it ever % does, the catcode of the characters in questionwill have to be changed % here.) But this means we cannot call \removeactivespaces as part of % \argremovec{,omment}, since @c uses \parsearg, and thus the argument % that \parsearg gets might well have any character at all in it. % \def\removeactivespaces#1{% \begingroup \ignoreactivespaces \edef\temp{#1}% \global\toks0 = \expandafter{\temp}% \endgroup } % Change the active space to expand to nothing. % \begingroup \obeyspaces \gdef\ignoreactivespaces{\obeyspaces\let =\empty} \endgroup \def\flushcr{\ifx\par\lisppar \def\next##1{}\else \let\next=\relax \fi \next} %% These are used to keep @begin/@end levels from running away %% Call \inENV within environments (after a \begingroup) \newif\ifENV \ENVfalse \def\inENV{\ifENV\relax\else\ENVtrue\fi} \def\ENVcheck{% \ifENV\errmessage{Still within an environment. Type Return to continue.} \endgroup\fi} % This is not perfect, but it should reduce lossage % @begin foo is the same as @foo, for now. \newhelp\EMsimple{Type to continue.} \outer\def\begin{\parsearg\beginxxx} \def\beginxxx #1{% \expandafter\ifx\csname #1\endcsname\relax {\errhelp=\EMsimple \errmessage{Undefined command @begin #1}}\else \csname #1\endcsname\fi} % @end foo executes the definition of \Efoo. % \def\end{\parsearg\endxxx} \def\endxxx #1{% \removeactivespaces{#1}% \edef\endthing{\the\toks0}% % \expandafter\ifx\csname E\endthing\endcsname\relax \expandafter\ifx\csname \endthing\endcsname\relax % There's no \foo, i.e., no ``environment'' foo. \errhelp = \EMsimple \errmessage{Undefined command `@end \endthing'}% \else \unmatchedenderror\endthing \fi \else % Everything's ok; the right environment has been started. \csname E\endthing\endcsname \fi } % There is an environment #1, but it hasn't been started. Give an error. % \def\unmatchedenderror#1{% \errhelp = \EMsimple \errmessage{This `@end #1' doesn't have a matching `@#1'}% } % Define the control sequence \E#1 to give an unmatched @end error. % \def\defineunmatchedend#1{% \expandafter\def\csname E#1\endcsname{\unmatchedenderror{#1}}% } % Single-spacing is done by various environments (specifically, in % \nonfillstart and \quotations). \newskip\singlespaceskip \singlespaceskip = \baselineskip \def\singlespace{% % Why was this kern here? It messes up equalizing space above and below % environments. --karl, 6may93 %{\advance \baselineskip by -\singlespaceskip %\kern \baselineskip}% \baselineskip=\singlespaceskip } %% Simple single-character @ commands % @@ prints an @ % Kludge this until the fonts are right (grr). \def\@{{\tt \char '100}} % This is turned off because it was never documented % and you can use @w{...} around a quote to suppress ligatures. %% Define @` and @' to be the same as ` and ' %% but suppressing ligatures. %\def\`{{`}} %\def\'{{'}} % Used to generate quoted braces. \def\mylbrace {{\tt \char '173}} \def\myrbrace {{\tt \char '175}} \let\{=\mylbrace \let\}=\myrbrace % @: forces normal size whitespace following. \def\:{\spacefactor=1000 } % @* forces a line break. \def\*{\hfil\break\hbox{}\ignorespaces} % @. is an end-of-sentence period. \def\.{.\spacefactor=3000 } % @w prevents a word break. Without the \leavevmode, @w at the % beginning of a paragraph, when TeX is still in vertical mode, would % produce a whole line of output instead of starting the paragraph. \def\w#1{\leavevmode\hbox{#1}} % @group ... @end group forces ... to be all on one page, by enclosing % it in a TeX vbox. We use \vtop instead of \vbox to construct the box % to keep its height that of a normal line. According to the rules for % \topskip (p.114 of the TeXbook), the glue inserted is % max (\topskip - \ht (first item), 0). If that height is large, % therefore, no glue is inserted, and the space between the headline and % the text is small, which looks bad. % \def\group{\begingroup \ifnum\catcode13=\active \else \errhelp = \groupinvalidhelp \errmessage{@group invalid in context where filling is enabled}% \fi % % The \vtop we start below produces a box with normal height and large % depth; thus, TeX puts \baselineskip glue before it, and (when the % next line of text is done) \lineskip glue after it. (See p.82 of % the TeXbook.) Thus, space below is not quite equal to space % above. But it's pretty close. \def\Egroup{% \egroup % End the \vtop. \endgroup % End the \group. }% % \vtop\bgroup % We have to put a strut on the last line in case the @group is in % the midst of an example, rather than completely enclosing it. % Otherwise, the interline space between the last line of the group % and the first line afterwards is too small. But we can't put the % strut in \Egroup, since there it would be on a line by itself. % Hence this just inserts a strut at the beginning of each line. \everypar = {\strut}% % % Since we have a strut on every line, we don't need any of TeX's % normal interline spacing. \offinterlineskip % % OK, but now we have to do something about blank % lines in the input in @example-like environments, which normally % just turn into \lisppar, which will insert no space now that we've % turned off the interline space. Simplest is to make them be an % empty paragraph. \ifx\par\lisppar \edef\par{\leavevmode \par}% % % Reset ^^M's definition to new definition of \par. \obeylines \fi % % We do @comment here in case we are called inside an environment, % such as @example, where each end-of-line in the input causes an % end-of-line in the output. We don't want the end-of-line after % the `@group' to put extra space in the output. Since @group % should appear on a line by itself (according to the Texinfo % manual), we don't worry about eating any user text. \comment } % % TeX puts in an \escapechar (i.e., `@') at the beginning of the help % message, so this ends up printing `@group can only ...'. % \newhelp\groupinvalidhelp{% group can only be used in environments such as @example,^^J% where each line of input produces a line of output.} % @need space-in-mils % forces a page break if there is not space-in-mils remaining. \newdimen\mil \mil=0.001in \def\need{\parsearg\needx} % Old definition--didn't work. %\def\needx #1{\par % %% This method tries to make TeX break the page naturally %% if the depth of the box does not fit. %{\baselineskip=0pt% %\vtop to #1\mil{\vfil}\kern -#1\mil\penalty 10000 %\prevdepth=-1000pt %}} \def\needx#1{% % Go into vertical mode, so we don't make a big box in the middle of a % paragraph. \par % % Don't add any leading before our big empty box, but allow a page % break, since the best break might be right here. \allowbreak \nointerlineskip \vtop to #1\mil{\vfil}% % % TeX does not even consider page breaks if a penalty added to the % main vertical list is 10000 or more. But in order to see if the % empty box we just added fits on the page, we must make it consider % page breaks. On the other hand, we don't want to actually break the % page after the empty box. So we use a penalty of 9999. % % There is an extremely small chance that TeX will actually break the % page at this \penalty, if there are no other feasible breakpoints in % sight. (If the user is using lots of big @group commands, which % almost-but-not-quite fill up a page, TeX will have a hard time doing % good page breaking, for example.) However, I could not construct an % example where a page broke at this \penalty; if it happens in a real % document, then we can reconsider our strategy. \penalty9999 % % Back up by the size of the box, whether we did a page break or not. \kern -#1\mil % % Do not allow a page break right after this kern. \nobreak } % @br forces paragraph break \let\br = \par % @dots{} output some dots \def\dots{$\ldots$} % @page forces the start of a new page \def\page{\par\vfill\supereject} % @exdent text.... % outputs text on separate line in roman font, starting at standard page margin % This records the amount of indent in the innermost environment. % That's how much \exdent should take out. \newskip\exdentamount % This defn is used inside fill environments such as @defun. \def\exdent{\parsearg\exdentyyy} \def\exdentyyy #1{{\hfil\break\hbox{\kern -\exdentamount{\rm#1}}\hfil\break}} % This defn is used inside nofill environments such as @example. \def\nofillexdent{\parsearg\nofillexdentyyy} \def\nofillexdentyyy #1{{\advance \leftskip by -\exdentamount \leftline{\hskip\leftskip{\rm#1}}}} %\hbox{{\rm#1}}\hfil\break}} % @include file insert text of that file as input. \def\include{\parsearg\includezzz} %Use \input\thisfile to avoid blank after \input, which may be an active %char (in which case the blank would become the \input argument). %The grouping keeps the value of \thisfile correct even when @include %is nested. \def\includezzz #1{\begingroup \def\thisfile{#1}\input\thisfile \endgroup} \def\thisfile{} % @center line outputs that line, centered \def\center{\parsearg\centerzzz} \def\centerzzz #1{{\advance\hsize by -\leftskip \advance\hsize by -\rightskip \centerline{#1}}} % @sp n outputs n lines of vertical space \def\sp{\parsearg\spxxx} \def\spxxx #1{\par \vskip #1\baselineskip} % @comment ...line which is ignored... % @c is the same as @comment % @ignore ... @end ignore is another way to write a comment \def\comment{\catcode 64=\other \catcode 123=\other \catcode 125=\other% \parsearg \commentxxx} \def\commentxxx #1{\catcode 64=0 \catcode 123=1 \catcode 125=2 } \let\c=\comment % Prevent errors for section commands. % Used in @ignore and in failing conditionals. \def\ignoresections{% \let\chapter=\relax \let\unnumbered=\relax \let\top=\relax \let\unnumberedsec=\relax \let\unnumberedsection=\relax \let\unnumberedsubsec=\relax \let\unnumberedsubsection=\relax \let\unnumberedsubsubsec=\relax \let\unnumberedsubsubsection=\relax \let\section=\relax \let\subsec=\relax \let\subsubsec=\relax \let\subsection=\relax \let\subsubsection=\relax \let\appendix=\relax \let\appendixsec=\relax \let\appendixsection=\relax \let\appendixsubsec=\relax \let\appendixsubsection=\relax \let\appendixsubsubsec=\relax \let\appendixsubsubsection=\relax \let\contents=\relax \let\smallbook=\relax \let\titlepage=\relax } % Used in nested conditionals, where we have to parse the Texinfo source % and so want to turn off most commands, in case they are used % incorrectly. % \def\ignoremorecommands{% \let\defcv = \relax \let\deffn = \relax \let\deffnx = \relax \let\defindex = \relax \let\defivar = \relax \let\defmac = \relax \let\defmethod = \relax \let\defop = \relax \let\defopt = \relax \let\defspec = \relax \let\deftp = \relax \let\deftypefn = \relax \let\deftypefun = \relax \let\deftypevar = \relax \let\deftypevr = \relax \let\defun = \relax \let\defvar = \relax \let\defvr = \relax \let\ref = \relax \let\xref = \relax \let\printindex = \relax \let\pxref = \relax \let\settitle = \relax \let\include = \relax \let\lowersections = \relax \let\down = \relax \let\raisesections = \relax \let\up = \relax \let\set = \relax \let\clear = \relax } % Ignore @ignore ... @end ignore. % \def\ignore{\doignore{ignore}} % Also ignore @ifinfo, @menu, and @direntry text. % \def\ifinfo{\doignore{ifinfo}} \def\menu{\doignore{menu}} \def\direntry{\doignore{direntry}} % Ignore text until a line `@end #1'. % \def\doignore#1{\begingroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define a command to swallow text until we reach `@end #1'. \long\def\doignoretext##1\end #1{\enddoignore}% % % Make sure that spaces turn into tokens that match what \doignoretext wants. \catcode32 = 10 % % And now expand that command. \doignoretext } % What we do to finish off ignored text. % \def\enddoignore{\endgroup\ignorespaces}% \newif\ifwarnedobs\warnedobsfalse \def\obstexwarn{% \ifwarnedobs\relax\else % We need to warn folks that they may have trouble with TeX 3.0. % This uses \immediate\write16 rather than \message to get newlines. \immediate\write16{} \immediate\write16{***WARNING*** for users of Unix TeX 3.0!} \immediate\write16{This manual trips a bug in TeX version 3.0 (tex hangs).} \immediate\write16{If you are running another version of TeX, relax.} \immediate\write16{If you are running Unix TeX 3.0, kill this TeX process.} \immediate\write16{ Then upgrade your TeX installation if you can.} \immediate\write16{If you are stuck with version 3.0, run the} \immediate\write16{ script ``tex3patch'' from the Texinfo distribution} \immediate\write16{ to use a workaround.} \immediate\write16{} \warnedobstrue \fi } % **In TeX 3.0, setting text in \nullfont hangs tex. For a % workaround (which requires the file ``dummy.tfm'' to be installed), % uncomment the following line: %%%%%\font\nullfont=dummy\let\obstexwarn=\relax % Ignore text, except that we keep track of conditional commands for % purposes of nesting, up to an `@end #1' command. % \def\nestedignore#1{% \obstexwarn % We must actually expand the ignored text to look for the @end % command, so that nested ignore constructs work. Thus, we put the % text into a \vbox and then do nothing with the result. To minimize % the change of memory overflow, we follow the approach outlined on % page 401 of the TeXbook: make the current font be a dummy font. % \setbox0 = \vbox\bgroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define `@end #1' to end the box, which will in turn undefine the % @end command again. \expandafter\def\csname E#1\endcsname{\egroup\ignorespaces}% % % We are going to be parsing Texinfo commands. Most cause no % trouble when they are used incorrectly, but some commands do % complicated argument parsing or otherwise get confused, so we % undefine them. % % We can't do anything about stray @-signs, unfortunately; % they'll produce `undefined control sequence' errors. \ignoremorecommands % % Set the current font to be \nullfont, a TeX primitive, and define % all the font commands to also use \nullfont. We don't use % dummy.tfm, as suggested in the TeXbook, because not all sites % might have that installed. Therefore, math mode will still % produce output, but that should be an extremely small amount of % stuff compared to the main input. % \nullfont \let\tenrm = \nullfont \let\tenit = \nullfont \let\tensl = \nullfont \let\tenbf = \nullfont \let\tentt = \nullfont \let\smallcaps = \nullfont \let\tensf = \nullfont % Similarly for index fonts (mostly for their use in % smallexample) \let\indrm = \nullfont \let\indit = \nullfont \let\indsl = \nullfont \let\indbf = \nullfont \let\indtt = \nullfont \let\indsc = \nullfont \let\indsf = \nullfont % % Don't complain when characters are missing from the fonts. \tracinglostchars = 0 % % Don't bother to do space factor calculations. \frenchspacing % % Don't report underfull hboxes. \hbadness = 10000 % % Do minimal line-breaking. \pretolerance = 10000 % % Do not execute instructions in @tex \def\tex{\doignore{tex}} } % @set VAR sets the variable VAR to an empty value. % @set VAR REST-OF-LINE sets VAR to the value REST-OF-LINE. % % Since we want to separate VAR from REST-OF-LINE (which might be % empty), we can't just use \parsearg; we have to insert a space of our % own to delimit the rest of the line, and then take it out again if we % didn't need it. % \def\set{\parsearg\setxxx} \def\setxxx#1{\setyyy#1 \endsetyyy} \def\setyyy#1 #2\endsetyyy{% \def\temp{#2}% \ifx\temp\empty \global\expandafter\let\csname SET#1\endcsname = \empty \else \setzzz{#1}#2\endsetzzz % Remove the trailing space \setxxx inserted. \fi } \def\setzzz#1#2 \endsetzzz{\expandafter\xdef\csname SET#1\endcsname{#2}} % @clear VAR clears (i.e., unsets) the variable VAR. % \def\clear{\parsearg\clearxxx} \def\clearxxx#1{\global\expandafter\let\csname SET#1\endcsname=\relax} % @value{foo} gets the text saved in variable foo. % \def\value#1{\expandafter \ifx\csname SET#1\endcsname\relax {\{No value for ``#1''\}} \else \csname SET#1\endcsname \fi} % @ifset VAR ... @end ifset reads the `...' iff VAR has been defined % with @set. % \def\ifset{\parsearg\ifsetxxx} \def\ifsetxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifsetfail \else \expandafter\ifsetsucceed \fi } \def\ifsetsucceed{\conditionalsucceed{ifset}} \def\ifsetfail{\nestedignore{ifset}} \defineunmatchedend{ifset} % @ifclear VAR ... @end ifclear reads the `...' iff VAR has never been % defined with @set, or has been undefined with @clear. % \def\ifclear{\parsearg\ifclearxxx} \def\ifclearxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifclearsucceed \else \expandafter\ifclearfail \fi } \def\ifclearsucceed{\conditionalsucceed{ifclear}} \def\ifclearfail{\nestedignore{ifclear}} \defineunmatchedend{ifclear} % @iftex always succeeds; we read the text following, through @end % iftex). But `@end iftex' should be valid only after an @iftex. % \def\iftex{\conditionalsucceed{iftex}} \defineunmatchedend{iftex} % We can't just want to start a group at @iftex (for example) and end it % at @end iftex, since then @set commands inside the conditional have no % effect (they'd get reverted at the end of the group). So we must % define \Eiftex to redefine itself to be its previous value. (We can't % just define it to fail again with an ``unmatched end'' error, since % the @ifset might be nested.) % \def\conditionalsucceed#1{% \edef\temp{% % Remember the current value of \E#1. \let\nece{prevE#1} = \nece{E#1}% % % At the `@end #1', redefine \E#1 to be its previous value. \def\nece{E#1}{\let\nece{E#1} = \nece{prevE#1}}% }% \temp } % We need to expand lots of \csname's, but we don't want to expand the % control sequences after we've constructed them. % \def\nece#1{\expandafter\noexpand\csname#1\endcsname} % @asis just yields its argument. Used with @table, for example. % \def\asis#1{#1} % @math means output in math mode. % We don't use $'s directly in the definition of \math because control % sequences like \math are expanded when the toc file is written. Then, % we read the toc file back, the $'s will be normal characters (as they % should be, according to the definition of Texinfo). So we must use a % control sequence to switch into and out of math mode. % % This isn't quite enough for @math to work properly in indices, but it % seems unlikely it will ever be needed there. % \let\implicitmath = $ \def\math#1{\implicitmath #1\implicitmath} % @bullet and @minus need the same treatment as @math, just above. \def\bullet{\implicitmath\ptexbullet\implicitmath} \def\minus{\implicitmath-\implicitmath} \def\node{\ENVcheck\parsearg\nodezzz} \def\nodezzz#1{\nodexxx [#1,]} \def\nodexxx[#1,#2]{\gdef\lastnode{#1}} \let\nwnode=\node \let\lastnode=\relax \def\donoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\setref{\lastnode}\fi \let\lastnode=\relax} \def\unnumbnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\unnumbsetref{\lastnode}\fi \let\lastnode=\relax} \def\appendixnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\appendixsetref{\lastnode}\fi \let\lastnode=\relax} \let\refill=\relax % @setfilename is done at the beginning of every texinfo file. % So open here the files we need to have open while reading the input. % This makes it possible to make a .fmt file for texinfo. \def\setfilename{% \readauxfile \opencontents \openindices \fixbackslash % Turn off hack to swallow `\input texinfo'. \global\let\setfilename=\comment % Ignore extra @setfilename cmds. \comment % Ignore the actual filename. } \outer\def\bye{\pagealignmacro\tracingstats=1\ptexend} \def\inforef #1{\inforefzzz #1,,,,**} \def\inforefzzz #1,#2,#3,#4**{See Info file \file{\ignorespaces #3{}}, node \samp{\ignorespaces#1{}}} \message{fonts,} % Font-change commands. % Texinfo supports the sans serif font style, which plain TeX does not. % So we set up a \sf analogous to plain's \rm, etc. \newfam\sffam \def\sf{\fam=\sffam \tensf} \let\li = \sf % Sometimes we call it \li, not \sf. %% Try out Computer Modern fonts at \magstephalf \let\mainmagstep=\magstephalf \ifx\bigger\relax \let\mainmagstep=\magstep1 \font\textrm=cmr12 \font\texttt=cmtt12 \else \font\textrm=cmr10 scaled \mainmagstep \font\texttt=cmtt10 scaled \mainmagstep \fi % Instead of cmb10, you many want to use cmbx10. % cmbx10 is a prettier font on its own, but cmb10 % looks better when embedded in a line with cmr10. \font\textbf=cmb10 scaled \mainmagstep \font\textit=cmti10 scaled \mainmagstep \font\textsl=cmsl10 scaled \mainmagstep \font\textsf=cmss10 scaled \mainmagstep \font\textsc=cmcsc10 scaled \mainmagstep \font\texti=cmmi10 scaled \mainmagstep \font\textsy=cmsy10 scaled \mainmagstep % A few fonts for @defun, etc. \font\defbf=cmbx10 scaled \magstep1 %was 1314 \font\deftt=cmtt10 scaled \magstep1 \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf} % Fonts for indices and small examples. % We actually use the slanted font rather than the italic, % because texinfo normally uses the slanted fonts for that. % Do not make many font distinctions in general in the index, since they % aren't very useful. \font\ninett=cmtt9 \font\indrm=cmr9 \font\indit=cmsl9 \let\indsl=\indit \let\indtt=\ninett \let\indsf=\indrm \let\indbf=\indrm \let\indsc=\indrm \font\indi=cmmi9 \font\indsy=cmsy9 % Fonts for headings \font\chaprm=cmbx12 scaled \magstep2 \font\chapit=cmti12 scaled \magstep2 \font\chapsl=cmsl12 scaled \magstep2 \font\chaptt=cmtt12 scaled \magstep2 \font\chapsf=cmss12 scaled \magstep2 \let\chapbf=\chaprm \font\chapsc=cmcsc10 scaled\magstep3 \font\chapi=cmmi12 scaled \magstep2 \font\chapsy=cmsy10 scaled \magstep3 \font\secrm=cmbx12 scaled \magstep1 \font\secit=cmti12 scaled \magstep1 \font\secsl=cmsl12 scaled \magstep1 \font\sectt=cmtt12 scaled \magstep1 \font\secsf=cmss12 scaled \magstep1 \font\secbf=cmbx12 scaled \magstep1 \font\secsc=cmcsc10 scaled\magstep2 \font\seci=cmmi12 scaled \magstep1 \font\secsy=cmsy10 scaled \magstep2 % \font\ssecrm=cmbx10 scaled \magstep1 % This size an font looked bad. % \font\ssecit=cmti10 scaled \magstep1 % The letters were too crowded. % \font\ssecsl=cmsl10 scaled \magstep1 % \font\ssectt=cmtt10 scaled \magstep1 % \font\ssecsf=cmss10 scaled \magstep1 %\font\ssecrm=cmb10 scaled 1315 % Note the use of cmb rather than cmbx. %\font\ssecit=cmti10 scaled 1315 % Also, the size is a little larger than %\font\ssecsl=cmsl10 scaled 1315 % being scaled magstep1. %\font\ssectt=cmtt10 scaled 1315 %\font\ssecsf=cmss10 scaled 1315 %\let\ssecbf=\ssecrm \font\ssecrm=cmbx12 scaled \magstephalf \font\ssecit=cmti12 scaled \magstephalf \font\ssecsl=cmsl12 scaled \magstephalf \font\ssectt=cmtt12 scaled \magstephalf \font\ssecsf=cmss12 scaled \magstephalf \font\ssecbf=cmbx12 scaled \magstephalf \font\ssecsc=cmcsc10 scaled \magstep1 \font\sseci=cmmi12 scaled \magstephalf \font\ssecsy=cmsy10 scaled \magstep1 % The smallcaps and symbol fonts should actually be scaled \magstep1.5, % but that is not a standard magnification. % Fonts for title page: \font\titlerm = cmbx12 scaled \magstep3 \let\authorrm = \secrm % In order for the font changes to affect most math symbols and letters, % we have to define the \textfont of the standard families. Since % texinfo doesn't allow for producing subscripts and superscripts, we % don't bother to reset \scriptfont and \scriptscriptfont (which would % also require loading a lot more fonts). % \def\resetmathfonts{% \textfont0 = \tenrm \textfont1 = \teni \textfont2 = \tensy \textfont\itfam = \tenit \textfont\slfam = \tensl \textfont\bffam = \tenbf \textfont\ttfam = \tentt \textfont\sffam = \tensf } % The font-changing commands redefine the meanings of \tenSTYLE, instead % of just \STYLE. We do this so that font changes will continue to work % in math mode, where it is the current \fam that is relevant in most % cases, not the current. Plain TeX does, for example, % \def\bf{\fam=\bffam \tenbf} By redefining \tenbf, we obviate the need % to redefine \bf itself. \def\textfonts{% \let\tenrm=\textrm \let\tenit=\textit \let\tensl=\textsl \let\tenbf=\textbf \let\tentt=\texttt \let\smallcaps=\textsc \let\tensf=\textsf \let\teni=\texti \let\tensy=\textsy \resetmathfonts} \def\chapfonts{% \let\tenrm=\chaprm \let\tenit=\chapit \let\tensl=\chapsl \let\tenbf=\chapbf \let\tentt=\chaptt \let\smallcaps=\chapsc \let\tensf=\chapsf \let\teni=\chapi \let\tensy=\chapsy \resetmathfonts} \def\secfonts{% \let\tenrm=\secrm \let\tenit=\secit \let\tensl=\secsl \let\tenbf=\secbf \let\tentt=\sectt \let\smallcaps=\secsc \let\tensf=\secsf \let\teni=\seci \let\tensy=\secsy \resetmathfonts} \def\subsecfonts{% \let\tenrm=\ssecrm \let\tenit=\ssecit \let\tensl=\ssecsl \let\tenbf=\ssecbf \let\tentt=\ssectt \let\smallcaps=\ssecsc \let\tensf=\ssecsf \let\teni=\sseci \let\tensy=\ssecsy \resetmathfonts} \def\indexfonts{% \let\tenrm=\indrm \let\tenit=\indit \let\tensl=\indsl \let\tenbf=\indbf \let\tentt=\indtt \let\smallcaps=\indsc \let\tensf=\indsf \let\teni=\indi \let\tensy=\indsy \resetmathfonts} % Set up the default fonts, so we can use them for creating boxes. % \textfonts % Count depth in font-changes, for error checks \newcount\fontdepth \fontdepth=0 % Fonts for short table of contents. \font\shortcontrm=cmr12 \font\shortcontbf=cmbx12 \font\shortcontsl=cmsl12 %% Add scribe-like font environments, plus @l for inline lisp (usually sans %% serif) and @ii for TeX italic % \smartitalic{ARG} outputs arg in italics, followed by an italic correction % unless the following character is such as not to need one. \def\smartitalicx{\ifx\next,\else\ifx\next-\else\ifx\next.\else\/\fi\fi\fi} \def\smartitalic#1{{\sl #1}\futurelet\next\smartitalicx} \let\i=\smartitalic \let\var=\smartitalic \let\dfn=\smartitalic \let\emph=\smartitalic \let\cite=\smartitalic \def\b#1{{\bf #1}} \let\strong=\b % We can't just use \exhyphenpenalty, because that only has effect at % the end of a paragraph. Restore normal hyphenation at the end of the % group within which \nohyphenation is presumably called. % \def\nohyphenation{\hyphenchar\font = -1 \aftergroup\restorehyphenation} \def\restorehyphenation{\hyphenchar\font = `- } \def\t#1{% {\tt \nohyphenation \rawbackslash \frenchspacing #1}% \null } \let\ttfont = \t %\def\samp #1{`{\tt \rawbackslash \frenchspacing #1}'\null} \def\samp #1{`\tclose{#1}'\null} \def\key #1{{\tt \nohyphenation \uppercase{#1}}\null} \def\ctrl #1{{\tt \rawbackslash \hat}#1} \let\file=\samp % @code is a modification of @t, % which makes spaces the same size as normal in the surrounding text. \def\tclose#1{% {% % Change normal interword space to be same as for the current font. \spaceskip = \fontdimen2\font % % Switch to typewriter. \tt % % But `\ ' produces the large typewriter interword space. \def\ {{\spaceskip = 0pt{} }}% % % Turn off hyphenation. \nohyphenation % \rawbackslash \frenchspacing #1% }% \null } % We *must* turn on hyphenation at `-' and `_' in \code. % Otherwise, it is too hard to avoid overful hboxes % in the Emacs manual, the Library manual, etc. % Unfortunately, TeX uses one parameter (\hyphenchar) to control % both hyphenation at - and hyphenation within words. % We must therefore turn them both off (\tclose does that) % and arrange explicitly to hyphenate an a dash. % -- rms. { \catcode `\-=\active \catcode `\_=\active \global\def\code{\begingroup \catcode `\-=\active \let-\codedash \let_\codeunder \codex} } \def\codedash{-\discretionary{}{}{}} \def\codeunder{\normalunderscore\discretionary{}{}{}} \def\codex #1{\tclose{#1}\endgroup} %\let\exp=\tclose %Was temporary % @kbd is like @code, except that if the argument is just one @key command, % then @kbd has no effect. \def\xkey{\key} \def\kbdfoo#1#2#3\par{\def\one{#1}\def\three{#3}\def\threex{??}% \ifx\one\xkey\ifx\threex\three \key{#2}% \else\tclose{\look}\fi \else\tclose{\look}\fi} % Typeset a dimension, e.g., `in' or `pt'. The only reason for the % argument is to make the input look right: @dmn{pt} instead of % @dmn{}pt. % \def\dmn#1{\thinspace #1} \def\kbd#1{\def\look{#1}\expandafter\kbdfoo\look??\par} \def\l#1{{\li #1}\null} % \def\r#1{{\rm #1}} % roman font % Use of \lowercase was suggested. \def\sc#1{{\smallcaps#1}} % smallcaps font \def\ii#1{{\it #1}} % italic font \message{page headings,} \newskip\titlepagetopglue \titlepagetopglue = 1.5in \newskip\titlepagebottomglue \titlepagebottomglue = 2pc % First the title page. Must do @settitle before @titlepage. \def\titlefont#1{{\titlerm #1}} \newif\ifseenauthor \newif\iffinishedtitlepage \def\shorttitlepage{\parsearg\shorttitlepagezzz} \def\shorttitlepagezzz #1{\begingroup\hbox{}\vskip 1.5in \chaprm \centerline{#1}% \endgroup\page\hbox{}\page} \def\titlepage{\begingroup \parindent=0pt \textfonts \let\subtitlerm=\tenrm % I deinstalled the following change because \cmr12 is undefined. % This change was not in the ChangeLog anyway. --rms. % \let\subtitlerm=\cmr12 \def\subtitlefont{\subtitlerm \normalbaselineskip = 13pt \normalbaselines}% % \def\authorfont{\authorrm \normalbaselineskip = 16pt \normalbaselines}% % % Leave some space at the very top of the page. \vglue\titlepagetopglue % % Now you can print the title using @title. \def\title{\parsearg\titlezzz}% \def\titlezzz##1{\leftline{\titlefont{##1}} % print a rule at the page bottom also. \finishedtitlepagefalse \vskip4pt \hrule height 4pt width \hsize \vskip4pt}% % No rule at page bottom unless we print one at the top with @title. \finishedtitlepagetrue % % Now you can put text using @subtitle. \def\subtitle{\parsearg\subtitlezzz}% \def\subtitlezzz##1{{\subtitlefont \rightline{##1}}}% % % @author should come last, but may come many times. \def\author{\parsearg\authorzzz}% \def\authorzzz##1{\ifseenauthor\else\vskip 0pt plus 1filll\seenauthortrue\fi {\authorfont \leftline{##1}}}% % % Most title ``pages'' are actually two pages long, with space % at the top of the second. We don't want the ragged left on the second. \let\oldpage = \page \def\page{% \iffinishedtitlepage\else \finishtitlepage \fi \oldpage \let\page = \oldpage \hbox{}}% % \def\page{\oldpage \hbox{}} } \def\Etitlepage{% \iffinishedtitlepage\else \finishtitlepage \fi % It is important to do the page break before ending the group, % because the headline and footline are only empty inside the group. % If we use the new definition of \page, we always get a blank page % after the title page, which we certainly don't want. \oldpage \endgroup \HEADINGSon } \def\finishtitlepage{% \vskip4pt \hrule height 2pt width \hsize \vskip\titlepagebottomglue \finishedtitlepagetrue } %%% Set up page headings and footings. \let\thispage=\folio \newtoks \evenheadline % Token sequence for heading line of even pages \newtoks \oddheadline % Token sequence for heading line of odd pages \newtoks \evenfootline % Token sequence for footing line of even pages \newtoks \oddfootline % Token sequence for footing line of odd pages % Now make Tex use those variables \headline={{\textfonts\rm \ifodd\pageno \the\oddheadline \else \the\evenheadline \fi}} \footline={{\textfonts\rm \ifodd\pageno \the\oddfootline \else \the\evenfootline \fi}\HEADINGShook} \let\HEADINGShook=\relax % Commands to set those variables. % For example, this is what @headings on does % @evenheading @thistitle|@thispage|@thischapter % @oddheading @thischapter|@thispage|@thistitle % @evenfooting @thisfile|| % @oddfooting ||@thisfile \def\evenheading{\parsearg\evenheadingxxx} \def\oddheading{\parsearg\oddheadingxxx} \def\everyheading{\parsearg\everyheadingxxx} \def\evenfooting{\parsearg\evenfootingxxx} \def\oddfooting{\parsearg\oddfootingxxx} \def\everyfooting{\parsearg\everyfootingxxx} {\catcode`\@=0 % \gdef\evenheadingxxx #1{\evenheadingyyy #1@|@|@|@|\finish} \gdef\evenheadingyyy #1@|#2@|#3@|#4\finish{% \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddheadingxxx #1{\oddheadingyyy #1@|@|@|@|\finish} \gdef\oddheadingyyy #1@|#2@|#3@|#4\finish{% \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\everyheadingxxx #1{\everyheadingyyy #1@|@|@|@|\finish} \gdef\everyheadingyyy #1@|#2@|#3@|#4\finish{% \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}} \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\evenfootingxxx #1{\evenfootingyyy #1@|@|@|@|\finish} \gdef\evenfootingyyy #1@|#2@|#3@|#4\finish{% \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddfootingxxx #1{\oddfootingyyy #1@|@|@|@|\finish} \gdef\oddfootingyyy #1@|#2@|#3@|#4\finish{% \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\everyfootingxxx #1{\everyfootingyyy #1@|@|@|@|\finish} \gdef\everyfootingyyy #1@|#2@|#3@|#4\finish{% \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}} \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} % }% unbind the catcode of @. % @headings double turns headings on for double-sided printing. % @headings single turns headings on for single-sided printing. % @headings off turns them off. % @headings on same as @headings double, retained for compatibility. % @headings after turns on double-sided headings after this page. % @headings doubleafter turns on double-sided headings after this page. % @headings singleafter turns on single-sided headings after this page. % By default, they are off. \def\headings #1 {\csname HEADINGS#1\endcsname} \def\HEADINGSoff{ \global\evenheadline={\hfil} \global\evenfootline={\hfil} \global\oddheadline={\hfil} \global\oddfootline={\hfil}} \HEADINGSoff % When we turn headings on, set the page number to 1. % For double-sided printing, put current file name in lower left corner, % chapter name on inside top of right hand pages, document % title on inside top of left hand pages, and page numbers on outside top % edge of all pages. \def\HEADINGSdouble{ %\pagealignmacro \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} } % For single-sided printing, chapter title goes across top left of page, % page number on top right. \def\HEADINGSsingle{ %\pagealignmacro \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} } \def\HEADINGSon{\HEADINGSdouble} \def\HEADINGSafter{\let\HEADINGShook=\HEADINGSdoublex} \let\HEADINGSdoubleafter=\HEADINGSafter \def\HEADINGSdoublex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} } \def\HEADINGSsingleafter{\let\HEADINGShook=\HEADINGSsinglex} \def\HEADINGSsinglex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} } % Subroutines used in generating headings % Produces Day Month Year style of output. \def\today{\number\day\space \ifcase\month\or January\or February\or March\or April\or May\or June\or July\or August\or September\or October\or November\or December\fi \space\number\year} % Use this if you want the Month Day, Year style of output. %\def\today{\ifcase\month\or %January\or February\or March\or April\or May\or June\or %July\or August\or September\or October\or November\or December\fi %\space\number\day, \number\year} % @settitle line... specifies the title of the document, for headings % It generates no output of its own \def\thistitle{No Title} \def\settitle{\parsearg\settitlezzz} \def\settitlezzz #1{\gdef\thistitle{#1}} \message{tables,} % @tabs -- simple alignment % These don't work. For one thing, \+ is defined as outer. % So these macros cannot even be defined. %\def\tabs{\parsearg\tabszzz} %\def\tabszzz #1{\settabs\+#1\cr} %\def\tabline{\parsearg\tablinezzz} %\def\tablinezzz #1{\+#1\cr} %\def\&{&} % Tables -- @table, @ftable, @vtable, @item(x), @kitem(x), @xitem(x). % default indentation of table text \newdimen\tableindent \tableindent=.8in % default indentation of @itemize and @enumerate text \newdimen\itemindent \itemindent=.3in % margin between end of table item and start of table text. \newdimen\itemmargin \itemmargin=.1in % used internally for \itemindent minus \itemmargin \newdimen\itemmax % Note @table, @vtable, and @vtable define @item, @itemx, etc., with % these defs. % They also define \itemindex % to index the item name in whatever manner is desired (perhaps none). \newif\ifitemxneedsnegativevskip \def\itemxpar{\par\ifitemxneedsnegativevskip\vskip-\parskip\nobreak\fi} \def\internalBitem{\smallbreak \parsearg\itemzzz} \def\internalBitemx{\itemxpar \parsearg\itemzzz} \def\internalBxitem "#1"{\def\xitemsubtopix{#1} \smallbreak \parsearg\xitemzzz} \def\internalBxitemx "#1"{\def\xitemsubtopix{#1} \itemxpar \parsearg\xitemzzz} \def\internalBkitem{\smallbreak \parsearg\kitemzzz} \def\internalBkitemx{\itemxpar \parsearg\kitemzzz} \def\kitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \lastfunction}}% \itemzzz {#1}} \def\xitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \xitemsubtopic}}% \itemzzz {#1}} \def\itemzzz #1{\begingroup % \advance\hsize by -\rightskip \advance\hsize by -\tableindent \setbox0=\hbox{\itemfont{#1}}% \itemindex{#1}% \nobreak % This prevents a break before @itemx. % % Be sure we are not still in the middle of a paragraph. %{\parskip = 0in %\par %}% % % If the item text does not fit in the space we have, put it on a line % by itself, and do not allow a page break either before or after that % line. We do not start a paragraph here because then if the next % command is, e.g., @kindex, the whatsit would get put into the % horizontal list on a line by itself, resulting in extra blank space. \ifdim \wd0>\itemmax % % Make this a paragraph so we get the \parskip glue and wrapping, % but leave it ragged-right. \begingroup \advance\leftskip by-\tableindent \advance\hsize by\tableindent \advance\rightskip by0pt plus1fil \leavevmode\unhbox0\par \endgroup % % We're going to be starting a paragraph, but we don't want the % \parskip glue -- logically it's part of the @item we just started. \nobreak \vskip-\parskip % % Stop a page break at the \parskip glue coming up. Unfortunately % we can't prevent a possible page break at the following % \baselineskip glue. \nobreak \endgroup \itemxneedsnegativevskipfalse \else % The item text fits into the space. Start a paragraph, so that the % following text (if any) will end up on the same line. Since that % text will be indented by \tableindent, we make the item text be in % a zero-width box. \noindent \rlap{\hskip -\tableindent\box0}\ignorespaces% \endgroup% \itemxneedsnegativevskiptrue% \fi } \def\item{\errmessage{@item while not in a table}} \def\itemx{\errmessage{@itemx while not in a table}} \def\kitem{\errmessage{@kitem while not in a table}} \def\kitemx{\errmessage{@kitemx while not in a table}} \def\xitem{\errmessage{@xitem while not in a table}} \def\xitemx{\errmessage{@xitemx while not in a table}} %% Contains a kludge to get @end[description] to work \def\description{\tablez{\dontindex}{1}{}{}{}{}} \def\table{\begingroup\inENV\obeylines\obeyspaces\tablex} {\obeylines\obeyspaces% \gdef\tablex #1^^M{% \tabley\dontindex#1 \endtabley}} \def\ftable{\begingroup\inENV\obeylines\obeyspaces\ftablex} {\obeylines\obeyspaces% \gdef\ftablex #1^^M{% \tabley\fnitemindex#1 \endtabley \def\Eftable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\vtable{\begingroup\inENV\obeylines\obeyspaces\vtablex} {\obeylines\obeyspaces% \gdef\vtablex #1^^M{% \tabley\vritemindex#1 \endtabley \def\Evtable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\dontindex #1{} \def\fnitemindex #1{\doind {fn}{\code{#1}}}% \def\vritemindex #1{\doind {vr}{\code{#1}}}% {\obeyspaces % \gdef\tabley#1#2 #3 #4 #5 #6 #7\endtabley{\endgroup% \tablez{#1}{#2}{#3}{#4}{#5}{#6}}} \def\tablez #1#2#3#4#5#6{% \aboveenvbreak % \begingroup % \def\Edescription{\Etable}% Neccessary kludge. \let\itemindex=#1% \ifnum 0#3>0 \advance \leftskip by #3\mil \fi % \ifnum 0#4>0 \tableindent=#4\mil \fi % \ifnum 0#5>0 \advance \rightskip by #5\mil \fi % \def\itemfont{#2}% \itemmax=\tableindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \tableindent % \exdentamount=\tableindent \parindent = 0pt \parskip = \smallskipamount \ifdim \parskip=0pt \parskip=2pt \fi% \def\Etable{\endgraf\afterenvbreak\endgroup}% \let\item = \internalBitem % \let\itemx = \internalBitemx % \let\kitem = \internalBkitem % \let\kitemx = \internalBkitemx % \let\xitem = \internalBxitem % \let\xitemx = \internalBxitemx % } % This is the counter used by @enumerate, which is really @itemize \newcount \itemno \def\itemize{\parsearg\itemizezzz} \def\itemizezzz #1{% \begingroup % ended by the @end itemsize \itemizey {#1}{\Eitemize} } \def\itemizey #1#2{% \aboveenvbreak % \itemmax=\itemindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \itemindent % \exdentamount=\itemindent \parindent = 0pt % \parskip = \smallskipamount % \ifdim \parskip=0pt \parskip=2pt \fi% \def#2{\endgraf\afterenvbreak\endgroup}% \def\itemcontents{#1}% \let\item=\itemizeitem} % Set sfcode to normal for the chars that usually have another value. % These are `.?!:;,' \def\frenchspacing{\sfcode46=1000 \sfcode63=1000 \sfcode33=1000 \sfcode58=1000 \sfcode59=1000 \sfcode44=1000 } % \splitoff TOKENS\endmark defines \first to be the first token in % TOKENS, and \rest to be the remainder. % \def\splitoff#1#2\endmark{\def\first{#1}\def\rest{#2}}% % Allow an optional argument of an uppercase letter, lowercase letter, % or number, to specify the first label in the enumerated list. No % argument is the same as `1'. % \def\enumerate{\parsearg\enumeratezzz} \def\enumeratezzz #1{\enumeratey #1 \endenumeratey} \def\enumeratey #1 #2\endenumeratey{% \begingroup % ended by the @end enumerate % % If we were given no argument, pretend we were given `1'. \def\thearg{#1}% \ifx\thearg\empty \def\thearg{1}\fi % % Detect if the argument is a single token. If so, it might be a % letter. Otherwise, the only valid thing it can be is a number. % (We will always have one token, because of the test we just made. % This is a good thing, since \splitoff doesn't work given nothing at % all -- the first parameter is undelimited.) \expandafter\splitoff\thearg\endmark \ifx\rest\empty % Only one token in the argument. It could still be anything. % A ``lowercase letter'' is one whose \lccode is nonzero. % An ``uppercase letter'' is one whose \lccode is both nonzero, and % not equal to itself. % Otherwise, we assume it's a number. % % We need the \relax at the end of the \ifnum lines to stop TeX from % continuing to look for a . % \ifnum\lccode\expandafter`\thearg=0\relax \numericenumerate % a number (we hope) \else % It's a letter. \ifnum\lccode\expandafter`\thearg=\expandafter`\thearg\relax \lowercaseenumerate % lowercase letter \else \uppercaseenumerate % uppercase letter \fi \fi \else % Multiple tokens in the argument. We hope it's a number. \numericenumerate \fi } % An @enumerate whose labels are integers. The starting integer is % given in \thearg. % \def\numericenumerate{% \itemno = \thearg \startenumeration{\the\itemno}% } % The starting (lowercase) letter is in \thearg. \def\lowercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more lowercase letters in @enumerate; get a bigger alphabet}% \fi \char\lccode\itemno }% } % The starting (uppercase) letter is in \thearg. \def\uppercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more uppercase letters in @enumerate; get a bigger alphabet} \fi \char\uccode\itemno }% } % Call itemizey, adding a period to the first argument and supplying the % common last two arguments. Also subtract one from the initial value in % \itemno, since @item increments \itemno. % \def\startenumeration#1{% \advance\itemno by -1 \itemizey{#1.}\Eenumerate\flushcr } % @alphaenumerate and @capsenumerate are abbreviations for giving an arg % to @enumerate. % \def\alphaenumerate{\enumerate{a}} \def\capsenumerate{\enumerate{A}} \def\Ealphaenumerate{\Eenumerate} \def\Ecapsenumerate{\Eenumerate} % Definition of @item while inside @itemize. \def\itemizeitem{% \advance\itemno by 1 {\let\par=\endgraf \smallbreak}% \ifhmode \errmessage{\in hmode at itemizeitem}\fi {\parskip=0in \hskip 0pt \hbox to 0pt{\hss \itemcontents\hskip \itemmargin}% \vadjust{\penalty 1200}}% \flushcr} \message{indexing,} % Index generation facilities % Define \newwrite to be identical to plain tex's \newwrite % except not \outer, so it can be used within \newindex. {\catcode`\@=11 \gdef\newwrite{\alloc@7\write\chardef\sixt@@n}} % \newindex {foo} defines an index named foo. % It automatically defines \fooindex such that % \fooindex ...rest of line... puts an entry in the index foo. % It also defines \fooindfile to be the number of the output channel for % the file that accumulates this index. The file's extension is foo. % The name of an index should be no more than 2 characters long % for the sake of vms. \def\newindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#1}} } % @defindex foo == \newindex{foo} \def\defindex{\parsearg\newindex} % Define @defcodeindex, like @defindex except put all entries in @code. \def\newcodeindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#1}} } \def\defcodeindex{\parsearg\newcodeindex} % @synindex foo bar makes index foo feed into index bar. % Do this instead of @defindex foo if you don't want it as a separate index. \def\synindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#2}}% } % @syncodeindex foo bar similar, but put all entries made for index foo % inside @code. \def\syncodeindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#2}}% } % Define \doindex, the driver for all \fooindex macros. % Argument #1 is generated by the calling \fooindex macro, % and it is "foo", the name of the index. % \doindex just uses \parsearg; it calls \doind for the actual work. % This is because \doind is more useful to call from other macros. % There is also \dosubind {index}{topic}{subtopic} % which makes an entry in a two-level index such as the operation index. \def\doindex#1{\edef\indexname{#1}\parsearg\singleindexer} \def\singleindexer #1{\doind{\indexname}{#1}} % like the previous two, but they put @code around the argument. \def\docodeindex#1{\edef\indexname{#1}\parsearg\singlecodeindexer} \def\singlecodeindexer #1{\doind{\indexname}{\code{#1}}} \def\indexdummies{% \def\_{{\realbackslash _}}% \def\w{\realbackslash w }% \def\bf{\realbackslash bf }% \def\rm{\realbackslash rm }% \def\sl{\realbackslash sl }% \def\sf{\realbackslash sf}% \def\tt{\realbackslash tt}% \def\gtr{\realbackslash gtr}% \def\less{\realbackslash less}% \def\hat{\realbackslash hat}% \def\char{\realbackslash char}% \def\TeX{\realbackslash TeX}% \def\dots{\realbackslash dots }% \def\copyright{\realbackslash copyright }% \def\tclose##1{\realbackslash tclose {##1}}% \def\code##1{\realbackslash code {##1}}% \def\samp##1{\realbackslash samp {##1}}% \def\t##1{\realbackslash r {##1}}% \def\r##1{\realbackslash r {##1}}% \def\i##1{\realbackslash i {##1}}% \def\b##1{\realbackslash b {##1}}% \def\cite##1{\realbackslash cite {##1}}% \def\key##1{\realbackslash key {##1}}% \def\file##1{\realbackslash file {##1}}% \def\var##1{\realbackslash var {##1}}% \def\kbd##1{\realbackslash kbd {##1}}% \def\dfn##1{\realbackslash dfn {##1}}% \def\emph##1{\realbackslash emph {##1}}% } % \indexnofonts no-ops all font-change commands. % This is used when outputting the strings to sort the index by. \def\indexdummyfont#1{#1} \def\indexdummytex{TeX} \def\indexdummydots{...} \def\indexnofonts{% \let\w=\indexdummyfont \let\t=\indexdummyfont \let\r=\indexdummyfont \let\i=\indexdummyfont \let\b=\indexdummyfont \let\emph=\indexdummyfont \let\strong=\indexdummyfont \let\cite=\indexdummyfont \let\sc=\indexdummyfont %Don't no-op \tt, since it isn't a user-level command % and is used in the definitions of the active chars like <, >, |... %\let\tt=\indexdummyfont \let\tclose=\indexdummyfont \let\code=\indexdummyfont \let\file=\indexdummyfont \let\samp=\indexdummyfont \let\kbd=\indexdummyfont \let\key=\indexdummyfont \let\var=\indexdummyfont \let\TeX=\indexdummytex \let\dots=\indexdummydots } % To define \realbackslash, we must make \ not be an escape. % We must first make another character (@) an escape % so we do not become unable to do a definition. {\catcode`\@=0 \catcode`\\=\other @gdef@realbackslash{\}} \let\indexbackslash=0 %overridden during \printindex. \def\doind #1#2{% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\% {\let\folio=0% Expand all macros now EXCEPT \folio \def\rawbackslashxx{\indexbackslash}% \indexbackslash isn't defined now % so it will be output as is; and it will print as backslash in the indx. % % Now process the index-string once, with all font commands turned off, % to get the string to sort the index by. {\indexnofonts \xdef\temp1{#2}% }% % Now produce the complete index entry. We process the index-string again, % this time with font commands expanded, to get what to print in the index. \edef\temp{% \write \csname#1indfile\endcsname{% \realbackslash entry {\temp1}{\folio}{#2}}}% \temp }% }\penalty\count10}} \def\dosubind #1#2#3{% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\% {\let\folio=0% \def\rawbackslashxx{\indexbackslash}% % % Now process the index-string once, with all font commands turned off, % to get the string to sort the index by. {\indexnofonts \xdef\temp1{#2 #3}% }% % Now produce the complete index entry. We process the index-string again, % this time with font commands expanded, to get what to print in the index. \edef\temp{% \write \csname#1indfile\endcsname{% \realbackslash entry {\temp1}{\folio}{#2}{#3}}}% \temp }% }\penalty\count10}} % The index entry written in the file actually looks like % \entry {sortstring}{page}{topic} % or % \entry {sortstring}{page}{topic}{subtopic} % The texindex program reads in these files and writes files % containing these kinds of lines: % \initial {c} % before the first topic whose initial is c % \entry {topic}{pagelist} % for a topic that is used without subtopics % \primary {topic} % for the beginning of a topic that is used with subtopics % \secondary {subtopic}{pagelist} % for each subtopic. % Define the user-accessible indexing commands % @findex, @vindex, @kindex, @cindex. \def\findex {\fnindex} \def\kindex {\kyindex} \def\cindex {\cpindex} \def\vindex {\vrindex} \def\tindex {\tpindex} \def\pindex {\pgindex} \def\cindexsub {\begingroup\obeylines\cindexsub} {\obeylines % \gdef\cindexsub "#1" #2^^M{\endgroup % \dosubind{cp}{#2}{#1}}} % Define the macros used in formatting output of the sorted index material. % This is what you call to cause a particular index to get printed. % Write % @unnumbered Function Index % @printindex fn \def\printindex{\parsearg\doprintindex} \def\doprintindex#1{% \tex \dobreak \chapheadingskip {10000} \catcode`\%=\other\catcode`\&=\other\catcode`\#=\other \catcode`\$=\other\catcode`\_=\other \catcode`\~=\other % % The following don't help, since the chars were translated % when the raw index was written, and their fonts were discarded % due to \indexnofonts. %\catcode`\"=\active %\catcode`\^=\active %\catcode`\_=\active %\catcode`\|=\active %\catcode`\<=\active %\catcode`\>=\active % % \def\indexbackslash{\rawbackslashxx} \indexfonts\rm \tolerance=9500 \advance\baselineskip -1pt \begindoublecolumns % % See if the index file exists and is nonempty. \openin 1 \jobname.#1s \ifeof 1 % \enddoublecolumns gets confused if there is no text in the index, % and it loses the chapter title and the aux file entries for the % index. The easiest way to prevent this problem is to make sure % there is some text. (Index is nonexistent) \else % % If the index file exists but is empty, then \openin leaves \ifeof % false. We have to make TeX try to read something from the file, so % it can discover if there is anything in it. \read 1 to \temp \ifeof 1 (Index is empty) \else \input \jobname.#1s \fi \fi \closein 1 \enddoublecolumns \Etex } % These macros are used by the sorted index file itself. % Change them to control the appearance of the index. % Same as \bigskipamount except no shrink. % \balancecolumns gets confused if there is any shrink. \newskip\initialskipamount \initialskipamount 12pt plus4pt \def\initial #1{% {\let\tentt=\sectt \let\tt=\sectt \let\sf=\sectt \ifdim\lastskip<\initialskipamount \removelastskip \penalty-200 \vskip \initialskipamount\fi \line{\secbf#1\hfill}\kern 2pt\penalty10000}} % This typesets a paragraph consisting of #1, dot leaders, and then #2 % flush to the right margin. It is used for index and table of contents % entries. The paragraph is indented by \leftskip. % \def\entry #1#2{\begingroup % % Start a new paragraph if necessary, so our assignments below can't % affect previous text. \par % % Do not fill out the last line with white space. \parfillskip = 0in % % No extra space above this paragraph. \parskip = 0in % % Do not prefer a separate line ending with a hyphen to fewer lines. \finalhyphendemerits = 0 % % \hangindent is only relevant when the entry text and page number % don't both fit on one line. In that case, bob suggests starting the % dots pretty far over on the line. Unfortunately, a large % indentation looks wrong when the entry text itself is broken across % lines. So we use a small indentation and put up with long leaders. % % \hangafter is reset to 1 (which is the value we want) at the start % of each paragraph, so we need not do anything with that. \hangindent=2em % % When the entry text needs to be broken, just fill out the first line % with blank space. \rightskip = 0pt plus1fil % % Start a ``paragraph'' for the index entry so the line breaking % parameters we've set above will have an effect. \noindent % % Insert the text of the index entry. TeX will do line-breaking on it. #1% % If there are no page numbers, don't output a line of dots. \def\tempa{#2} \def\tempb{} \ifx\tempa\tempb\ \else % % If we must, put the page number on a line of its own, and fill out % this line with blank space. (The \hfil is overwhelmed with the % fill leaders glue in \indexdotfill if the page number does fit.) \hfil\penalty50 \null\nobreak\indexdotfill % Have leaders before the page number. % % The `\ ' here is removed by the implicit \unskip that TeX does as % part of (the primitive) \par. Without it, a spurious underfull % \hbox ensues. \ #2% The page number ends the paragraph. \fi% \par \endgroup} % Like \dotfill except takes at least 1 em. \def\indexdotfill{\cleaders \hbox{$\mathsurround=0pt \mkern1.5mu . \mkern1.5mu$}\hskip 1em plus 1fill} \def\primary #1{\line{#1\hfil}} \newskip\secondaryindent \secondaryindent=0.5cm \def\secondary #1#2{ {\parfillskip=0in \parskip=0in \hangindent =1in \hangafter=1 \noindent\hskip\secondaryindent\hbox{#1}\indexdotfill #2\par }} %% Define two-column mode, which is used in indexes. %% Adapted from the TeXbook, page 416. \catcode `\@=11 \newbox\partialpage \newdimen\doublecolumnhsize \def\begindoublecolumns{\begingroup % Grab any single-column material above us. \output = {\global\setbox\partialpage =\vbox{\unvbox255\kern -\topskip \kern \baselineskip}}% \eject % % Now switch to the double-column output routine. \output={\doublecolumnout}% % % Change the page size parameters. We could do this once outside this % routine, in each of @smallbook, @afourpaper, and the default 8.5x11 % format, but then we repeat the same computation. Repeating a couple % of assignments once per index is clearly meaningless for the % execution time, so we may as well do it once. % % First we halve the line length, less a little for the gutter between % the columns. We compute the gutter based on the line length, so it % changes automatically with the paper format. The magic constant % below is chosen so that the gutter has the same value (well, +- < % 1pt) as it did when we hard-coded it. % % We put the result in a separate register, \doublecolumhsize, so we % can restore it in \pagesofar, after \hsize itself has (potentially) % been clobbered. % \doublecolumnhsize = \hsize \advance\doublecolumnhsize by -.04154\hsize \divide\doublecolumnhsize by 2 \hsize = \doublecolumnhsize % % Double the \vsize as well. (We don't need a separate register here, % since nobody clobbers \vsize.) \vsize = 2\vsize \doublecolumnpagegoal } \def\enddoublecolumns{\eject \endgroup \pagegoal=\vsize \unvbox\partialpage} \def\doublecolumnsplit{\splittopskip=\topskip \splitmaxdepth=\maxdepth \global\dimen@=\pageheight \global\advance\dimen@ by-\ht\partialpage \global\setbox1=\vsplit255 to\dimen@ \global\setbox0=\vbox{\unvbox1} \global\setbox3=\vsplit255 to\dimen@ \global\setbox2=\vbox{\unvbox3} \ifdim\ht0>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi \ifdim\ht2>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi } \def\doublecolumnpagegoal{% \dimen@=\vsize \advance\dimen@ by-2\ht\partialpage \global\pagegoal=\dimen@ } \def\pagesofar{\unvbox\partialpage % \hsize=\doublecolumnhsize % have to restore this since output routine \wd0=\hsize \wd2=\hsize \hbox to\pagewidth{\box0\hfil\box2}} \def\doublecolumnout{% \setbox5=\copy255 {\vbadness=10000 \doublecolumnsplit} \ifvbox255 \setbox0=\vtop to\dimen@{\unvbox0} \setbox2=\vtop to\dimen@{\unvbox2} \onepageout\pagesofar \unvbox255 \penalty\outputpenalty \else \setbox0=\vbox{\unvbox5} \ifvbox0 \dimen@=\ht0 \advance\dimen@ by\topskip \advance\dimen@ by-\baselineskip \divide\dimen@ by2 \splittopskip=\topskip \splitmaxdepth=\maxdepth {\vbadness=10000 \loop \global\setbox5=\copy0 \setbox1=\vsplit5 to\dimen@ \setbox3=\vsplit5 to\dimen@ \ifvbox5 \global\advance\dimen@ by1pt \repeat \setbox0=\vbox to\dimen@{\unvbox1} \setbox2=\vbox to\dimen@{\unvbox3} \global\setbox\partialpage=\vbox{\pagesofar} \doublecolumnpagegoal } \fi \fi } \catcode `\@=\other \message{sectioning,} % Define chapters, sections, etc. \newcount \chapno \newcount \secno \secno=0 \newcount \subsecno \subsecno=0 \newcount \subsubsecno \subsubsecno=0 % This counter is funny since it counts through charcodes of letters A, B, ... \newcount \appendixno \appendixno = `\@ \def\appendixletter{\char\the\appendixno} \newwrite \contentsfile % This is called from \setfilename. \def\opencontents{\openout \contentsfile = \jobname.toc} % Each @chapter defines this as the name of the chapter. % page headings and footings can use it. @section does likewise \def\thischapter{} \def\thissection{} \def\seccheck#1{\if \pageno<0 % \errmessage{@#1 not allowed after generating table of contents}\fi % } \def\chapternofonts{% \let\rawbackslash=\relax% \let\frenchspacing=\relax% \def\result{\realbackslash result} \def\equiv{\realbackslash equiv} \def\expansion{\realbackslash expansion} \def\print{\realbackslash print} \def\TeX{\realbackslash TeX} \def\dots{\realbackslash dots} \def\copyright{\realbackslash copyright} \def\tt{\realbackslash tt} \def\bf{\realbackslash bf } \def\w{\realbackslash w} \def\less{\realbackslash less} \def\gtr{\realbackslash gtr} \def\hat{\realbackslash hat} \def\char{\realbackslash char} \def\tclose##1{\realbackslash tclose {##1}} \def\code##1{\realbackslash code {##1}} \def\samp##1{\realbackslash samp {##1}} \def\r##1{\realbackslash r {##1}} \def\b##1{\realbackslash b {##1}} \def\key##1{\realbackslash key {##1}} \def\file##1{\realbackslash file {##1}} \def\kbd##1{\realbackslash kbd {##1}} % These are redefined because @smartitalic wouldn't work inside xdef. \def\i##1{\realbackslash i {##1}} \def\cite##1{\realbackslash cite {##1}} \def\var##1{\realbackslash var {##1}} \def\emph##1{\realbackslash emph {##1}} \def\dfn##1{\realbackslash dfn {##1}} } \newcount\absseclevel % used to calculate proper heading level \newcount\secbase\secbase=0 % @raise/lowersections modify this count % @raisesections: treat @section as chapter, @subsection as section, etc. \def\raisesections{\global\advance\secbase by -1} \let\up=\raisesections % original BFox name % @lowersections: treat @chapter as section, @section as subsection, etc. \def\lowersections{\global\advance\secbase by 1} \let\down=\lowersections % original BFox name % Choose a numbered-heading macro % #1 is heading level if unmodified by @raisesections or @lowersections % #2 is text for heading \def\numhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \chapterzzz{#2} \or \seczzz{#2} \or \numberedsubseczzz{#2} \or \numberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \chapterzzz{#2} \else \numberedsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses appendix heading levels \def\apphead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \appendixzzz{#2} \or \appendixsectionzzz{#2} \or \appendixsubseczzz{#2} \or \appendixsubsubseczzz{#2} \else \ifnum \absseclevel<0 \appendixzzz{#2} \else \appendixsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses numberless heading levels \def\unnmhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \unnumberedzzz{#2} \or \unnumberedseczzz{#2} \or \unnumberedsubseczzz{#2} \or \unnumberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \unnumberedzzz{#2} \else \unnumberedsubsubseczzz{#2} \fi \fi } \def\thischaptername{No Chapter Title} \outer\def\chapter{\parsearg\chapteryyy} \def\chapteryyy #1{\numhead0{#1}} % normally numhead0 calls chapterzzz \def\chapterzzz #1{\seccheck{chapter}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \chapno by 1 \message{Chapter \the\chapno}% \chapmacro {#1}{\the\chapno}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% % We don't substitute the actual chapter name into \thischapter % because we don't want its macros evaluated now. \xdef\thischapter{Chapter \the\chapno: \noexpand\thischaptername}% {\chapternofonts% \edef\temp{{\realbackslash chapentry {#1}{\the\chapno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec }} \outer\def\appendix{\parsearg\appendixyyy} \def\appendixyyy #1{\apphead0{#1}} % normally apphead0 calls appendixzzz \def\appendixzzz #1{\seccheck{appendix}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \appendixno by 1 \message{Appendix \appendixletter}% \chapmacro {#1}{Appendix \appendixletter}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% \xdef\thischapter{Appendix \appendixletter: \noexpand\thischaptername}% {\chapternofonts% \edef\temp{{\realbackslash chapentry {#1}{Appendix \appendixletter}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \global\let\section = \appendixsec \global\let\subsection = \appendixsubsec \global\let\subsubsection = \appendixsubsubsec }} \outer\def\top{\parsearg\unnumberedyyy} \outer\def\unnumbered{\parsearg\unnumberedyyy} \def\unnumberedyyy #1{\unnmhead0{#1}} % normally unnmhead0 calls unnumberedzzz \def\unnumberedzzz #1{\seccheck{unnumbered}% \secno=0 \subsecno=0 \subsubsecno=0 % % This used to be simply \message{#1}, but TeX fully expands the % argument to \message. Therefore, if #1 contained @-commands, TeX % expanded them. For example, in `@unnumbered The @cite{Book}', TeX % expanded @cite (which turns out to cause errors because \cite is meant % to be executed, not expanded). % % Anyway, we don't want the fully-expanded definition of @cite to appear % as a result of the \message, we just want `@cite' itself. We use % \the to achieve this: TeX expands \the only once, % simply yielding the contents of the . \toks0 = {#1}\message{(\the\toks0)}% % \unnumbchapmacro {#1}% \gdef\thischapter{#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbchapentry {#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \global\let\section = \unnumberedsec \global\let\subsection = \unnumberedsubsec \global\let\subsubsection = \unnumberedsubsubsec }} \outer\def\numberedsec{\parsearg\secyyy} \def\secyyy #1{\numhead1{#1}} % normally calls seczzz \def\seczzz #1{\seccheck{section}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\the\chapno}{\the\secno}% {\chapternofonts% \edef\temp{{\realbackslash secentry % {#1}{\the\chapno}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appenixsection{\parsearg\appendixsecyyy} \outer\def\appendixsec{\parsearg\appendixsecyyy} \def\appendixsecyyy #1{\apphead1{#1}} % normally calls appendixsectionzzz \def\appendixsectionzzz #1{\seccheck{appendixsection}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\appendixletter}{\the\secno}% {\chapternofonts% \edef\temp{{\realbackslash secentry % {#1}{\appendixletter}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsec{\parsearg\unnumberedsecyyy} \def\unnumberedsecyyy #1{\unnmhead1{#1}} % normally calls unnumberedseczzz \def\unnumberedseczzz #1{\seccheck{unnumberedsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsec{\parsearg\numberedsubsecyyy} \def\numberedsubsecyyy #1{\numhead2{#1}} % normally calls numberedsubseczzz \def\numberedsubseczzz #1{\seccheck{subsection}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\the\chapno}{\the\secno}{\the\subsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsecentry % {#1}{\the\chapno}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsec{\parsearg\appendixsubsecyyy} \def\appendixsubsecyyy #1{\apphead2{#1}} % normally calls appendixsubseczzz \def\appendixsubseczzz #1{\seccheck{appendixsubsec}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\appendixletter}{\the\secno}{\the\subsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsecentry % {#1}{\appendixletter}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsec{\parsearg\unnumberedsubsecyyy} \def\unnumberedsubsecyyy #1{\unnmhead2{#1}} %normally calls unnumberedsubseczzz \def\unnumberedsubseczzz #1{\seccheck{unnumberedsubsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsubsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsubsec{\parsearg\numberedsubsubsecyyy} \def\numberedsubsubsecyyy #1{\numhead3{#1}} % normally numberedsubsubseczzz \def\numberedsubsubseczzz #1{\seccheck{subsubsection}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsubsecentry % {#1} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno} {\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsubsec{\parsearg\appendixsubsubsecyyy} \def\appendixsubsubsecyyy #1{\apphead3{#1}} % normally appendixsubsubseczzz \def\appendixsubsubseczzz #1{\seccheck{appendixsubsubsec}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\appendixletter}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsubsecentry{#1}% {\appendixletter} {\the\secno}{\the\subsecno}{\the\subsubsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsubsec{\parsearg\unnumberedsubsubsecyyy} \def\unnumberedsubsubsecyyy #1{\unnmhead3{#1}} %normally unnumberedsubsubseczzz \def\unnumberedsubsubseczzz #1{\seccheck{unnumberedsubsubsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsubsubsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} % These are variants which are not "outer", so they can appear in @ifinfo. % Actually, they should now be obsolete; ordinary section commands should work. \def\infotop{\parsearg\unnumberedzzz} \def\infounnumbered{\parsearg\unnumberedzzz} \def\infounnumberedsec{\parsearg\unnumberedseczzz} \def\infounnumberedsubsec{\parsearg\unnumberedsubseczzz} \def\infounnumberedsubsubsec{\parsearg\unnumberedsubsubseczzz} \def\infoappendix{\parsearg\appendixzzz} \def\infoappendixsec{\parsearg\appendixseczzz} \def\infoappendixsubsec{\parsearg\appendixsubseczzz} \def\infoappendixsubsubsec{\parsearg\appendixsubsubseczzz} \def\infochapter{\parsearg\chapterzzz} \def\infosection{\parsearg\sectionzzz} \def\infosubsection{\parsearg\subsectionzzz} \def\infosubsubsection{\parsearg\subsubsectionzzz} % These macros control what the section commands do, according % to what kind of chapter we are in (ordinary, appendix, or unnumbered). % Define them by default for a numbered chapter. \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec % Define @majorheading, @heading and @subheading % NOTE on use of \vbox for chapter headings, section headings, and % such: % 1) We use \vbox rather than the earlier \line to permit % overlong headings to fold. % 2) \hyphenpenalty is set to 10000 because hyphenation in a % heading is obnoxious; this forbids it. % 3) Likewise, headings look best if no \parindent is used, and % if justification is not attempted. Hence \raggedright. \def\majorheading{\parsearg\majorheadingzzz} \def\majorheadingzzz #1{% {\advance\chapheadingskip by 10pt \chapbreak }% {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} \def\chapheading{\parsearg\chapheadingzzz} \def\chapheadingzzz #1{\chapbreak % {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} \def\heading{\parsearg\secheadingi} \def\subheading{\parsearg\subsecheadingi} \def\subsubheading{\parsearg\subsubsecheadingi} % These macros generate a chapter, section, etc. heading only % (including whitespace, linebreaking, etc. around it), % given all the information in convenient, parsed form. %%% Args are the skip and penalty (usually negative) \def\dobreak#1#2{\par\ifdim\lastskip<#1\removelastskip\penalty#2\vskip#1\fi} \def\setchapterstyle #1 {\csname CHAPF#1\endcsname} %%% Define plain chapter starts, and page on/off switching for it % Parameter controlling skip before chapter headings (if needed) \newskip \chapheadingskip \chapheadingskip = 30pt plus 8pt minus 4pt \def\chapbreak{\dobreak \chapheadingskip {-4000}} \def\chappager{\par\vfill\supereject} \def\chapoddpage{\chappager \ifodd\pageno \else \hbox to 0pt{} \chappager\fi} \def\setchapternewpage #1 {\csname CHAPPAG#1\endcsname} \def\CHAPPAGoff{ \global\let\pchapsepmacro=\chapbreak \global\let\pagealignmacro=\chappager} \def\CHAPPAGon{ \global\let\pchapsepmacro=\chappager \global\let\pagealignmacro=\chappager \global\def\HEADINGSon{\HEADINGSsingle}} \def\CHAPPAGodd{ \global\let\pchapsepmacro=\chapoddpage \global\let\pagealignmacro=\chapoddpage \global\def\HEADINGSon{\HEADINGSdouble}} \CHAPPAGon \def\CHAPFplain{ \global\let\chapmacro=\chfplain \global\let\unnumbchapmacro=\unnchfplain} \def\chfplain #1#2{% \pchapsepmacro {% \chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #2\enspace #1}% }% \bigskip \penalty5000 } \def\unnchfplain #1{% \pchapsepmacro % {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 10000 % } \CHAPFplain % The default \def\unnchfopen #1{% \chapoddpage {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 10000 % } \def\chfopen #1#2{\chapoddpage {\chapfonts \vbox to 3in{\vfil \hbox to\hsize{\hfil #2} \hbox to\hsize{\hfil #1} \vfil}}% \par\penalty 5000 % } \def\CHAPFopen{ \global\let\chapmacro=\chfopen \global\let\unnumbchapmacro=\unnchfopen} % Parameter controlling skip before section headings. \newskip \subsecheadingskip \subsecheadingskip = 17pt plus 8pt minus 4pt \def\subsecheadingbreak{\dobreak \subsecheadingskip {-500}} \newskip \secheadingskip \secheadingskip = 21pt plus 8pt minus 4pt \def\secheadingbreak{\dobreak \secheadingskip {-1000}} % @paragraphindent is defined for the Info formatting commands only. \let\paragraphindent=\comment % Section fonts are the base font at magstep2, which produces % a size a bit more than 14 points in the default situation. \def\secheading #1#2#3{\secheadingi {#2.#3\enspace #1}} \def\plainsecheading #1{\secheadingi {#1}} \def\secheadingi #1{{\advance \secheadingskip by \parskip % \secheadingbreak}% {\secfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 } % Subsection fonts are the base font at magstep1, % which produces a size of 12 points. \def\subsecheading #1#2#3#4{\subsecheadingi {#2.#3.#4\enspace #1}} \def\subsecheadingi #1{{\advance \subsecheadingskip by \parskip % \subsecheadingbreak}% {\subsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 } \def\subsubsecfonts{\subsecfonts} % Maybe this should change: % Perhaps make sssec fonts scaled % magstep half \def\subsubsecheading #1#2#3#4#5{\subsubsecheadingi {#2.#3.#4.#5\enspace #1}} \def\subsubsecheadingi #1{{\advance \subsecheadingskip by \parskip % \subsecheadingbreak}% {\subsubsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000} \message{toc printing,} % Finish up the main text and prepare to read what we've written % to \contentsfile. \newskip\contentsrightmargin \contentsrightmargin=1in \def\startcontents#1{% \pagealignmacro \immediate\closeout \contentsfile \ifnum \pageno>0 \pageno = -1 % Request roman numbered pages. \fi % Don't need to put `Contents' or `Short Contents' in the headline. % It is abundantly clear what they are. \unnumbchapmacro{#1}\def\thischapter{}% \begingroup % Set up to handle contents files properly. \catcode`\\=0 \catcode`\{=1 \catcode`\}=2 \catcode`\@=11 \raggedbottom % Worry more about breakpoints than the bottom. \advance\hsize by -\contentsrightmargin % Don't use the full line length. } % Normal (long) toc. \outer\def\contents{% \startcontents{Table of Contents}% \input \jobname.toc \endgroup \vfill \eject } % And just the chapters. \outer\def\summarycontents{% \startcontents{Short Contents}% % \let\chapentry = \shortchapentry \let\unnumbchapentry = \shortunnumberedentry % We want a true roman here for the page numbers. \secfonts \let\rm=\shortcontrm \let\bf=\shortcontbf \let\sl=\shortcontsl \rm \advance\baselineskip by 1pt % Open it up a little. \def\secentry ##1##2##3##4{} \def\unnumbsecentry ##1##2{} \def\subsecentry ##1##2##3##4##5{} \def\unnumbsubsecentry ##1##2{} \def\subsubsecentry ##1##2##3##4##5##6{} \def\unnumbsubsubsecentry ##1##2{} \input \jobname.toc \endgroup \vfill \eject } \let\shortcontents = \summarycontents % These macros generate individual entries in the table of contents. % The first argument is the chapter or section name. % The last argument is the page number. % The arguments in between are the chapter number, section number, ... % Chapter-level things, for both the long and short contents. \def\chapentry#1#2#3{\dochapentry{#2\labelspace#1}{#3}} % See comments in \dochapentry re vbox and related settings \def\shortchapentry#1#2#3{% \tocentry{\shortchaplabel{#2}\labelspace #1}{\doshortpageno{#3}}% } % Typeset the label for a chapter or appendix for the short contents. % The arg is, e.g. `Appendix A' for an appendix, or `3' for a chapter. % We could simplify the code here by writing out an \appendixentry % command in the toc file for appendices, instead of using \chapentry % for both, but it doesn't seem worth it. \setbox0 = \hbox{\shortcontrm Appendix } \newdimen\shortappendixwidth \shortappendixwidth = \wd0 \def\shortchaplabel#1{% % We typeset #1 in a box of constant width, regardless of the text of % #1, so the chapter titles will come out aligned. \setbox0 = \hbox{#1}% \dimen0 = \ifdim\wd0 > \shortappendixwidth \shortappendixwidth \else 0pt \fi % % This space should be plenty, since a single number is .5em, and the % widest letter (M) is 1em, at least in the Computer Modern fonts. % (This space doesn't include the extra space that gets added after % the label; that gets put in in \shortchapentry above.) \advance\dimen0 by 1.1em \hbox to \dimen0{#1\hfil}% } \def\unnumbchapentry#1#2{\dochapentry{#1}{#2}} \def\shortunnumberedentry#1#2{% \def\tempa{}% \def\tempb{#2}% \ifx\tempa\tempb% \tocentry{#1}{}% \else% \tocentry{#1}{\doshortpageno{#2}}% \fi} % Sections. \def\secentry#1#2#3#4{\dosecentry{#2.#3\labelspace#1}{#4}} \def\unnumbsecentry#1#2{\dosecentry{#1}{#2}} % Subsections. \def\subsecentry#1#2#3#4#5{\dosubsecentry{#2.#3.#4\labelspace#1}{#5}} \def\unnumbsubsecentry#1#2{\dosubsecentry{#1}{#2}} % And subsubsections. \def\subsubsecentry#1#2#3#4#5#6{% \dosubsubsecentry{#2.#3.#4.#5\labelspace#1}{#6}} \def\unnumbsubsubsecentry#1#2{\dosubsubsecentry{#1}{#2}} % This parameter controls the indentation of the various levels. \newdimen\tocindent \tocindent = 3pc % Now for the actual typesetting. In all these, #1 is the text and #2 is the % page number. % % If the toc has to be broken over pages, we would want to be at chapters % if at all possible; hence the \penalty. \def\dochapentry#1#2{% \penalty-300 \vskip\baselineskip \begingroup \chapentryfonts \tocentry{#1}{\dopageno{#2}}% \endgroup \nobreak\vskip .25\baselineskip } \def\dosecentry#1#2{\begingroup \secentryfonts \leftskip=\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsecentry#1#2{\begingroup \subsecentryfonts \leftskip=2\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsubsecentry#1#2{\begingroup \subsubsecentryfonts \leftskip=3\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} % Final typesetting of a toc entry; we use the same \entry macro as for % the index entries, but we want to suppress hyphenation here. (We % can't do that in the \entry macro, since index entries might consist % of hyphenated-identifiers-that-do-not-fit-on-a-line-and-nothing-else.) % \def\tocentry#1#2{\begingroup \hyphenpenalty = 10000 \entry{#1}{#2}% \endgroup} % Space between chapter (or whatever) number and the title. \def\labelspace{\hskip1em \relax} \def\dopageno#1{{\rm #1}} \def\doshortpageno#1{{\rm #1}} \def\chapentryfonts{\secfonts \rm} \def\secentryfonts{\textfonts} \let\subsecentryfonts = \textfonts \let\subsubsecentryfonts = \textfonts \message{environments,} % Since these characters are used in examples, it should be an even number of % \tt widths. Each \tt character is 1en, so two makes it 1em. % Furthermore, these definitions must come after we define our fonts. \newbox\dblarrowbox \newbox\longdblarrowbox \newbox\pushcharbox \newbox\bullbox \newbox\equivbox \newbox\errorbox \let\ptexequiv = \equiv %{\tentt %\global\setbox\dblarrowbox = \hbox to 1em{\hfil$\Rightarrow$\hfil} %\global\setbox\longdblarrowbox = \hbox to 1em{\hfil$\mapsto$\hfil} %\global\setbox\pushcharbox = \hbox to 1em{\hfil$\dashv$\hfil} %\global\setbox\equivbox = \hbox to 1em{\hfil$\ptexequiv$\hfil} % Adapted from the manmac format (p.420 of TeXbook) %\global\setbox\bullbox = \hbox to 1em{\kern.15em\vrule height .75ex width .85ex % depth .1ex\hfil} %} \def\point{$\star$} \def\result{\leavevmode\raise.15ex\hbox to 1em{\hfil$\Rightarrow$\hfil}} \def\expansion{\leavevmode\raise.1ex\hbox to 1em{\hfil$\mapsto$\hfil}} \def\print{\leavevmode\lower.1ex\hbox to 1em{\hfil$\dashv$\hfil}} \def\equiv{\leavevmode\lower.1ex\hbox to 1em{\hfil$\ptexequiv$\hfil}} % Adapted from the TeXbook's \boxit. {\tentt \global\dimen0 = 3em}% Width of the box. \dimen2 = .55pt % Thickness of rules % The text. (`r' is open on the right, `e' somewhat less so on the left.) \setbox0 = \hbox{\kern-.75pt \tensf error\kern-1.5pt} \global\setbox\errorbox=\hbox to \dimen0{\hfil \hsize = \dimen0 \advance\hsize by -5.8pt % Space to left+right. \advance\hsize by -2\dimen2 % Rules. \vbox{ \hrule height\dimen2 \hbox{\vrule width\dimen2 \kern3pt % Space to left of text. \vtop{\kern2.4pt \box0 \kern2.4pt}% Space above/below. \kern3pt\vrule width\dimen2}% Space to right. \hrule height\dimen2} \hfil} % The @error{} command. \def\error{\leavevmode\lower.7ex\copy\errorbox} % @tex ... @end tex escapes into raw Tex temporarily. % One exception: @ is still an escape character, so that @end tex works. % But \@ or @@ will get a plain tex @ character. \def\tex{\begingroup \catcode `\\=0 \catcode `\{=1 \catcode `\}=2 \catcode `\$=3 \catcode `\&=4 \catcode `\#=6 \catcode `\^=7 \catcode `\_=8 \catcode `\~=13 \let~=\tie \catcode `\%=14 \catcode 43=12 \catcode`\"=12 \catcode`\==12 \catcode`\|=12 \catcode`\<=12 \catcode`\>=12 \escapechar=`\\ % \let\{=\ptexlbrace \let\}=\ptexrbrace \let\.=\ptexdot \let\*=\ptexstar \let\dots=\ptexdots \def\@{@}% \let\bullet=\ptexbullet \let\b=\ptexb \let\c=\ptexc \let\i=\ptexi \let\t=\ptext \let\l=\ptexl \let\L=\ptexL % \let\Etex=\endgroup} % Define @lisp ... @endlisp. % @lisp does a \begingroup so it can rebind things, % including the definition of @endlisp (which normally is erroneous). % Amount to narrow the margins by for @lisp. \newskip\lispnarrowing \lispnarrowing=0.4in % This is the definition that ^^M gets inside @lisp, @example, and other % such environments. \null is better than a space, since it doesn't % have any width. \def\lisppar{\null\endgraf} % Make each space character in the input produce a normal interword % space in the output. Don't allow a line break at this space, as this % is used only in environments like @example, where each line of input % should produce a line of output anyway. % {\obeyspaces % \gdef\sepspaces{\obeyspaces\let =\tie}} % Define \obeyedspace to be our active space, whatever it is. This is % for use in \parsearg. {\sepspaces % \global\let\obeyedspace= } % This space is always present above and below environments. \newskip\envskipamount \envskipamount = 0pt % Make spacing and below environment symmetrical. We use \parskip here % to help in doing that, since in @example-like environments \parskip % is reset to zero; thus the \afterenvbreak inserts no space -- but the % start of the next paragraph will insert \parskip % \def\aboveenvbreak{{\advance\envskipamount by \parskip \endgraf \ifdim\lastskip<\envskipamount \removelastskip \penalty-50 \vskip\envskipamount \fi}} \let\afterenvbreak = \aboveenvbreak % \nonarrowing is a flag. If "set", @lisp etc don't narrow margins. \let\nonarrowing=\relax %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % \cartouche: draw rectangle w/rounded corners around argument \font\circle=lcircle10 \newdimen\circthick \newdimen\cartouter\newdimen\cartinner \newskip\normbskip\newskip\normpskip\newskip\normlskip \circthick=\fontdimen8\circle % \def\ctl{{\circle\char'013\hskip -6pt}}% 6pt from pl file: 1/2charwidth \def\ctr{{\hskip 6pt\circle\char'010}} \def\cbl{{\circle\char'012\hskip -6pt}} \def\cbr{{\hskip 6pt\circle\char'011}} \def\carttop{\hbox to \cartouter{\hskip\lskip \ctl\leaders\hrule height\circthick\hfil\ctr \hskip\rskip}} \def\cartbot{\hbox to \cartouter{\hskip\lskip \cbl\leaders\hrule height\circthick\hfil\cbr \hskip\rskip}} % \newskip\lskip\newskip\rskip \long\def\cartouche{% \begingroup \lskip=\leftskip \rskip=\rightskip \leftskip=0pt\rightskip=0pt %we want these *outside*. \cartinner=\hsize \advance\cartinner by-\lskip \advance\cartinner by-\rskip \cartouter=\hsize \advance\cartouter by 18pt % allow for 3pt kerns on either % side, and for 6pt waste from % each corner char \normbskip=\baselineskip \normpskip=\parskip \normlskip=\lineskip % Flag to tell @lisp, etc., not to narrow margin. \let\nonarrowing=\comment \vbox\bgroup \baselineskip=0pt\parskip=0pt\lineskip=0pt \carttop \hbox\bgroup \hskip\lskip \vrule\kern3pt \vbox\bgroup \hsize=\cartinner \kern3pt \begingroup \baselineskip=\normbskip \lineskip=\normlskip \parskip=\normpskip \vskip -\parskip \def\Ecartouche{% \endgroup \kern3pt \egroup \kern3pt\vrule \hskip\rskip \egroup \cartbot \egroup \endgroup }} % This macro is called at the beginning of all the @example variants, % inside a group. \def\nonfillstart{% \aboveenvbreak \inENV % This group ends at the end of the body \hfuzz = 12pt % Don't be fussy \sepspaces % Make spaces be word-separators rather than space tokens. \singlespace \let\par = \lisppar % don't ignore blank lines \obeylines % each line of input is a line of output \parskip = 0pt \parindent = 0pt \emergencystretch = 0pt % don't try to avoid overfull boxes % @cartouche defines \nonarrowing to inhibit narrowing % at next level down. \ifx\nonarrowing\relax \advance \leftskip by \lispnarrowing \exdentamount=\lispnarrowing \let\exdent=\nofillexdent \let\nonarrowing=\relax \fi } % To ending an @example-like environment, we first end the paragraph % (via \afterenvbreak's vertical glue), and then the group. That way we % keep the zero \parskip that the environments set -- \parskip glue % will be inserted at the beginning of the next paragraph in the % document, after the environment. % \def\nonfillfinish{\afterenvbreak\endgroup}% % This macro is \def\lisp{\begingroup \nonfillstart \let\Elisp = \nonfillfinish \tt \rawbackslash % have \ input char produce \ char from current font \gobble } % Define the \E... control sequence only if we are inside the % environment, so the error checking in \end will work. % % We must call \lisp last in the definition, since it reads the % return following the @example (or whatever) command. % \def\example{\begingroup \def\Eexample{\nonfillfinish\endgroup}\lisp} \def\smallexample{\begingroup \def\Esmallexample{\nonfillfinish\endgroup}\lisp} \def\smalllisp{\begingroup \def\Esmalllisp{\nonfillfinish\endgroup}\lisp} % @smallexample and @smalllisp. This is not used unless the @smallbook % command is given. Originally contributed by Pavel@xerox. % \def\smalllispx{\begingroup \nonfillstart \let\Esmalllisp = \nonfillfinish \let\Esmallexample = \nonfillfinish % % Smaller interline space and fonts for small examples. \baselineskip 10pt \indexfonts \tt \rawbackslash % output the \ character from the current font \gobble } % This is @display; same as @lisp except use roman font. % \def\display{\begingroup \nonfillstart \let\Edisplay = \nonfillfinish \gobble } % This is @format; same as @display except don't narrow margins. % \def\format{\begingroup \let\nonarrowing = t \nonfillstart \let\Eformat = \nonfillfinish \gobble } % @flushleft (same as @format) and @flushright. % \def\flushleft{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushleft = \nonfillfinish \gobble } \def\flushright{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushright = \nonfillfinish \advance\leftskip by 0pt plus 1fill \gobble} % @quotation does normal linebreaking and narrows the margins. % \def\quotation{% \begingroup\inENV %This group ends at the end of the @quotation body {\parskip=0pt % because we will skip by \parskip too, later \aboveenvbreak}% \singlespace \parindent=0pt \let\Equotation = \nonfillfinish % @cartouche defines \nonarrowing to inhibit narrowing % at next level down. \ifx\nonarrowing\relax \advance \leftskip by \lispnarrowing \advance \rightskip by \lispnarrowing \exdentamount=\lispnarrowing \let\nonarrowing=\relax \fi} \message{defuns,} % Define formatter for defuns % First, allow user to change definition object font (\df) internally \def\setdeffont #1 {\csname DEF#1\endcsname} \newskip\defbodyindent \defbodyindent=.4in \newskip\defargsindent \defargsindent=50pt \newskip\deftypemargin \deftypemargin=12pt \newskip\deflastargmargin \deflastargmargin=18pt \newcount\parencount % define \functionparens, which makes ( and ) and & do special things. % \functionparens affects the group it is contained in. \def\activeparens{% \catcode`\(=\active \catcode`\)=\active \catcode`\&=\active \catcode`\[=\active \catcode`\]=\active} % Make control sequences which act like normal parenthesis chars. \let\lparen = ( \let\rparen = ) {\activeparens % Now, smart parens don't turn on until &foo (see \amprm) % Be sure that we always have a definition for `(', etc. For example, % if the fn name has parens in it, \boldbrax will not be in effect yet, % so TeX would otherwise complain about undefined control sequence. \global\let(=\lparen \global\let)=\rparen \global\let[=\lbrack \global\let]=\rbrack \gdef\functionparens{\boldbrax\let&=\amprm\parencount=0 } \gdef\boldbrax{\let(=\opnr\let)=\clnr\let[=\lbrb\let]=\rbrb} % Definitions of (, ) and & used in args for functions. % This is the definition of ( outside of all parentheses. \gdef\oprm#1 {{\rm\char`\(}#1 \bf \let(=\opnested % \global\advance\parencount by 1 } % % This is the definition of ( when already inside a level of parens. \gdef\opnested{\char`\(\global\advance\parencount by 1 } % \gdef\clrm{% Print a paren in roman if it is taking us back to depth of 0. % also in that case restore the outer-level definition of (. \ifnum \parencount=1 {\rm \char `\)}\sl \let(=\oprm \else \char `\) \fi \global\advance \parencount by -1 } % If we encounter &foo, then turn on ()-hacking afterwards \gdef\amprm#1 {{\rm\}\let(=\oprm \let)=\clrm\ } % \gdef\normalparens{\boldbrax\let&=\ampnr} } % End of definition inside \activeparens %% These parens (in \boldbrax) actually are a little bolder than the %% contained text. This is especially needed for [ and ] \def\opnr{{\sf\char`\(}} \def\clnr{{\sf\char`\)}} \def\ampnr{\&} \def\lbrb{{\bf\char`\[}} \def\rbrb{{\bf\char`\]}} % First, defname, which formats the header line itself. % #1 should be the function name. % #2 should be the type of definition, such as "Function". \def\defname #1#2{% % Get the values of \leftskip and \rightskip as they were % outside the @def... \dimen2=\leftskip \advance\dimen2 by -\defbodyindent \dimen3=\rightskip \advance\dimen3 by -\defbodyindent \noindent % \setbox0=\hbox{\hskip \deflastargmargin{\rm #2}\hskip \deftypemargin}% \dimen0=\hsize \advance \dimen0 by -\wd0 % compute size for first line \dimen1=\hsize \advance \dimen1 by -\defargsindent %size for continuations \parshape 2 0in \dimen0 \defargsindent \dimen1 % % Now output arg 2 ("Function" or some such) % ending at \deftypemargin from the right margin, % but stuck inside a box of width 0 so it does not interfere with linebreaking {% Adjust \hsize to exclude the ambient margins, % so that \rightline will obey them. \advance \hsize by -\dimen2 \advance \hsize by -\dimen3 \rlap{\rightline{{\rm #2}\hskip \deftypemargin}}}% % Make all lines underfull and no complaints: \tolerance=10000 \hbadness=10000 \advance\leftskip by -\defbodyindent \exdentamount=\defbodyindent {\df #1}\enskip % Generate function name } % Actually process the body of a definition % #1 should be the terminating control sequence, such as \Edefun. % #2 should be the "another name" control sequence, such as \defunx. % #3 should be the control sequence that actually processes the header, % such as \defunheader. \def\defparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\activeparens\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % 61 is `=' \obeylines\activeparens\spacesplit#3} \def\defmethparsebody #1#2#3#4 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\activeparens\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#4}}} \def\defopparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\activeparens\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#5}}} % These parsing functions are similar to the preceding ones % except that they do not make parens into active characters. % These are used for "variables" since they have no arguments. \def\defvarparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % \obeylines\spacesplit#3} % This is used for \def{tp,vr}parsebody. It could probably be used for % some of the others, too, with some judicious conditionals. % \def\parsebodycommon#1#2#3{% \begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines } \def\defvrparsebody#1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{#3{#4}}% } % This loses on `@deftp {Data Type} {struct termios}' -- it thinks the % type is just `struct', because we lose the braces in `{struct % termios}' when \spacesplit reads its undelimited argument. Sigh. % \let\deftpparsebody=\defvrparsebody % % So, to get around this, we put \empty in with the type name. That % way, TeX won't find exactly `{...}' as an undelimited argument, and % won't strip off the braces. % \def\deftpparsebody #1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{\parsetpheaderline{#3{#4}}}\empty } % Fine, but then we have to eventually remove the \empty *and* the % braces (if any). That's what this does, putting the result in \tptemp. % \def\removeemptybraces\empty#1\relax{\def\tptemp{#1}}% % After \spacesplit has done its work, this is called -- #1 is the final % thing to call, #2 the type name (which starts with \empty), and #3 % (which might be empty) the arguments. % \def\parsetpheaderline#1#2#3{% \removeemptybraces#2\relax #1{\tptemp}{#3}% }% \def\defopvarparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\spacesplit{#3{#5}}} % Split up #2 at the first space token. % call #1 with two arguments: % the first is all of #2 before the space token, % the second is all of #2 after that space token. % If #2 contains no space token, all of it is passed as the first arg % and the second is passed as empty. {\obeylines \gdef\spacesplit#1#2^^M{\endgroup\spacesplitfoo{#1}#2 \relax\spacesplitfoo}% \long\gdef\spacesplitfoo#1#2 #3#4\spacesplitfoo{% \ifx\relax #3% #1{#2}{}\else #1{#2}{#3#4}\fi}} % So much for the things common to all kinds of definitions. % Define @defun. % First, define the processing that is wanted for arguments of \defun % Use this to expand the args and terminate the paragraph they make up \def\defunargs #1{\functionparens \sl % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. \hyphenchar\tensl=0 #1% \hyphenchar\tensl=45 \ifnum\parencount=0 \else \errmessage{unbalanced parens in @def arguments}\fi% \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } \def\deftypefunargs #1{% % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. \functionparens \code{#1}% \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } % Do complete processing of one @defun or @defunx line already parsed. % @deffn Command forward-char nchars \def\deffn{\defmethparsebody\Edeffn\deffnx\deffnheader} \def\deffnheader #1#2#3{\doind {fn}{\code{#2}}% \begingroup\defname {#2}{#1}\defunargs{#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defun == @deffn Function \def\defun{\defparsebody\Edefun\defunx\defunheader} \def\defunheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Function}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefun int foobar (int @var{foo}, float @var{bar}) \def\deftypefun{\defparsebody\Edeftypefun\deftypefunx\deftypefunheader} % #1 is the data type. #2 is the name and args. \def\deftypefunheader #1#2{\deftypefunheaderx{#1}#2 \relax} % #1 is the data type, #2 the name, #3 the args. \def\deftypefunheaderx #1#2 #3\relax{% \doind {fn}{\code{#2}}% Make entry in function index \begingroup\defname {\code{#1} #2}{Function}% \deftypefunargs {#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefn {Library Function} int foobar (int @var{foo}, float @var{bar}) \def\deftypefn{\defmethparsebody\Edeftypefn\deftypefnx\deftypefnheader} % #1 is the classification. #2 is the data type. #3 is the name and args. \def\deftypefnheader #1#2#3{\deftypefnheaderx{#1}{#2}#3 \relax} % #1 is the classification, #2 the data type, #3 the name, #4 the args. \def\deftypefnheaderx #1#2#3 #4\relax{% \doind {fn}{\code{#3}}% Make entry in function index \begingroup \normalparens % notably, turn off `&' magic, which prevents % at least some C++ text from working \defname {\code{#2} #3}{#1}% \deftypefunargs {#4}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defmac == @deffn Macro \def\defmac{\defparsebody\Edefmac\defmacx\defmacheader} \def\defmacheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Macro}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defspec == @deffn Special Form \def\defspec{\defparsebody\Edefspec\defspecx\defspecheader} \def\defspecheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Special Form}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % This definition is run if you use @defunx % anywhere other than immediately after a @defun or @defunx. \def\deffnx #1 {\errmessage{@deffnx in invalid context}} \def\defunx #1 {\errmessage{@defunx in invalid context}} \def\defmacx #1 {\errmessage{@defmacx in invalid context}} \def\defspecx #1 {\errmessage{@defspecx in invalid context}} \def\deftypefnx #1 {\errmessage{@deftypefnx in invalid context}} \def\deftypeunx #1 {\errmessage{@deftypeunx in invalid context}} % @defmethod, and so on % @defop {Funny Method} foo-class frobnicate argument \def\defop #1 {\def\defoptype{#1}% \defopparsebody\Edefop\defopx\defopheader\defoptype} \def\defopheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% Make entry in function index \begingroup\defname {#2}{\defoptype{} on #1}% \defunargs {#3}\endgroup % } % @defmethod == @defop Method \def\defmethod{\defmethparsebody\Edefmethod\defmethodx\defmethodheader} \def\defmethodheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% entry in function index \begingroup\defname {#2}{Method on #1}% \defunargs {#3}\endgroup % } % @defcv {Class Option} foo-class foo-flag \def\defcv #1 {\def\defcvtype{#1}% \defopvarparsebody\Edefcv\defcvx\defcvarheader\defcvtype} \def\defcvarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{\defcvtype{} of #1}% \defvarargs {#3}\endgroup % } % @defivar == @defcv {Instance Variable} \def\defivar{\defvrparsebody\Edefivar\defivarx\defivarheader} \def\defivarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{Instance Variable of #1}% \defvarargs {#3}\endgroup % } % These definitions are run if you use @defmethodx, etc., % anywhere other than immediately after a @defmethod, etc. \def\defopx #1 {\errmessage{@defopx in invalid context}} \def\defmethodx #1 {\errmessage{@defmethodx in invalid context}} \def\defcvx #1 {\errmessage{@defcvx in invalid context}} \def\defivarx #1 {\errmessage{@defivarx in invalid context}} % Now @defvar % First, define the processing that is wanted for arguments of @defvar. % This is actually simple: just print them in roman. % This must expand the args and terminate the paragraph they make up \def\defvarargs #1{\normalparens #1% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000} % @defvr Counter foo-count \def\defvr{\defvrparsebody\Edefvr\defvrx\defvrheader} \def\defvrheader #1#2#3{\doind {vr}{\code{#2}}% \begingroup\defname {#2}{#1}\defvarargs{#3}\endgroup} % @defvar == @defvr Variable \def\defvar{\defvarparsebody\Edefvar\defvarx\defvarheader} \def\defvarheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{Variable}% \defvarargs {#2}\endgroup % } % @defopt == @defvr {User Option} \def\defopt{\defvarparsebody\Edefopt\defoptx\defoptheader} \def\defoptheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{User Option}% \defvarargs {#2}\endgroup % } % @deftypevar int foobar \def\deftypevar{\defvarparsebody\Edeftypevar\deftypevarx\deftypevarheader} % #1 is the data type. #2 is the name. \def\deftypevarheader #1#2{% \doind {vr}{\code{#2}}% Make entry in variables index \begingroup\defname {\code{#1} #2}{Variable}% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} % @deftypevr {Global Flag} int enable \def\deftypevr{\defvrparsebody\Edeftypevr\deftypevrx\deftypevrheader} \def\deftypevrheader #1#2#3{\doind {vr}{\code{#3}}% \begingroup\defname {\code{#2} #3}{#1} \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} % This definition is run if you use @defvarx % anywhere other than immediately after a @defvar or @defvarx. \def\defvrx #1 {\errmessage{@defvrx in invalid context}} \def\defvarx #1 {\errmessage{@defvarx in invalid context}} \def\defoptx #1 {\errmessage{@defoptx in invalid context}} \def\deftypevarx #1 {\errmessage{@deftypevarx in invalid context}} \def\deftypevrx #1 {\errmessage{@deftypevrx in invalid context}} % Now define @deftp % Args are printed in bold, a slight difference from @defvar. \def\deftpargs #1{\bf \defvarargs{#1}} % @deftp Class window height width ... \def\deftp{\deftpparsebody\Edeftp\deftpx\deftpheader} \def\deftpheader #1#2#3{\doind {tp}{\code{#2}}% \begingroup\defname {#2}{#1}\deftpargs{#3}\endgroup} % This definition is run if you use @deftpx, etc % anywhere other than immediately after a @deftp, etc. \def\deftpx #1 {\errmessage{@deftpx in invalid context}} \message{cross reference,} % Define cross-reference macros \newwrite \auxfile \newif\ifhavexrefs % True if xref values are known. \newif\ifwarnedxrefs % True if we warned once that they aren't known. % \setref{foo} defines a cross-reference point named foo. \def\setref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ysectionnumberandtype}} \def\unnumbsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ynothing}} \def\appendixsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Yappendixletterandtype}} % \xref, \pxref, and \ref generate cross-references to specified points. % For \xrefX, #1 is the node name, #2 the name of the Info % cross-reference, #3 the printed node name, #4 the name of the Info % file, #5 the name of the printed manual. All but the node name can be % omitted. % \def\pxref#1{see \xrefX[#1,,,,,,,]} \def\xref#1{See \xrefX[#1,,,,,,,]} \def\ref#1{\xrefX[#1,,,,,,,]} \def\xrefX[#1,#2,#3,#4,#5,#6]{\begingroup% \def\printedmanual{\ignorespaces #5}% \def\printednodename{\ignorespaces #3}% % \setbox1=\hbox{\printedmanual}% \setbox0=\hbox{\printednodename}% \ifdim \wd0=0pt% % No printed node name was explicitly given. \ifx SETxref-automatic-section-title % % This line should make the actual chapter or section title appear inside % the square brackets. Use the real section title if we have it. \ifdim \wd1>0pt% % It is in another manual, so we don't have it. \def\printednodename{\ignorespaces #1} \else% % We know the real title if we have the xref values. \ifhavexrefs \def\printednodename{\refx{#1-title}}% % Otherwise just copy the Info node name. \else \def\printednodename{\ignorespaces #1} \fi% \fi\def\printednodename{#1-title}% \else% This line just uses the node name. \def\printednodename{\ignorespaces #1}% \fi% ends \ifx SETxref-automatic-section-title \fi% ends \ifdim \wd0 % % % If we use \unhbox0 and \unhbox1 to print the node names, TeX does % not insert empty discretionaries after hyphens, which means that it % will not find a line break at a hyphen in a node names. Since some % manuals are best written with fairly long node names, containing % hyphens, this is a loss. Therefore, we simply give the text of % the node name again, so it is as if TeX is seeing it for the first % time. \ifdim \wd1>0pt section ``\printednodename'' in \cite{\printedmanual}% \else% \turnoffactive% \refx{#1-snt}{} [\printednodename], page\tie\refx{#1-pg}{}% \fi \endgroup} % \dosetq is the interface for calls from other macros % Use \turnoffactive so that punctuation chars such as underscore % work in node names. \def\dosetq #1#2{{\let\folio=0 \turnoffactive% \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}% \next}} % \internalsetq {foo}{page} expands into % CHARACTERS 'xrdef {foo}{...expansion of \Ypage...} % When the aux file is read, ' is the escape character \def\internalsetq #1#2{'xrdef {#1}{\csname #2\endcsname}} % Things to be expanded by \internalsetq \def\Ypagenumber{\folio} \def\Ytitle{\thissection} \def\Ynothing{} \def\Ysectionnumberandtype{% \ifnum\secno=0 Chapter\xreftie\the\chapno % \else \ifnum \subsecno=0 Section\xreftie\the\chapno.\the\secno % \else \ifnum \subsubsecno=0 % Section\xreftie\the\chapno.\the\secno.\the\subsecno % \else % Section\xreftie\the\chapno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \def\Yappendixletterandtype{% \ifnum\secno=0 Appendix\xreftie'char\the\appendixno{}% \else \ifnum \subsecno=0 Section\xreftie'char\the\appendixno.\the\secno % \else \ifnum \subsubsecno=0 % Section\xreftie'char\the\appendixno.\the\secno.\the\subsecno % \else % Section\xreftie'char\the\appendixno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \gdef\xreftie{'tie} % Use TeX 3.0's \inputlineno to get the line number, for better error % messages, but if we're using an old version of TeX, don't do anything. % \ifx\inputlineno\thisisundefined \let\linenumber = \empty % Non-3.0. \else \def\linenumber{\the\inputlineno:\space} \fi % Define \refx{NAME}{SUFFIX} to reference a cross-reference string named NAME. % If its value is nonempty, SUFFIX is output afterward. \def\refx#1#2{% \expandafter\ifx\csname X#1\endcsname\relax % If not defined, say something at least. $\langle$un\-de\-fined$\rangle$% \ifhavexrefs \message{\linenumber Undefined cross reference `#1'.}% \else \ifwarnedxrefs\else \global\warnedxrefstrue \message{Cross reference values unknown; you must run TeX again.}% \fi \fi \else % It's defined, so just use it. \csname X#1\endcsname \fi #2% Output the suffix in any case. } % Read the last existing aux file, if any. No error if none exists. % This is the macro invoked by entries in the aux file. \def\xrdef #1#2{ {\catcode`\'=\other\expandafter \gdef \csname X#1\endcsname {#2}}} \def\readauxfile{% \begingroup \catcode `\^^@=\other \catcode `\=\other \catcode `\=\other \catcode `\^^C=\other \catcode `\^^D=\other \catcode `\^^E=\other \catcode `\^^F=\other \catcode `\^^G=\other \catcode `\^^H=\other \catcode `\ =\other \catcode `\^^L=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode 26=\other \catcode `\^^[=\other \catcode `\^^\=\other \catcode `\^^]=\other \catcode `\^^^=\other \catcode `\^^_=\other \catcode `\@=\other \catcode `\^=\other \catcode `\~=\other \catcode `\[=\other \catcode `\]=\other \catcode`\"=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode `\$=\other \catcode `\#=\other \catcode `\&=\other % `\+ does not work, so use 43. \catcode 43=\other % the aux file uses ' as the escape. % Turn off \ as an escape so we do not lose on % entries which were dumped with control sequences in their names. % For example, 'xrdef {$\leq $-fun}{page ...} made by @defun ^^ % Reference to such entries still does not work the way one would wish, % but at least they do not bomb out when the aux file is read in. \catcode `\{=1 \catcode `\}=2 \catcode `\%=\other \catcode `\'=0 \catcode `\\=\other \openin 1 \jobname.aux \ifeof 1 \else \closein 1 \input \jobname.aux \global\havexrefstrue \global\warnedobstrue \fi % Open the new aux file. Tex will close it automatically at exit. \openout \auxfile=\jobname.aux \endgroup} % Footnotes. \newcount \footnoteno % The trailing space in the following definition for supereject is % vital for proper filling; pages come out unaligned when you do a % pagealignmacro call if that space before the closing brace is % removed. \def\supereject{\par\penalty -20000\footnoteno =0 } % @footnotestyle is meaningful for info output only.. \let\footnotestyle=\comment \let\ptexfootnote=\footnote {\catcode `\@=11 % % Auto-number footnotes. Otherwise like plain. \gdef\footnote{% \global\advance\footnoteno by \@ne \edef\thisfootno{$^{\the\footnoteno}$}% % % In case the footnote comes at the end of a sentence, preserve the % extra spacing after we do the footnote number. \let\@sf\empty \ifhmode\edef\@sf{\spacefactor\the\spacefactor}\/\fi % % Remove inadvertent blank space before typesetting the footnote number. \unskip \thisfootno\@sf \footnotezzz }% % Don't bother with the trickery in plain.tex to not require the % footnote text as a parameter. Our footnotes don't need to be so general. % \long\gdef\footnotezzz#1{\insert\footins{% % We want to typeset this text as a normal paragraph, even if the % footnote reference occurs in (for example) a display environment. % So reset some parameters. \interlinepenalty\interfootnotelinepenalty \splittopskip\ht\strutbox % top baseline for broken footnotes \splitmaxdepth\dp\strutbox \floatingpenalty\@MM \leftskip\z@skip \rightskip\z@skip \spaceskip\z@skip \xspaceskip\z@skip \parindent\defaultparindent % % Hang the footnote text off the number. \hang \textindent{\thisfootno}% % % Don't crash into the line above the footnote text. Since this % expands into a box, it must come within the paragraph, lest it % provide a place where TeX can split the footnote. \footstrut #1\strut}% } }%end \catcode `\@=11 % Set the baselineskip to #1, and the lineskip and strut size % correspondingly. There is no deep meaning behind these magic numbers % used as factors; they just match (closely enough) what Knuth defined. % \def\lineskipfactor{.08333} \def\strutheightpercent{.70833} \def\strutdepthpercent {.29167} % \def\setleading#1{% \normalbaselineskip = #1\relax \normallineskip = \lineskipfactor\normalbaselineskip \normalbaselines \setbox\strutbox =\hbox{% \vrule width0pt height\strutheightpercent\baselineskip depth \strutdepthpercent \baselineskip }% } % @| inserts a changebar to the left of the current line. It should % surround any changed text. This approach does *not* work if the % change spans more than two lines of output. To handle that, we would % have adopt a much more difficult approach (putting marks into the main % vertical list for the beginning and end of each change). % \def\|{% % \vadjust can only be used in horizontal mode. \leavevmode % % Append this vertical mode material after the current line in the output. \vadjust{% % We want to insert a rule with the height and depth of the current % leading; that is exactly what \strutbox is supposed to record. \vskip-\baselineskip % % \vadjust-items are inserted at the left edge of the type. So % the \llap here moves out into the left-hand margin. \llap{% % % For a thicker or thinner bar, change the `1pt'. \vrule height\baselineskip width1pt % % This is the space between the bar and the text. \hskip 12pt }% }% } % For a final copy, take out the rectangles % that mark overfull boxes (in case you have decided % that the text looks ok even though it passes the margin). % \def\finalout{\overfullrule=0pt} % End of control word definitions. \message{and turning on texinfo input format.} \def\openindices{% \newindex{cp}% \newcodeindex{fn}% \newcodeindex{vr}% \newcodeindex{tp}% \newcodeindex{ky}% \newcodeindex{pg}% } % Set some numeric style parameters, for 8.5 x 11 format. %\hsize = 6.5in \newdimen\defaultparindent \defaultparindent = 15pt \parindent = \defaultparindent \parskip 18pt plus 1pt \setleading{15pt} \advance\topskip by 1.2cm % Prevent underfull vbox error messages. \vbadness=10000 % Following George Bush, just get rid of widows and orphans. \widowpenalty=10000 \clubpenalty=10000 % Use TeX 3.0's \emergencystretch to help line breaking, but if we're % using an old version of TeX, don't do anything. We want the amount of % stretch added to depend on the line length, hence the dependence on % \hsize. This makes it come to about 9pt for the 8.5x11 format. % \ifx\emergencystretch\thisisundefined % Allow us to assign to \emergencystretch anyway. \def\emergencystretch{\dimen0}% \else \emergencystretch = \hsize \divide\emergencystretch by 45 \fi % Use @smallbook to reset parameters for 7x9.5 format (or else 7x9.25) \def\smallbook{ % These values for secheadingskip and subsecheadingskip are % experiments. RJC 7 Aug 1992 \global\secheadingskip = 17pt plus 6pt minus 3pt \global\subsecheadingskip = 14pt plus 6pt minus 3pt \global\lispnarrowing = 0.3in \setleading{12pt} \advance\topskip by -1cm \global\parskip 3pt plus 1pt \global\hsize = 5in \global\vsize=7.5in \global\tolerance=700 \global\hfuzz=1pt \global\contentsrightmargin=0pt \global\pagewidth=\hsize \global\pageheight=\vsize \global\let\smalllisp=\smalllispx \global\let\smallexample=\smalllispx \global\def\Esmallexample{\Esmalllisp} } % Use @afourpaper to print on European A4 paper. \def\afourpaper{ \global\tolerance=700 \global\hfuzz=1pt \setleading{12pt} \global\parskip 15pt plus 1pt \global\vsize= 53\baselineskip \advance\vsize by \topskip %\global\hsize= 5.85in % A4 wide 10pt \global\hsize= 6.5in \global\outerhsize=\hsize \global\advance\outerhsize by 0.5in \global\outervsize=\vsize \global\advance\outervsize by 0.6in \global\pagewidth=\hsize \global\pageheight=\vsize } % Define macros to output various characters with catcode for normal text. \catcode`\"=\other \catcode`\~=\other \catcode`\^=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode`\+=\other \def\normaldoublequote{"} \def\normaltilde{~} \def\normalcaret{^} \def\normalunderscore{_} \def\normalverticalbar{|} \def\normalless{<} \def\normalgreater{>} \def\normalplus{+} % This macro is used to make a character print one way in ttfont % where it can probably just be output, and another way in other fonts, % where something hairier probably needs to be done. % % #1 is what to print if we are indeed using \tt; #2 is what to print % otherwise. Since all the Computer Modern typewriter fonts have zero % interword stretch (and shrink), and it is reasonable to expect all % typewriter fonts to have this, we can check that font parameter. % \def\ifusingtt#1#2{\ifdim \fontdimen3\the\font=0pt #1\else #2\fi} % Turn off all special characters except @ % (and those which the user can use as if they were ordinary). % Most of these we simply print from the \tt font, but for some, we can % use math or other variants that look better in normal text. \catcode`\"=\active \def\activedoublequote{{\tt \char '042}} \let"=\activedoublequote \catcode`\~=\active \def~{{\tt \char '176}} \chardef\hat=`\^ \catcode`\^=\active \def^{{\tt \hat}} \catcode`\_=\active \def_{\ifusingtt\normalunderscore\_} % Subroutine for the previous macro. \def\_{\lvvmode \kern.06em \vbox{\hrule width.3em height.1ex}} % \lvvmode is equivalent in function to \leavevmode. % Using \leavevmode runs into trouble when written out to % an index file due to the expansion of \leavevmode into ``\unhbox % \voidb@x'' ---which looks to TeX like ``\unhbox \voidb\x'' due to our % magic tricks with @. \def\lvvmode{\vbox to 0pt{}} \catcode`\|=\active \def|{{\tt \char '174}} \chardef \less=`\< \catcode`\<=\active \def<{{\tt \less}} \chardef \gtr=`\> \catcode`\>=\active \def>{{\tt \gtr}} \catcode`\+=\active \def+{{\tt \char 43}} %\catcode 27=\active %\def^^[{$\diamondsuit$} % Used sometimes to turn off (effectively) the active characters % even after parsing them. \def\turnoffactive{\let"=\normaldoublequote \let~=\normaltilde \let^=\normalcaret \let_=\normalunderscore \let|=\normalverticalbar \let<=\normalless \let>=\normalgreater \let+=\normalplus} % Set up an active definition for =, but don't enable it most of the time. {\catcode`\==\active \global\def={{\tt \char 61}}} \catcode`\@=0 % \rawbackslashxx output one backslash character in current font \global\chardef\rawbackslashxx=`\\ %{\catcode`\\=\other %@gdef@rawbackslashxx{\}} % \rawbackslash redefines \ as input to do \rawbackslashxx. {\catcode`\\=\active @gdef@rawbackslash{@let\=@rawbackslashxx }} % \normalbackslash outputs one backslash in fixed width font. \def\normalbackslash{{\tt\rawbackslashxx}} % Say @foo, not \foo, in error messages. \escapechar=`\@ % \catcode 17=0 % Define control-q \catcode`\\=\active % If a .fmt file is being used, we don't want the `\input texinfo' to show up. % That is what \eatinput is for; after that, the `\' should revert to printing % a backslash. % @gdef@eatinput input texinfo{@fixbackslash} @global@let\ = @eatinput % On the other hand, perhaps the file did not have a `\input texinfo'. Then % the first `\{ in the file would cause an error. This macro tries to fix % that, assuming it is called before the first `\' could plausibly occur. % @gdef@fixbackslash{@ifx\@eatinput @let\ = @normalbackslash @fi} %% These look ok in all fonts, so just make them not special. The @rm below %% makes sure that the current font starts out as the newly loaded cmr10 @catcode`@$=@other @catcode`@%=@other @catcode`@&=@other @catcode`@#=@other @textfonts @rm @c Local variables: @c page-delimiter: "^\\\\message" @c End: diffutils-2.4/mkinstalldirs100777 21570 13 1153 5432727042 14173 0ustar djmuser#!/bin/sh # Make directory hierarchy. # Written by Noah Friedman # Public domain. defaultIFS=' ' IFS="${IFS-${defaultIFS}}" errstatus=0 for file in ${1+"$@"} ; do oIFS="${IFS}" # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo ${file} | sed -e 's@/@%@g' -e 's@^%@/@'` IFS="${oIFS}" pathcomp='' for d in ${1+"$@"} ; do pathcomp="${pathcomp}${d}" if test ! -d "${pathcomp}"; then echo "mkdir $pathcomp" 1>&2 mkdir "${pathcomp}" || errstatus=$? fi pathcomp="${pathcomp}/" done done exit $errstatus # eof diffutils-2.4/fnmatch.c100666 74720 1 11416 5432540375 14150 0ustar eggertdaemon/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS) extern int errno; #endif /* Match STRING against the filename pattern PATTERN, returning zero if it matches, nonzero if not. */ int fnmatch (pattern, string, flags) const char *pattern; const char *string; int flags; { register const char *p = pattern, *n = string; register char c; /* Note that this evalutes C many times. */ #define FOLD(c) ((flags & FNM_CASEFOLD) && isupper (c) ? tolower (c) : (c)) while ((c = *p++) != '\0') { c = FOLD (c); switch (c) { case '?': if (*n == '\0') return FNM_NOMATCH; else if ((flags & FNM_FILE_NAME) && *n == '/') return FNM_NOMATCH; else if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; break; case '\\': if (!(flags & FNM_NOESCAPE)) { c = *p++; c = FOLD (c); } if (FOLD (*n) != c) return FNM_NOMATCH; break; case '*': if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; for (c = *p++; c == '?' || c == '*'; c = *p++, ++n) if (((flags & FNM_FILE_NAME) && *n == '/') || (c == '?' && *n == '\0')) return FNM_NOMATCH; if (c == '\0') return 0; { char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c; c1 = FOLD (c1); for (--p; *n != '\0'; ++n) if ((c == '[' || FOLD (*n) == c1) && fnmatch (p, n, flags & ~FNM_PERIOD) == 0) return 0; return FNM_NOMATCH; } case '[': { /* Nonzero if the sense of the character class is inverted. */ register int not; if (*n == '\0') return FNM_NOMATCH; if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; not = (*p == '!' || *p == '^'); if (not) ++p; c = *p++; for (;;) { register char cstart = c, cend = c; if (!(flags & FNM_NOESCAPE) && c == '\\') cstart = cend = *p++; cstart = cend = FOLD (cstart); if (c == '\0') /* [ (unterminated) loses. */ return FNM_NOMATCH; c = *p++; c = FOLD (c); if ((flags & FNM_FILE_NAME) && c == '/') /* [/] can never match. */ return FNM_NOMATCH; if (c == '-' && *p != ']') { cend = *p++; if (!(flags & FNM_NOESCAPE) && cend == '\\') cend = *p++; if (cend == '\0') return FNM_NOMATCH; cend = FOLD (cend); c = *p++; } if (FOLD (*n) >= cstart && FOLD (*n) <= cend) goto matched; if (c == ']') break; } if (!not) return FNM_NOMATCH; break; matched:; /* Skip the rest of the [...] that already matched. */ while (c != ']') { if (c == '\0') /* [... (unterminated) loses. */ return FNM_NOMATCH; c = *p++; if (!(flags & FNM_NOESCAPE) && c == '\\') /* XXX 1003.2d11 is unclear if this is right. */ ++p; } if (not) return FNM_NOMATCH; } break; default: if (c != FOLD (*n)) return FNM_NOMATCH; } ++n; } if (*n == '\0') return 0; if ((flags & FNM_LEADING_DIR) && *n == '/') /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ return 0; return FNM_NOMATCH; } #endif /* _LIBC or not __GNU_LIBRARY__. */ diffutils-2.4/fnmatch.h100666 74720 1 4156 5362120650 14130 0ustar eggertdaemon/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _FNMATCH_H #define _FNMATCH_H 1 #ifdef __cplusplus extern "C" { #endif #if defined (__cplusplus) || (defined (__STDC__) && __STDC__) #undef __P #define __P(args) args #else /* Not C++ or ANSI C. */ #undef __P #define __P(args) () /* We can get away without defining `const' here only because in this file it is used only inside the prototype for `fnmatch', which is elided in non-ANSI C where `const' is problematical. */ #endif /* C++ or ANSI C. */ /* Bits set in the FLAGS argument to `fnmatch'. */ #define FNM_PATHNAME (1 << 0) /* No wildcard can ever match `/'. */ #define FNM_NOESCAPE (1 << 1) /* Backslashes don't quote special chars. */ #define FNM_PERIOD (1 << 2) /* Leading `.' is matched only explicitly. */ #if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_GNU_SOURCE) #define FNM_FILE_NAME FNM_PATHNAME /* Preferred GNU name. */ #define FNM_LEADING_DIR (1 << 3) /* Ignore `/...' after a match. */ #define FNM_CASEFOLD (1 << 4) /* Compare without regard to case. */ #endif /* Value returned by `fnmatch' if STRING does not match PATTERN. */ #define FNM_NOMATCH 1 /* Match STRING against the filename pattern PATTERN, returning zero if it matches, FNM_NOMATCH if not. */ extern int fnmatch __P ((const char *__pattern, const char *__string, int __flags)); #ifdef __cplusplus } #endif #endif /* fnmatch.h */