/usr/src/gnu/usr.bin/cvs/diff/io.c

Bug Summary

File:	src/gnu/usr.bin/cvs/diff/io.c
Warning:	line 456, column 12 Array access (from variable 'p0') results in a null pointer dereference

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name io.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/cvs/obj/diff -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/cvs/diff -I .. -I ../src -I /usr/src/gnu/usr.bin/cvs/lib -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/cvs/obj/diff -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/cvs/diff/io.c

1/* File I/O for GNU DIFF.
 Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, Inc.

4This file is part of GNU DIFF.

6GNU DIFF is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.

11GNU DIFF is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14GNU General Public License for more details.

16*/

18#include "diff.h"

20/* Rotate a value n bits to the left. */
21#define UINT_BIT(sizeof (unsigned) * 8) (sizeof (unsigned) * CHAR_BIT8)
22#define ROL(v, n)((v) << (n) | (v) >> ((sizeof (unsigned) * 8) - (
n))) ((v) << (n) | (v) >> (UINT_BIT(sizeof (unsigned) * 8) - (n)))

24/* Given a hash value and a new character, return a new hash value. */
25#define HASH(h, c)((c) + ((h) << (7) | (h) >> ((sizeof (unsigned) *
 8) - (7)))) ((c) + ROL (h, 7)((h) << (7) | (h) >> ((sizeof (unsigned) * 8) - (
7))))

27/* Guess remaining number of lines from number N of lines so far,
 size S so far, and total size T.  */
29#define GUESS_LINES(n,s,t)(((t) - (s)) / ((n) < 10 ? 32 : (s) / ((n)-1)) + 5) (((t) - (s)) / ((n) < 10 ? 32 : (s) / ((n)-1)) + 5)

31/* Type used for fast prefix comparison in find_identical_ends.  */
32#ifndef wordint
33#define wordint int
34#endif
35
36/* 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.  */
40struct equivclass
41{
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;	/* That line's length, not counting its newline.  */
46};

48/* Hash-table: array of buckets, each being a chain of equivalence classes.
 buckets[-1] is reserved for incomplete lines.  */
50static int *buckets;

52/* Number of buckets in the hash table array, not counting buckets[-1]. */
53static int nbuckets;

55/* 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.  */
58static struct equivclass *equivs;

60/* Index of first free element in the array `equivs'.  */
61static int equivs_index;

63/* Number of elements allocated in the array `equivs'.  */
64static int equivs_alloc;

66static void find_and_hash_each_line PARAMS((struct file_data *))(struct file_data *);
67static void find_identical_ends PARAMS((struct file_data[]))(struct file_data[]);
68static void prepare_text_end PARAMS((struct file_data *))(struct file_data *);
69
70/* Check for binary files and compare them for exact identity.  */

72/* Return 1 if BUF contains a non text character.
 SIZE is the number of characters in BUF.  */

75#define binary_file_p(buf, size)(memchr (buf, '\0', size) != 0) (memchr (buf, '\0', size) != 0)

77/* Get ready to read the current file.
 Return nonzero if SKIP_TEST is zero,
 and if it appears to be a binary file.  */

81int
82sip (current, skip_test)
   struct file_data *current;
   int skip_test;
85{
/* If we have a nonexistent file at this stage, treat it as empty.  */
if (current->desc < 0)
  {
    /* Leave room for a sentinel.  */
    current->bufsize = sizeof (wordint);
    current->buffer = xmalloc (current->bufsize);
  }
else
  {
    current->bufsize = STAT_BLOCKSIZE (current->stat)(current->stat).st_blksize;
    current->buffer = xmalloc (current->bufsize);

    if (! skip_test)
{
 /* Check first part of file to see if it's a binary file.  */
101#if HAVE_SETMODE0
 int oldmode = setmode (current->desc, O_BINARY);
103#endif
 size_t n = read (current->desc, current->buffer, current->bufsize);
 if (n == -1)
   pfatal_with_name (current->name);
 current->buffered_chars = n;
108#if HAVE_SETMODE0
 if (oldmode != O_BINARY)
   {
     if (lseek (current->desc, - (off_t) n, SEEK_CUR1) == -1)
pfatal_with_name (current->name);
     setmode (current->desc, oldmode);
     current->buffered_chars = 0;
   }
116#endif
 return binary_file_p (current->buffer, n)(memchr (current->buffer, '\0', n) != 0);
}
  }

current->buffered_chars = 0;
return 0;
123}

125/* Slurp the rest of the current file completely into memory.  */

127void
128slurp (current)
   struct file_data *current;
130{
size_t cc;

if (current->desc < 0)
  /* The file is nonexistent.  */
  ;
else if (S_ISREG (current->stat.st_mode)((current->stat.st_mode & 0170000) == 0100000))
  {
    /* It's a regular file; slurp in the rest all at once.  */

    /* Get the size out of the stat block.
Allocate enough room for appended newline and sentinel.  */
    cc = current->stat.st_size + 1 + sizeof (wordint);
    if (current->bufsize < cc)
{
 current->bufsize = cc;
 current->buffer = xrealloc (current->buffer, cc);
}

    if (current->buffered_chars < current->stat.st_size)
{
 cc = read (current->desc,
     current->buffer + current->buffered_chars,
     current->stat.st_size - current->buffered_chars);
 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 + 1 + sizeof (wordint);
    current->buffer = xrealloc (current->buffer, current->bufsize);
  }
182}
183
184/* Split the file into lines, simultaneously computing the equivalence class for
 each line. */

187static void
188find_and_hash_each_line (current)
   struct file_data *current;
190{
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;
int use_line_cmp = ignore_some_line_changes;

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)(1 && isspace (c)))
  h = HASH (h, ISUPPER (c) ? tolower (c) : c)(((1 && isupper (c)) ? tolower (c) : c) + ((h) <<
 (7) | (h) >> ((sizeof (unsigned) * 8) - (7))));
     }
 else if (ignore_space_change_flag)
   while ((c = *p++) != '\n')
     {
if (ISSPACE (c)(1 && isspace (c)))
  {
    for (;;)
      {
	c = *p++;
	if (!ISSPACE (c)(1 && isspace (c)))
	  break;
	if (c == '\n')
	  goto hashing_done;
      }
    h = HASH (h, ' ')((' ') + ((h) << (7) | (h) >> ((sizeof (unsigned)
 * 8) - (7))));
  }
/* C is now the first non-space.  */
h = HASH (h, ISUPPER (c) ? tolower (c) : c)(((1 && isupper (c)) ? tolower (c) : c) + ((h) <<
 (7) | (h) >> ((sizeof (unsigned) * 8) - (7))));
     }
 else
   while ((c = *p++) != '\n')
     h = HASH (h, ISUPPER (c) ? tolower (c) : c)(((1 && isupper (c)) ? tolower (c) : c) + ((h) <<
 (7) | (h) >> ((sizeof (unsigned) * 8) - (7))));
}
    else
{
 if (ignore_all_space_flag)
   while ((c = *p++) != '\n')
     {
if (! ISSPACE (c)(1 && isspace (c)))
  h = HASH (h, c)((c) + ((h) << (7) | (h) >> ((sizeof (unsigned) *
 8) - (7))));
     }
 else if (ignore_space_change_flag)
   while ((c = *p++) != '\n')
     {
if (ISSPACE (c)(1 && isspace (c)))
  {
    for (;;)
      {
	c = *p++;
	if (!ISSPACE (c)(1 && isspace (c)))
	  break;
	if (c == '\n')
	  goto hashing_done;
      }
    h = HASH (h, ' ')((' ') + ((h) << (7) | (h) >> ((sizeof (unsigned)
 * 8) - (7))));
  }
/* C is now the first non-space.  */
h = HASH (h, c)((c) + ((h) << (7) | (h) >> ((sizeof (unsigned) *
 8) - (7))));
     }
 else
   while ((c = *p++) != '\n')
     h = HASH (h, c)((c) + ((h) << (7) | (h) >> ((sizeof (unsigned) *
 8) - (7))));
}
 hashing_done:;

    bucket = &buckets[h % nbuckets];
    length = (char const *) p - ip - 1;

    if ((char const *) p == bufend
 && current->missing_newline
 && ROBUST_OUTPUT_STYLE (output_style)((output_style) != OUTPUT_ED && (output_style) != OUTPUT_FORWARD_ED
))
{
 /* This line is incomplete.  If this is significant,
    put the line into bucket[-1].  */
 if (! (ignore_space_change_flag | ignore_all_space_flag))
   bucket = &buckets[-1];

 /* Omit the inserted newline when computing linbuf later.  */
 p--;
 bufend = suffix_begin = (char const *) p;
}

    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)
 {
   char const *eqline = eqs[i].line;

   /* Reuse existing equivalence class if the lines are identical.
      This detects the common case of exact identity
      faster than complete comparison would.  */
   if (eqs[i].length == length && memcmp (eqline, ip, length) == 0)
     break;

   /* Reuse existing class if line_cmp reports the lines equal.  */
   if (use_line_cmp && line_cmp (eqline, ip) == 0)
     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)
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;
382}
383
384/* 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.  */

388static void
389prepare_text_end (current)
   struct file_data *current;
391{
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 = 1;
  }

/* Don't use uninitialized storage when planting or using sentinels.  */
if (p)
  bzero (p + buffered_chars, sizeof (word))memset (p + buffered_chars, 0, sizeof (int));
407}
408
409/* Given a vector of two file_data objects, find the identical
 prefixes and suffixes of each object. */

412static void
413find_identical_ends (filevec)
   struct file_data filevec[];
415{
wordint *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)
1
Assuming 'filevec[0].desc' is not equal to 'filevec[1].desc'→
2
←
Taking true branch→
  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++)
3
←
Loop condition is true.  Entering loop body→
4
←
Loop condition is true.  Entering loop body→
5
←
Loop condition is false. Execution continues on line 439→
  prepare_text_end (&filevec[i]);

/* Find identical prefix.  */

p0 = buffer0 = filevec[0].buffer;
6
←
Null pointer value stored to 'p0'→
p1 = buffer1 = filevec[1].buffer;

n0 = filevec[0].buffered_chars;
n1 = filevec[1].buffered_chars;

if (p06.1
'p0' is not equal to 'p1'
 == p1)
7
←
Taking false branch→
  /* 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 (n07.1
'n0' is >= 'n1'
 < n1)
8
←
Taking false branch→
p0[n0] = ~p1[n0];
    else
p1[n1] = ~p0[n1];
9
←
Array access (from variable 'p0') results in a null pointer dereference

    /* Loop until first mismatch, or to the sentinel characters.  */

    /* Compare a word at a time for speed.  */
    w0 = (wordint *) p0;
    w1 = (wordint *) 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)((output_style) != OUTPUT_ED && (output_style) != OUTPUT_FORWARD_ED
)
 && (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)((output_style) != OUTPUT_ED && (output_style) != OUTPUT_FORWARD_ED
)
    || 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)(((p0 - filevec[0].prefix_end) - (0)) / ((0) < 10 ? 32 : (
0) / ((0)-1)) + 5)
 + context;
  }
else
  {
    prefix_count = 0;
    prefix_mask = ~0;
    alloc_lines0 = GUESS_LINES (0, 0, n0)(((n0) - (0)) / ((0) < 10 ? 32 : (0) / ((0)-1)) + 5);
  }

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)(((tem) - (filevec[1].prefix_end - buffer1)) / ((lines) < 10
 ? 32 : (filevec[1].prefix_end - buffer1) / ((lines)-1)) + 5)
     + 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;
621}
622
623/* 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) . . . */
626static int const primes[] =
627{
509,
1021,
2039,
4093,
8191,
16381,
32749,
635#if 32767 < INT_MAX2147483647
65521,
131071,
262139,
524287,
1048573,
2097143,
4194301,
8388593,
16777213,
33554393,
67108859,			/* Preposterously large . . . */
134217689,
268435399,
536870909,
1073741789,
2147483647,
652#endif
0
654};

656/* 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.  */

661int
662read_files (filevec, pretend_binary)
   struct file_data filevec[];
   int pretend_binary;
665{
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)
  {
680#if HAVE_SETMODE0
    setmode (filevec[0].desc, O_BINARY);
    setmode (filevec[1].desc, O_BINARY);
683#endif
    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 + 1) * sizeof (*buckets));
bzero (buckets++, (nbuckets + 1) * sizeof (*buckets))memset (buckets++, 0, (nbuckets + 1) * 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 - 1);

return 0;
712}