diff.c

Go to the documentation of this file.

/* diff  - print differences between 2 files      Author: Erik Baalbergen */

/* Poor man's implementation of diff(1)         - no options available
*       - may give more output than other diffs,
*         due to the straight-forward algorithm
*       - runs out of memory if the differing chunks become too large
*       - input line length should not exceed LINELEN; longer lines are
*         truncated, while only the first LINELEN characters are compared
*
*       - Bug fixes by Rick Thomas Sept. 1989
*
* Please report bugs and suggestions to erikb@cs.vu.nl
*------------------------------------------------------------------------------
* Changed diff to conform to POSIX 1003.2 ( Draft 11) by Thomas Brupbacher
* ( tobr@mw.lpc.ethz.ch).
*
* To incorporate the context diff option -c in the program, the source code
* for the program cdiff has been copied to the end of this program. Only
* slight modifications for the cdiff code to work within the program diff
* were made( e.g. main() -> context_diff()).
*
* New options:
* -c, -C n where n=0,1,...:
*       produces a context diff as the program cdiff. The default is to
*       print 3 lines of context, this value can be changed with -C
*       ( e.g. -C 5 prints five lines of context.)
* -e :  Prints an ed script, so you can convert <file1> to <file2> with
*       the command ed <file1> < `diff -e <file1> <file2>`.
* -b :  Causes trailing blanks to be ignored and spaces of multiple blanks
*       to be reduced to one blank before comparison.
*-----------------------------------------------------------------------------
*/

#include <errno.h>
#include <stdlib.h>
#include <limits.h>             /* NAME_MAX for maximal filename length  */
#include <string.h>             /* string manipulation                   */
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <ctype.h>
#include <time.h>
#include <dirent.h>
#include <unistd.h>
#include <stdio.h>

/* These definitions are needed only to suppress warning messages. */
#define Nullfp          ((FILE*)0)
#define Nullch          ((char*)0)
#define NullStructLine  ((struct line *)0)

#define LINELEN 128             /* max line length included in diff      */


#define NOT_SET 0               /* Defines to characterise if a flag     */
#define SET     1               /* is set                                */

 /* Indexes of the warning-message array         */
#define EXCLUSIVE_OPTIONS       0
#define CANNOT_OPEN_FILE        1

 /* Used to define the mode              */
typedef enum {
  undefined, context, ed_mode
} MODE;

 /* Global variables for the 'normal' diff part  */
char *progname;                 /* program name (on command line)        */
int diffs = 0;                  /* number of differences                 */
MODE mode;                      /* which mode is used                    */
int severe_error;               /* nonzero after severe, non-fatal error */

/* The following global variables are used with the -r option:
 * for every pair of files that are different, a "command line" of the
 * form "diff <options> <oldfile> <newfile>" is printed before the real
 * output starts.                                                        */
int firstoutput = 1;            /* flag to print one time                */
char options_string[10];        /* string to hold command line options   */
char oldfile[PATH_MAX];         /* first file                            */
char newfile[PATH_MAX];         /* second file                           */


 /* Global variables for the command-line options */
int trim_blanks = NOT_SET;      /* SET if -b specified                   */
int recursive_dir = NOT_SET;    /* SET if -r specified                   */
int context_lines = 3;          /* numbers of lines in a context         */
static int offset;              /* offset of the actual line number for -e */

 /* Function prototypes for the functions in this file   */
struct f;
_PROTOTYPE(int main, (int argc, char **argv ));
_PROTOTYPE(void process_command_line, (int argc, char **argv ));
_PROTOTYPE(void analyse_input_files, (char *arg1, char *arg2, char *input1, 
                                                        char *input2 ));
_PROTOTYPE(void diff, (char *filename1, char *filename2 ));
_PROTOTYPE(FILE *check_file, (char *name ));
_PROTOTYPE(void build_option_string, (void ));
_PROTOTYPE(void fatal_error, (char *fmt, char *s ));
_PROTOTYPE(void warn, (int number, char *string ));
_PROTOTYPE(void trimming_blanks, (char *l_text ));
_PROTOTYPE(char *filename, (char *path_string));
_PROTOTYPE(struct line *new_line, (int size ));
_PROTOTYPE(void free_line, (struct line *l ));
_PROTOTYPE(int equal_line, (struct line *l1, struct line *l2 ));
_PROTOTYPE(int equal_3, (struct line *l1, struct line *l2 ));
_PROTOTYPE(struct line *read_line, (FILE *fp ));
_PROTOTYPE(void advance, (struct f *f ));
_PROTOTYPE(void aside, (struct f *f, struct line *l ));
_PROTOTYPE(struct line *next, (struct f *f ));
_PROTOTYPE(void init_f, (struct f *f, FILE *fp ));
_PROTOTYPE(void update, (struct f *f, char *s ));
_PROTOTYPE(void __diff, (FILE *fp1, FILE *fp2 ));
_PROTOTYPE(void differ, (struct f *f1, struct f *f2 ));
_PROTOTYPE(int wlen, (struct f *f ));
_PROTOTYPE(void range, (int a, int b ));
_PROTOTYPE(void cdiff, (char *old, char *new, FILE *file1, FILE *file2 ));
_PROTOTYPE(void dumphunk, (void ));
_PROTOTYPE(char *getold, (int targ ));
_PROTOTYPE(char *getnew, (int targ ));
_PROTOTYPE(int isdir, (char *path ));
_PROTOTYPE(void diff_recursive, (char *dir1, char *dir2 ));
_PROTOTYPE(void file_type_error, (char *filename1, char *filename2, 
                        struct stat *statbuf1, struct stat *statbuf2 ));
_PROTOTYPE(void *xmalloc, (size_t size));
_PROTOTYPE(void *xrealloc, (void *ptr, size_t size));

int main(argc, argv)
int argc;
char **argv;
{
  char file1[PATH_MAX], file2[PATH_MAX];
  extern int optind;            /* index of the current string in argv   */

  progname = argv[0];
  process_command_line(argc, argv);

  analyse_input_files(argv[optind], argv[optind + 1], file1, file2);
  optind++;

  if (recursive_dir == SET) {
        build_option_string();
        diff_recursive(file1, file2);
  } else {
        diff(file1, file2);
  }

  return(severe_error ? 2 : diffs > 0 ? 1 : 0);
}

/* Process the command line and set the flags for the different
 * options. the processing of the command line is done with the
 * getopt() library function. a minimal error processing is done
 * for the number of command line arguments.                             */
void process_command_line(argc, argv)
int argc;                       /* number of arguments on command line   */
char **argv;                    /* ** to arguments on command line       */
{
  int c;
  extern char *optarg;          /* points to string with options         */
  extern int optind;            /* index of the current string in argv   */

  /* Are there enough arguments?                 */
  if (argc < 3) {
        fatal_error("Usage: %s [-c|-e|-C n][-br] file1 file2\n", progname);
  }

  /* Process all options using getopt()  */
  while ((c = getopt(argc, argv, "ceC:br")) != -1) {
        switch (c) {
            case 'c':
                if (mode != undefined) warn(EXCLUSIVE_OPTIONS, "c");
                mode = context;
                context_lines = 3;
                break;
            case 'e':
                if (mode != undefined) warn(EXCLUSIVE_OPTIONS, "e");
                mode = ed_mode;
                break;
            case 'C':
                if (mode != undefined) warn(EXCLUSIVE_OPTIONS, "C");
                mode = context;
                context_lines = atoi(optarg);
                break;
            case 'b':   trim_blanks = SET;      break;
            case 'r':   recursive_dir = SET;    break;
            case '?':
                exit(2);
        }
  }

  /* We should have two arguments left   */
  if ((argc - optind) != 2)
        fatal_error("Need exactly two input file-names!\n", "");
}

/* Analyse_input_files takes the two input files on the command line
 * and decides what to do. returns the (corrected) filenames that
 * can be used to call diff().
 * if two directories are given, then a recursive diff is done.
 * one directory and one filename compares the file with <filename>
 * in the directory <directory> with <filename>.
 * if two filenames are specified, no special action takes place.
 */
void analyse_input_files(arg1, arg2, input1, input2)
char *arg1, *arg2;              /* filenames on the command line         */
char *input1, *input2;          /* filenames to be used with diff()      */
{
  int stat1 = 0, stat2 = 0;

  if (strcmp(arg1, "-") != 0)
        stat1 = isdir(arg1);    /* != 0 <-> arg1 is directory            */
  if (strcmp(arg2, "-") != 0) stat2 = isdir(arg2);
#ifdef DEBUG
  fprintf(stderr, "%s, stat = %d\n", arg1, stat1);
  fprintf(stderr, "%s, stat = %d\n", arg2, stat2);
#endif
  if (stat1 && stat2) {         /* both arg1 and arg2 are directories */
        recursive_dir = SET;
        strcpy(input1, arg1);
        strcpy(input2, arg2);
        return;
  }
  if (stat1 != 0) {             /* arg1 is a dir, arg2 not               */
        if (strcmp(arg2, "-") != 0) {   /* arg2 != stdin         */
                strcpy(input1, arg1);
                strcat(input1, "/");
                strcat(input1, arg2);
                strcpy(input2, arg2);
                return;
        } else {
                fatal_error("cannot compare stdin (-) with a directory!", "");
        }
  }
  if (stat2 != 0) {             /* arg2 is a dir, arg1 not               */
        if (strcmp(arg1, "-") != 0) {   /* arg1 != stdin         */
                strcpy(input1, arg1);
                strcpy(input2, arg2);
                strcat(input2, "/");
                strcat(input2, arg1);
                return;
        } else {                /* arg1 == stdin                         */
                fatal_error("cannot compare stdin (-) with a directory!", "");
        }
  }

  /* Both arg1 and arg2 are normal  files        */
  strcpy(input1, arg1);
  strcpy(input2, arg2);
}

/* Diff() is the front end for all modes of the program diff, execpt
 * the recursive_dir option.
 * diff() expects the filenames of the two files to be compared as
 * arguments. the mode is determined from the global variable mode.
 */
void diff(filename1, filename2)
char *filename1, *filename2;
{
  FILE *file1 = check_file(filename1);
  FILE *file2 = check_file(filename2);
  struct stat statbuf1, statbuf2;

  if ((file1 != Nullfp) && (file2 != Nullfp)) {
        /* If we do a recursive diff, then we don't compare block
         * special, character special or FIFO special files to any
         * file.                          */
        fstat(fileno(file1), &statbuf1);
        fstat(fileno(file2), &statbuf2);
        if ((((statbuf1.st_mode & S_IFREG) != S_IFREG) ||
             ((statbuf2.st_mode & S_IFREG) != S_IFREG)) &&
            (recursive_dir == SET)) {
                file_type_error(filename1, filename2, &statbuf1, &statbuf2);
        } else {
                switch (mode) {
                    case context:
                        cdiff(filename1, filename2, file1, file2);
                        break;
                    case ed_mode:
                    case undefined:
                        __diff(file1, file2);
                        if (mode == ed_mode) printf("w\n");
                        break;
                }
        }
  } else
        severe_error = 1;
  if (file1 != Nullfp) fclose(file1);
  if (file2 != Nullfp) fclose(file2);
}

/* Check_file() opens the fileptr with name <filename>. if <filename>
 * equals "-" stdin is associated with the return value.
 */
FILE *check_file(name)
char *name;
{
  FILE *temp;

  if (strcmp(name, "-") == 0) {
        return(stdin);
  } else {
        temp = fopen(name, "r");
        if (temp == Nullfp) warn(CANNOT_OPEN_FILE, name);
        return(temp);
  }
}

/* Build_option_string() is called before recursive_dir() is called
 * from the main() function. its purpose is to build the string that
 * is used on the command line to get the current operation mode.
 * e.g. "-C 6 -b".
 */
void build_option_string()
{
  switch (mode) {
            case ed_mode:sprintf(options_string, "-e");
        break;
      case context:
        if (context_lines == 3)
                sprintf(options_string, "-c");
        else
                sprintf(options_string, "-C %d", context_lines);
        break;
  }

}


/* The fatal error handler.
 * Expects a format string and a string as arguments. The arguments
 * are printed to stderr and the program exits with an error code 2.
 */
void fatal_error(fmt, s)
char *fmt;                      /* the format sttring to be printed      */
char *s;                        /* string to be inserted into the format
                                 * string                                */
{
  fprintf(stderr, "%s: ", progname);
  fprintf(stderr, fmt, s);
  fprintf(stderr, "\n");
  exit(2);
}

/* This function prints non fatal error messages to stderr.
 * Expects the index of the message to be printed and a pointer
 * to the (optional) string to be printed.
 * Returns no value.
 */
void warn(number, string)
int number;                     /* index of the warning                  */
char *string;                   /* string to be inserted to the warning  */
{
  static char *warning[] = {
    "%s: The options -c, -e, -C n are mutually exclusive! Assuming -%c\n",
    "%s: cannot open file %s for reading\n",
  };
  fprintf(stderr, warning[number], progname, string);
}

/* Function used with the optione -b, trims the blanks in a input line:
 * - blanks between words are reduced to one
 * - trailing blanks are eliminated.
 */
void trimming_blanks(l_text)
char *l_text;                   /* begin of the char array               */
{
  char *line = l_text;
  char *copy_to, *copy_from;

  do {
        if (*line == ' ') {
                copy_from = line;
                copy_to = line;
                while (*(++copy_from) == ' ');
                if (*copy_from != '\n') copy_to++;
                while (*copy_from != '\0') *(copy_to++) = *(copy_from++);
                *copy_to = '\0';
        }
  } while (*(++line) != '\0');
}


/* Filename separates the filename and the relative path in path_string.
 * Returns the filename with a leading /
 */
char *filename(path_string)
char *path_string;
{
  char name[NAME_MAX + 2];      /* filename plus /                       */
  char *ptr;

  name[0] = '/';
  ptr = strrchr(path_string, '/');

  if (ptr == 0) {               /* no / in path_string, only a filename  */
        strcat(name, path_string);
  } else {
        strcat(name, ptr);
  }

  return(name);
}

/* The line module: one member in a linked list of lines. */
struct line {
  struct line *l_next;          /* pointer to the next line      */
  char l_eof;                   /* == 0 if last line in file     */
  char *l_text;                 /* array with the text           */
};

struct line *freelist = 0;
#define stepup(ll) ( ((ll) && ((ll)->l_eof==0)) ? (ll)->l_next : (ll) )

/* Function to allocate space for a new line containing SIZE chars      */
struct line *new_line(size)
int size;
{
  register struct line *l;

  if ((l = freelist) != NullStructLine)
        freelist = freelist->l_next;
  else {
        l = (struct line *) xmalloc(3 * sizeof(void *));
        l->l_text = (char *) xmalloc((size + 2) * sizeof(char));
        if ((l == 0) || (l->l_text == 0)) fatal_error("Out of memory", "");
  }
  return l;
}


/* Free_line() releases storage allocated for <l>. */
void free_line(l)
register struct line *l;
{
  l->l_next = freelist;
  freelist = l;
}

/* Equal_line() compares two lines, <l1> and <l2>.
 * the returned value is the result of the strcmp() function.
 */
int equal_line(l1, l2)
struct line *l1, *l2;
{
  if (l1 == 0 || l2 == 0)
        return(0);
  else if (l1->l_eof || l2->l_eof)
        return(l1->l_eof == l2->l_eof);
  else
        return(strcmp(l1->l_text, l2->l_text) == 0);
}

int equal_3(l1, l2)
struct line *l1, *l2;
{
  register int i, ansr;

  ansr = 1;
#ifdef DEBUG
  if (l1 == 0)
        fprintf(stderr, "\t(null)\n");
  else if (l1->l_eof)
        fprintf(stderr, "\t(eof)\n");
  else
        fprintf(stderr, "\t%s", l1->l_text);
  if (l2 == 0)
        fprintf(stderr, "\t(null)\n");
  else if (l2->l_eof)
        fprintf(stderr, "\t(eof)\n");
  else
        fprintf(stderr, "\t%s", l2->l_text);
#endif
  for (i = 0; i < 3; ++i) {
        if (!equal_line(l1, l2)) {
                ansr = 0;
                break;
        }
        l1 = stepup(l1);
        l2 = stepup(l2);
  }
#ifdef DEBUG
  fprintf(stderr, "\t%d\n", ansr);
#endif
  return(ansr);
}

struct line *
 read_line(fp)
FILE *fp;
{
  register struct line *l = new_line(LINELEN);
  register char *p;
  register int c;

  (p = &(l->l_text[LINELEN]))[1] = '\377';
  l->l_eof = 0;
  if (fgets(l->l_text, LINELEN + 2, fp) == 0) {
        l->l_eof = 1;
        l->l_text[0] = 0;
  } else if ((p[1] & 0377) != 0377 && *p != '\n') {
        while ((c = fgetc(fp)) != '\n' && c != EOF) {
        }
        *p++ = '\n';
        *p = '\0';
  }
  l->l_next = 0;
  if (trim_blanks == SET) {
#ifdef DEBUG
        printf("xxx %s xxx\n", l->l_text);
#endif
        trimming_blanks(l->l_text);
#ifdef DEBUG
        printf("xxx %s xxx\n", l->l_text);
#endif
  }
  return l;
}

/* File window handler */
struct f {
  struct line *f_bwin, *f_ewin;
  struct line *f_aside;
  int f_linecnt;                /* line number in file of last advanced line */
  FILE *f_fp;
};

void advance(f)
register struct f *f;
{
  register struct line *l;

  if ((l = f->f_bwin) != NullStructLine) {
        if (f->f_ewin == l)
                f->f_bwin = f->f_ewin = 0;
        else
                f->f_bwin = l->l_next;
        free_line(l);
        (f->f_linecnt)++;
  }
}

void aside(f, l)
struct f *f;
struct line *l;
{
  register struct line *ll;

  if (l == 0) return;
  if ((ll = l->l_next) != NullStructLine) {
        while (ll->l_next) ll = ll->l_next;
        ll->l_next = f->f_aside;
        f->f_aside = l->l_next;
        l->l_next = 0;
        f->f_ewin = l;
  }
}


struct line *next(f)
register struct f *f;
{
  register struct line *l;

  if ((l = f->f_aside) != NullStructLine) {
        f->f_aside = l->l_next;
        l->l_next = 0;
  } else
        l = read_line(f->f_fp);
  if (l) {
        if (f->f_bwin == 0)
                f->f_bwin = f->f_ewin = l;
        else {
                if (f->f_ewin->l_eof && l->l_eof) {
                        free_line(l);
                        return(f->f_ewin);
                }
                f->f_ewin->l_next = l;
                f->f_ewin = l;
        }
  }
  return l;
}


/* Init_f() initialises a window structure (struct f). <fp> is the
 * file associated with <f>.
 */
void init_f(f, fp)
register struct f *f;
FILE *fp;
{
  f->f_bwin = f->f_ewin = f->f_aside = 0;
  f->f_linecnt = 0;
  f->f_fp = fp;
}


/* Update() prints a window. <f> is a pointer to the window, <s> is the
 * string containing the "prefix" to the printout( either "<" or ">").
 * after completion of update(), the window is empty.
 */
void update(f, s)
register struct f *f;
char *s;
{
  char *help;
  int only_dot = 0;

  if (firstoutput && (recursive_dir == SET)) {
        printf("diff %s %s %s\n", options_string, oldfile, newfile);
        firstoutput = 0;
  }
  while (f->f_bwin && f->f_bwin != f->f_ewin) {
        if (mode != ed_mode) {
                printf("%s%s", s, f->f_bwin->l_text);
        } else {
#ifdef DEBUG
                printf("ed_mode: test for only dot");
                printf("%s", f->f_bwin->l_text);
#endif
                help = f->f_bwin->l_text;
                while ((*help == ' ') ||
                       (*help == '.') ||
                       (*help == '\t')) {
                        if (*(help++) == '.') only_dot++;
                        if (only_dot > 1) break;
                }

                /* If only_dot is equal 1, there is only one dot on
                 * the line, so we have to take special actions.
                 * f the line with only one dot is found, we output
                 * two dots (".."), terminate the append modus and
                 * substitute "." for "..". Afterwards we restart
                 * with the append command.                      */
                if (*help == '\n' && only_dot == 1) {
                        help = f->f_bwin->l_text;
                        while (*help != '\0') {
                                if (*help == '.') printf(".");
                                putchar((int) *(help++));
                        }
                        printf(".\n");
                        printf(".s/\\.\\././\n");
                        printf("a\n");
                } else {
                        printf("%s%s", s, f->f_bwin->l_text);
                }
        }
        advance(f);
  }
}

/* __Diff(), performs the "core operation" of the program.
 * Expects two file-pointers as arguments. This functions does
 * *not* check if the file-pointers are valid.
 */

void __diff(fp1, fp2)
FILE *fp1, *fp2;
{
  struct f f1, f2;
  struct line *l1, *s1, *b1, *l2, *s2, *b2;
  register struct line *ll;

  init_f(&f1, fp1);
  init_f(&f2, fp2);
  l1 = next(&f1);
  l2 = next(&f2);
  while ((l1->l_eof == 0) || (l2->l_eof == 0)) {
        if (equal_line(l1, l2)) {
  equal:
                advance(&f1);
                advance(&f2);
                l1 = next(&f1);
                l2 = next(&f2);
                continue;
        }
        s1 = b1 = l1;
        s2 = b2 = l2;
        /* Read several more lines */
        next(&f1);
        next(&f1);
        next(&f2);
        next(&f2);
        /* Start searching */
search:
        next(&f2);
        ll = s1;
        do {
                if (equal_3(ll, b2)) {
                        l1 = ll;
                        l2 = b2;
                        aside(&f1, ll);
                        aside(&f2, b2);
                        differ(&f1, &f2);
                        goto equal;
                }
                if (ll->l_eof) break;
                ll = stepup(ll);
        } while (ll);
        b2 = stepup(b2);

        next(&f1);
        ll = s2;
        do {
                if (equal_3(b1, ll)) {
                        l1 = b1;
                        l2 = ll;
                        aside(&f2, ll);
                        aside(&f1, b1);
                        differ(&f1, &f2);
                        goto equal;
                }
                if (ll->l_eof != 0) break;
                ll = stepup(ll);
        } while (ll);
        b1 = stepup(b1);

        goto search;
  }

  /* Both of the files reached EOF */
}

/* Differ() prints the differences between files. the arguments <f1> and
 * <f2> are pointers to the two windows, where the differences are.
 */
void differ(f1, f2)
register struct f *f1, *f2;
{
  int cnt1 = f1->f_linecnt, len1 = wlen(f1);
  int cnt2 = f2->f_linecnt, len2 = wlen(f2);
  if ((len1 != 0) || (len2 != 0)) {
        if (len1 == 0) {
                if (mode == ed_mode) {
                        cnt1 += offset;
                        printf("%d a\n", cnt1);
                        update(f2, "");
                        printf(".\n");
                        offset += len2;
                } else {
                        printf("%da", cnt1);
                        range(cnt2 + 1, cnt2 + len2);
                }
        } else if (len2 == 0) {
                if (mode == ed_mode) {
                        cnt1 += offset;
                        range(cnt1 + 1, cnt1 + len1);
                        printf("d\n");
                        offset -= len1;
                        while (f1->f_bwin && f1->f_bwin != f1->f_ewin)
                                advance(f1);
                } else {
                        range(cnt1 + 1, cnt1 + len1);
                        printf("d%d", cnt2);
                }
        } else {
                if (mode != ed_mode) {
                        range(cnt1 + 1, cnt1 + len1);
                        putchar('c');
                        range(cnt2 + 1, cnt2 + len2);
                } else {
                        cnt1 += offset;
                        if (len1 == len2) {
                                range(cnt1 + 1, cnt1 + len1);
                                printf("c\n");
                                update(f2, "");
                                printf(".\n");
                        } else {
                                range(cnt1 + 1, cnt1 + len1);
                                printf("d\n");
                                printf("%d a\n", cnt1);
                                update(f2, "");
                                printf(".\n");
                                offset -= len1 - len2;
                        }
                        while (f1->f_bwin && f1->f_bwin != f1->f_ewin)
                                advance(f1);
                }
        }
        if (mode != ed_mode) {
                putchar('\n');
                if (len1 != 0) update(f1, "< ");
                if ((len1 != 0) && (len2 != 0)) printf("---\n");
                if (len2 != 0) update(f2, "> ");
        }
        diffs++;
  }
}


/* Function wlen() calculates the number of lines in a window. */
int wlen(f)
struct f *f;
{
  register cnt = 0;
  register struct line *l = f->f_bwin, *e = f->f_ewin;

  while (l && l != e) {
        cnt++;
        l = l->l_next;
  }
  return cnt;
}


/* Range() prints the line numbers of a range. the arguments <a> and <b>
 * are the beginning and the ending line number of the range. if
 * <a> == <b>, only one line number is printed. otherwise <a> and <b> are
 * separated by a ",".
 */
void range(a, b)
int a, b;
{
  printf(((a == b) ? "%d" : "%d,%d"), a, b);
}

/* Here follows the code for option -c.
 * This code is from the cdiff program by Larry Wall. I changed it only
 * slightly to reflect the POSIX standard and to call the main routine
 * as function context_diff().
 */

/* Cdiff - context diff                 Author: Larry Wall */

/* These global variables are still here from the original cdiff program...
 * I was to lazy just to sort them out...
 */
char buff[512];
FILE *oldfp, *newfp;

int oldmin, oldmax, newmin, newmax;
int oldbeg, oldend, newbeg, newend;
int preoldmax, prenewmax;
int preoldbeg, preoldend, prenewbeg, prenewend;
int oldwanted, newwanted;

char *oldhunk, *newhunk;
size_t oldsize, oldalloc, newsize, newalloc;

int oldline, newline; /* Jose */

void cdiff(old, new, file1, file2)
char *old, *new;                /* The names of the two files to be compared */
FILE *file1, *file2;            /* The corresponding file-pointers       */
{
  FILE *inputfp;
  struct stat statbuf;
  register char *s;
  char op;
  char *newmark, *oldmark;
  int len;
  char *line;
  int i, status;

  oldfp = file1;
  newfp = file2;

  oldalloc = 512;
  oldhunk = (char *) xmalloc(oldalloc);
  newalloc = 512;
  newhunk = (char *) xmalloc(newalloc);


/* The context diff spawns a new process that executes a normal diff
 * and parses the output.
 */
  if (trim_blanks == SET)
        sprintf(buff, "diff -b %s %s", old, new);
  else
        sprintf(buff, "diff %s %s", old, new);

  inputfp = popen(buff, "r");
  if (!inputfp) {
        fprintf(stderr, "Can't execute diff %s %s, popen failed with %s\n",
                old, new, strerror(errno));
        exit(2);
  }
  preoldend = -1000;
  firstoutput = 1;
  oldline = newline = 0;
  while (fgets(buff, sizeof buff, inputfp) != Nullch) {
        if (firstoutput) {
                if (recursive_dir == SET) {
                        printf("diff %s %s %s\n", options_string,
                               oldfile, newfile);
                }
                fstat(fileno(oldfp), &statbuf);
                printf("*** %s %s", old, ctime(&statbuf.st_mtime));
                fstat(fileno(newfp), &statbuf);
                printf("--- %s %s", new, ctime(&statbuf.st_mtime));
                firstoutput = 0;
        }
        if (isdigit(*buff)) {
                oldmin = atoi(buff);
                for (s = buff; isdigit(*s); s++);
                if (*s == ',') {
                        s++;
                        oldmax = atoi(s);
                        for (; isdigit(*s); s++);
                } else {
                        oldmax = oldmin;
                }
                if (*s != 'a' && *s != 'd' && *s != 'c') {
                        fprintf(stderr, "Unparseable input: %s", s);
                        exit(2);
                }
                op = *s;
                s++;
                newmin = atoi(s);
                for (; isdigit(*s); s++);
                if (*s == ',') {
                        s++;
                        newmax = atoi(s);
                        for (; isdigit(*s); s++);
                } else {
                        newmax = newmin;
                }
                if (*s != '\n' && *s != ' ') {
                        fprintf(stderr, "Unparseable input: %s", s);
                        exit(2);
                }
                newmark = oldmark = "! ";
                if (op == 'a') {
                        oldmin++;
                        newmark = "+ ";
                }
                if (op == 'd') {
                        newmin++;
                        oldmark = "- ";
                }
                oldbeg = oldmin - context_lines;
                oldend = oldmax + context_lines;
                if (oldbeg < 1) oldbeg = 1;
                newbeg = newmin - context_lines;
                newend = newmax + context_lines;
                if (newbeg < 1) newbeg = 1;

                if (preoldend < oldbeg - 1) {
                        if (preoldend >= 0) {
                                dumphunk();
                        }
                        preoldbeg = oldbeg;
                        prenewbeg = newbeg;
                        oldwanted = newwanted = 0;
                        oldsize = newsize = 0;
                } else {        /* we want to append to previous hunk */
                        oldbeg = preoldmax + 1;
                        newbeg = prenewmax + 1;
                }

                for (i = oldbeg; i <= oldmax; i++) {
                        line = getold(i);
                        if (!line) {
                                oldend = oldmax = i - 1;
                                break;
                        }
                        len = strlen(line) + 2;
                        if (oldsize + len + 1 >= oldalloc) {
                                oldalloc *= 2;
                                oldhunk = (char *) xrealloc(oldhunk, oldalloc);
                        }
                        if (i >= oldmin) {
                                strcpy(oldhunk + oldsize, oldmark);
                                oldwanted++;
                        } else {
                                strcpy(oldhunk + oldsize, "  ");
                        }
                        strcpy(oldhunk + oldsize + 2, line);
                        oldsize += len;
                }
                preoldmax = oldmax;
                preoldend = oldend;

                for (i = newbeg; i <= newmax; i++) {
                        line = getnew(i);
                        if (!line) {
                                newend = newmax = i - 1;
                                break;
                        }
                        len = strlen(line) + 2;
                        if (newsize + len + 1 >= newalloc) {
                                newalloc *= 2;
                                newhunk = (char *) xrealloc(newhunk, newalloc);
                        }
                        if (i >= newmin) {
                                strcpy(newhunk + newsize, newmark);
                                newwanted++;
                        } else {
                                strcpy(newhunk + newsize, "  ");
                        }
                        strcpy(newhunk + newsize + 2, line);
                        newsize += len;
                }
                prenewmax = newmax;
                prenewend = newend;
        }
  }
  status = pclose(inputfp);
  if (status != 0) diffs++;
  if (!WIFEXITED(status) || WEXITSTATUS(status) > 1) severe_error = 1;

  if (preoldend >= 0) {
        dumphunk();
  }
}

void dumphunk()
{
  int i;
  char *line;
  int len;

  for (i = preoldmax + 1; i <= preoldend; i++) {
        line = getold(i);
        if (!line) {
                preoldend = i - 1;
                break;
        }
        len = strlen(line) + 2;
        if (oldsize + len + 1 >= oldalloc) {
                oldalloc *= 2;
                oldhunk = (char *) xrealloc(oldhunk, oldalloc);
        }
        strcpy(oldhunk + oldsize, "  ");
        strcpy(oldhunk + oldsize + 2, line);
        oldsize += len;
  }
  for (i = prenewmax + 1; i <= prenewend; i++) {
        line = getnew(i);
        if (!line) {
                prenewend = i - 1;
                break;
        }
        len = strlen(line) + 2;
        if (newsize + len + 1 >= newalloc) {
                newalloc *= 2;
                newhunk = (char *) xrealloc(newhunk, newalloc);
        }
        strcpy(newhunk + newsize, "  ");
        strcpy(newhunk + newsize + 2, line);
        newsize += len;
  }
  fputs("***************\n", stdout);
  if (preoldbeg >= preoldend) {
        printf("*** %d ****\n", preoldend);
  } else {
        printf("*** %d,%d ****\n", preoldbeg, preoldend);
  }
  if (oldwanted) {
        fputs(oldhunk, stdout);
  }
  oldsize = 0;
  *oldhunk = '\0';
  if (prenewbeg >= prenewend) {
        printf("--- %d ----\n", prenewend);
  } else {
        printf("--- %d,%d ----\n", prenewbeg, prenewend);
  }
  if (newwanted) {
        fputs(newhunk, stdout);
  }
  newsize = 0;
  *newhunk = '\0';
}

char *getold(targ)
int targ;
{
  while (fgets(buff, sizeof buff, oldfp) != Nullch) {
        oldline++;
        if (oldline == targ) return buff;
  }
  return Nullch;
}

char *getnew(targ)
int targ;
{
  while (fgets(buff, sizeof buff, newfp) != Nullch) {
        newline++;
        if (newline == targ) return buff;
  }
  return Nullch;
}


/* Isdir() checks, if <path> is the name of a directory. a return value
 * is 0, <path> is a normal file. otherwise the <path> is a directory.
 */
int isdir(path)
char *path;
{
  struct stat buf;
  stat(path, &buf);
  if (buf.st_mode & S_IFDIR) {  /* path is a directory           */
        return(~0);
  } else {
        return(0);
  }
}



/* This is the "main" function if a diff of two directories has to be
 * done. diff_recursive() expects the names of the two directories to
 * be compared.                                                          */
void diff_recursive(dir1, dir2)
char *dir1, *dir2;
{
  FILE *ls1, *ls2;
  char file1[PATH_MAX], file2[PATH_MAX];
  char jointfile1[PATH_MAX], jointfile2[PATH_MAX];
  char command[PATH_MAX];
  int difference, eof1, eof2;

  sprintf(command, "ls %s", dir1);
  ls1 = popen(command, "r");
  sprintf(command, "ls %s", dir2);
  ls2 = popen(command, "r");

  if ((ls1 == NULL) || (ls2 == NULL))
        fatal_error("cannot execute ls!", "");

  file1[0] = '\0';
  eof1 = fscanf(ls1, "%s\n", file1);
  file2[0] = '\0';
  eof2 = fscanf(ls2, "%s\n", file2);

  while ((file1[0] != '\0') && (file2[0] != '\0')) {
        difference = strcmp(file1, file2);
        while (difference != 0) {
                if (difference < 0) {
                        printf("Only in %s: %s\n", dir1, file1);
                        file1[0] = '\0';
                        eof1 = fscanf(ls1, "%s\n", file1);
                        if (file1[0] == '\0') break;
                } else {
                        printf("Only in %s: %s\n", dir2, file2);
                        file2[0] = '\0';
                        eof2 = fscanf(ls2, "%s\n", file2);
                        if (file2[0] == '\0') break;
                }
                difference = strcmp(file1, file2);
        }
        if (eof1 != EOF && eof2 != EOF) {
                strcpy(jointfile1, dir1);
                strcat(jointfile1, "/");
                strcat(jointfile1, file1);
                strcpy(jointfile2, dir2);
                strcat(jointfile2, "/");
                strcat(jointfile2, file2);

                if ((isdir(jointfile1) != 0) && (isdir(jointfile2) != 0)) {
                        printf("Common subdirectories: %s and %s\n",
                               jointfile1, jointfile2);
                        diff_recursive(jointfile1, jointfile2);
                } else {
                        firstoutput = 1;
                        strcpy(oldfile, jointfile1);
                        strcpy(newfile, jointfile2);
                        diff(jointfile1, jointfile2);
                }
                file1[0] = '\0';
                eof1 = fscanf(ls1, "%s\n", file1);
                file2[0] = '\0';
                eof2 = fscanf(ls2, "%s\n", file2);
        }
  }

  if (file1[0] != '\0') {       /* first arg still has files             */
        do {
                printf("Only in %s: %s\n", dir1, file1);
                eof1 = fscanf(ls1, " %s\n", file1);
        } while (eof1 != EOF);
  }
  if (file2[0] != '\0') {
        do {
                printf("Only in %s: %s\n", dir2, file2);
                eof2 = fscanf(ls2, " %s\n", file2);
        } while (eof2 != EOF);
  }
  if (pclose(ls1) != 0) severe_error = 1;
  if (pclose(ls2) != 0) severe_error = 1;
}


/* File_type_error is called, if in a recursive diff ( -r) one of the two
 * files a block special, a character special or a FIFO special file is.
 * The corresponding error message is printed here.                       */
void file_type_error(filename1, filename2, statbuf1, statbuf2)
char *filename1, *filename2;
struct stat *statbuf1, *statbuf2;
{
  char type1[25], type2[25];

  switch (statbuf1->st_mode & S_IFMT) { /* select only file mode */
      case S_IFREG:
        sprintf(type1, "regular file ");
        break;
      case S_IFBLK:
        sprintf(type1, "block special file ");
        break;
      case S_IFDIR:     sprintf(type1, "directory ");   break;
      case S_IFCHR:
        sprintf(type1, "character special file ");
        break;
      case S_IFIFO:
        sprintf(type1, "FIFO special file ");
        break;
  }

  switch (statbuf2->st_mode & S_IFMT) { /* select only file mode */
      case S_IFREG:
        sprintf(type2, "regular file ");
        break;
      case S_IFBLK:
        sprintf(type2, "block special file ");
        break;
      case S_IFDIR:     sprintf(type2, "directory ");   break;
      case S_IFCHR:
        sprintf(type2, "character special file ");
        break;
      case S_IFIFO:
        sprintf(type2, "FIFO special file ");
        break;
  }
  printf("File %s is a %s while file %s is a %s\n",
         filename1, type1, filename2, type2);
}

void *xmalloc(size)
size_t size;
{
  void *ptr;

  ptr = malloc(size);
  if (ptr == NULL) {
        fprintf(stderr, "%s: out of memory\n", progname);
        exit(2);
  }
  return(ptr);
}

void *xrealloc(ptr, size)
void *ptr;
size_t size;
{
  ptr = realloc(ptr, size);
  if (ptr == NULL) {
        fprintf(stderr, "%s: out of memory\n", progname);
        exit(2);
  }
  return(ptr);
}

---