/* sort - sort lines of text (with all kinds of options).
   Copyright (C) 1988, 1991, 1992, 1993, 1994, 1995 Free Software Foundation

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   Written December 1988 by Mike Haertel.
   The author may be reached (Email) at the address mike@gnu.ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation. */

/* define to sort binary data */
/* #define SAOMOD_BINARY 1 */

/* define to sorts on hms, mjd */
/* #define SAOMOD_ASTRO  1 */

/* define to sort RDB tables */
/* #define SAOMOD_TABLE  1 */

/* always define --this just marks code fixes */
#define SAOMOD_FIX    1

/* Get isblank from GNU libc.  */
#define _GNU_SOURCE

#include <sys/types.h>

#ifndef RTMX
#include <signal.h>
#else
#include <sys/signal.h>
#endif

#if HAVE_CONFIG_H
#include <conf.h>
#endif

#include <stdio.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#include "system.h"
#ifdef LOCAL_INCLUDES
#include "version.h"
#include "error.h"
#endif

#ifdef SAOMOD_TABLE
#include <table.h>
#endif
#ifdef SAOMOD_ASTRO
double mjd();
#endif

#ifdef _POSIX_VERSION
#include <limits.h>
#else
#ifndef UCHAR_MAX
#define UCHAR_MAX 255
#endif
#endif

#if HAVE_LONG_LONG
typedef long long longlong;
#else
typedef long longlong;
#endif

static void usage ();

#ifdef SAOMOD_TABLE
        int table = 0;
#endif

#ifdef SAOMOD_BINARY
	int BinarySort = 0;
#endif

#define min(a, b) ((a) < (b) ? (a) : (b))
#define UCHAR_LIM (UCHAR_MAX + 1)
#define UCHAR(c) ((unsigned char) (c))

#ifndef DEFAULT_TMPDIR
#define DEFAULT_TMPDIR "/tmp"
#endif

/* The kind of blanks for '-b' to skip in various options. */
enum blanktype { bl_start, bl_end, bl_both };

/* The name this program was run with. */
char *program_name;

/* Table of digits. */
static int digits[UCHAR_LIM];

/* Table of white space. */
static int blanks[UCHAR_LIM];

/* Table of non-printing characters. */
static int nonprinting[UCHAR_LIM];

/* Table of non-dictionary characters (not letters, digits, or blanks). */
static int nondictionary[UCHAR_LIM];

/* Translation table folding lower case to upper. */
static char fold_toupper[UCHAR_LIM];

/* Table mapping 3-letter month names to integers.
   Alphabetic order allows binary search. */
static struct month
{
  char *name;
  int val;
} const monthtab[] =
{
  {"APR", 4},
  {"AUG", 8},
  {"DEC", 12},
  {"FEB", 2},
  {"JAN", 1},
  {"JUL", 7},
  {"JUN", 6},
  {"MAR", 3},
  {"MAY", 5},
  {"NOV", 11},
  {"OCT", 10},
  {"SEP", 9}
};

/* During the merge phase, the number of files to merge at once. */
#define NMERGE 48

/* Initial buffer size for in core sorting.  Will not grow unless a
   line longer than this is seen. */
static int sortalloc = 1024 * 1024;

/* Initial buffer size for in core merge buffers.  Bear in mind that
   up to NMERGE * mergealloc bytes may be allocated for merge buffers. */
static int mergealloc =  32 * 1024;

/* Guess of average line length. */
static int linelength = 30;

/* Maximum number of elements for the array(s) of struct line's, in bytes.  */
#define LINEALLOC (8 * 256 * 1024)

/* Prefix for temporary file names. */
static char *temp_file_prefix;

/* Flag to reverse the order of all comparisons. */
static int reverse;

/* Flag for stable sort.  This turns off the last ditch bytewise
   comparison of lines, and instead leaves lines in the same order
   they were read if all keys compare equal.  */
static int stable;

/* Tab character separating fields.  If NUL, then fields are separated
   by the empty string between a non-whitespace character and a whitespace
   character. */
static char tab = '\0';

/* Nonzero if any of the input files are the standard input. */
static int have_read_stdin;

/* Lines are held in core as counted strings. */
struct line
{
  char *text;			/* Text of the line. */
  int length;			/* Length not including final newline. */
  char *keybeg;			/* Start of first key. */
  char *keylim;			/* Limit of first key. */
#ifdef SAOMOD_ASTRO
  int   flag;
  double value;			/* the chached value of the a numeric key. */
#endif
};

/* Arrays of lines. */
struct lines
{
  struct line *lines;		/* Dynamically allocated array of lines. */
  int used;			/* Number of slots used. */
  int alloc;			/* Number of slots allocated. */
  int limit;			/* Max number of slots to allocate.  */
};

/* Input buffers. */
struct buffer
{
  char *buf;			/* Dynamically allocated buffer. */
  int used;			/* Number of bytes used. */
  int alloc;			/* Number of bytes allocated. */
  int left;			/* Number of bytes left after line parsing. */
};

/* Lists of key field comparisons to be tried. */
static struct keyfield
{
  int sword;			/* Zero-origin 'word' to start at. */
  int schar;			/* Additional characters to skip. */
  int skipsblanks;		/* Skip leading white space at start. */
  int eword;			/* Zero-origin first word after field. */
  int echar;			/* Additional characters in field. */
  int skipeblanks;		/* Skip trailing white space at finish. */
  int *ignore;			/* Boolean array of characters to ignore. */
  char *translate;		/* Translation applied to characters. */
  int numeric;			/* Flag for numeric comparison. */
  int month;			/* Flag for comparison by month name. */
  int reverse;			/* Reverse the sense of comparison. */
  int nzone;
  double dzone;
  int	 btype;
  struct keyfield *next;	/* Next keyfield to try. */
} keyhead;

/* The list of temporary files. */
static struct tempnode
{
  char *name;
  struct tempnode *next;
} temphead;


/* Flag to remove consecutive duplicate lines from the output.
   Only the last of a sequence of equal lines will be output. */
static int unique = 0;
static int differ = 0;
static int countr = 0;
static int setcnt = 1;


/* Clean up any remaining temporary files. */

static void
cleanup ()
{
  struct tempnode *node;

  for (node = temphead.next; node; node = node->next)
    unlink (node->name);
}

/* Allocate N bytes of memory dynamically, with error checking.  */

char *
xmalloc (n)
     unsigned n;
{
  char *p;

  p = (char *)malloc (n);
  if (p == 0)
    {
      fprintf (stderr, "virtual memory exhausted");
      cleanup ();
      exit (2);
    }
  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.  */

char *
xrealloc (p, n)
     char *p;
     unsigned n;
{
  if (p == 0)
    return (char *)xmalloc (n);
  if (n == 0)
    {
      free (p);
      return 0;
    }
  p = (char *)realloc (p, n);
  if (p == 0)
    {
      fprintf (stderr, "virtual memory exhausted");
      cleanup ();
      exit (2);
    }
  return p;
}
static FILE *
xfopen (file, how)
     char *file, *how;
{
#ifdef SAOMOD_TABLE
  FILE *fp = Open(file, how);
#else
  FILE *fp;
  if ( !strcmp(file, "-") && !strcmp(how, "r") ) fp = stdin;
  else if ( !strcmp(file, "-") && !strcmp(how, "w") ) fp = stdout;
  else fp = fopen(file, how);
#endif

  if (fp == 0) {
      perror (file);
      cleanup ();
      exit (2);
  }

  if (fp == stdin) have_read_stdin = 1;

  return fp;
}

static void
xfclose (fp)
     FILE *fp;
{
  if (fp == stdin) {
      /* Allow reading stdin from tty more than once. */
      if (feof (fp))
	clearerr (fp);
  } else if ( fp == stdout ) {
      if (fflush (fp) != 0) {
	  perror ("flushing file");
	  cleanup ();
	  exit (2);
      }
  } else {
#ifdef SAOMOD_TABLE
      if ( Close(fp) != 0 ) {
#else
      if ( fclose(fp) != 0 ) {
#endif

	  perror ("closing file");
	  cleanup ();
	  exit (2);
      }
  }
}

static void
xfwrite (buf, size, nelem, fp)
     char *buf;
     int size, nelem;
     FILE *fp;
{
  if (fwrite (buf, size, nelem, fp) != (size_t)nelem)
    {
      perror ("writing file");
      cleanup ();
      exit (2);
    }
}

/* Return a name for a temporary file. */

static char *
tempname ()
{
  static int seq;
  int len = strlen (temp_file_prefix);
  char *name = xmalloc (len + 16);
  struct tempnode *node =
  (struct tempnode *) xmalloc (sizeof (struct tempnode));

  sprintf (name,
	   "%s%ssort%5.5d%5.5d",
	   temp_file_prefix,
	   (len && temp_file_prefix[len - 1] != '/') ? "/" : "",
	   (unsigned int) getpid () & 0xffff, ++seq);
  node->name = name;
  node->next = temphead.next;
  temphead.next = node;
  return name;
}

/* Search through the list of temporary files for NAME;
   remove it if it is found on the list. */

static void
zaptemp (name)
     char *name;
{
  struct tempnode *node, *temp;

  for (node = &temphead; node->next; node = node->next)
    if (!strcmp (name, node->next->name))
      break;
  if (node->next)
    {
      temp = node->next;
      unlink (temp->name);
      free (temp->name);
      node->next = temp->next;
      free ((char *) temp);
    }
}

/* Initialize the character class tables. */

static void
inittables ()
{
  int i;

  for (i = 0; i < UCHAR_LIM; ++i)
    {
      if (ISBLANK (i))
	blanks[i] = 1;
      if (ISDIGIT (i))
	digits[i] = 1;
      if (!ISPRINT (i))
	nonprinting[i] = 1;
      if (!ISALNUM (i) && !ISBLANK (i))
	nondictionary[i] = 1;
      if (ISLOWER (i))
	fold_toupper[i] = toupper (i);
      else
	fold_toupper[i] = i;
    }
}

/* Initialize BUF, allocating ALLOC bytes initially. */

static void
initbuf (buf, alloc)
     struct buffer *buf;
     int alloc;
{
  buf->alloc = alloc;
  buf->buf = xmalloc (buf->alloc);
  buf->used = buf->left = 0;
}

/* Fill BUF reading from FP, moving buf->left bytes from the end
   of buf->buf to the beginning first.	If EOF is reached and the
   file wasn't terminated by a newline, supply one.  Return a count
   of bytes buffered. */

static int
fillbuf (buf, fp)
     struct buffer *buf;
     FILE *fp;
{
  int cc;

  memmove (buf->buf, buf->buf + buf->used - buf->left, buf->left);
  buf->used = buf->left;

#ifdef SAOMOD_BINARY
  if ( BinarySort ) {
	cc = fread (buf->buf + buf->used, 1, buf->alloc - buf->used, fp);

	buf->used += cc;

	return buf->used;
  }
#endif

  while (!feof (fp) && (buf->used == 0 || !memchr (buf->buf, '\n', buf->used)))
    {
      if (buf->used == buf->alloc)
	{
	  buf->alloc *= 2;
	  buf->buf = xrealloc (buf->buf, buf->alloc);
	}
      cc = fread (buf->buf + buf->used, 1, buf->alloc - buf->used, fp);
      if (ferror (fp))
	{
	  perror ("reading file");
	  cleanup ();
	  exit (2);
	}
      buf->used += cc;
    }

  if (feof (fp) && buf->used && buf->buf[buf->used - 1] != '\n')
    {
      if (buf->used == buf->alloc)
	{
	  buf->alloc *= 2;
	  buf->buf = xrealloc (buf->buf, buf->alloc);
	}
      buf->buf[buf->used++] = '\n';
    }

  return buf->used;
}

/* Initialize LINES, allocating space for ALLOC lines initially.
   LIMIT is the maximum possible number of lines to allocate space
   for, ever.  */

static void
initlines (lines, alloc, limit)
     struct lines *lines;
     int alloc;
     int limit;
{
  lines->alloc = alloc;
  lines->lines = (struct line *) xmalloc (lines->alloc * sizeof (struct line));
  lines->used = 0;
  lines->limit = limit;
}

/* Return a pointer to the first character of the field specified
   by KEY in LINE. */

static char *
begfield (line, key)
     struct line *line;
     struct keyfield *key;
{
  register char *ptr = line->text, *lim = ptr + line->length;
  register int sword = key->sword, schar = key->schar;

  if (tab)
    while (ptr < lim && sword--)
      {
	while (ptr < lim && *ptr != tab)
	  ++ptr;
	if (ptr < lim)
	  ++ptr;
      }
  else
    while (ptr < lim && sword--)
      {
	while (ptr < lim && blanks[UCHAR (*ptr)])
	  ++ptr;
	while (ptr < lim && !blanks[UCHAR (*ptr)])
	  ++ptr;
      }

  if (key->skipsblanks
#ifdef SAOMOD_TABLE
||table
#endif
      )
    while (ptr < lim && blanks[UCHAR (*ptr)])
      ++ptr;

  while (ptr < lim && schar--)
    ++ptr;

  return ptr;
}

/* Return the limit of (a pointer to the first character after) the field
   in LINE specified by KEY. */

static char *
limfield (line, key)
     struct line *line;
     struct keyfield *key;
{
  register char *ptr = line->text, *lim = ptr + line->length;
  register int eword = key->eword, echar = key->echar;

  if ( eword == -1 ) {
	eword = 1;
	echar = 0;
  }

  if (tab)
    while (ptr < lim && eword--)
      {
	while (ptr < lim && *ptr != tab)
	  ++ptr;
	if (ptr < lim && (eword > 0 || key->skipeblanks))
	  ++ptr;
      }
  else
    while (ptr < lim && eword--)
      {
	while (ptr < lim && blanks[UCHAR (*ptr)])
	  ++ptr;
	while (ptr < lim && !blanks[UCHAR (*ptr)])
	  ++ptr;
      }

#ifdef SAOMOD_TABLE
  if ( table ) {
    if ( blanks[UCHAR (*ptr)] ) {
	while (ptr > line->text && blanks[UCHAR (*ptr)] ) --ptr;
        ptr++;
    }
  } else
#endif
    {
  if (key->skipeblanks)
    while (ptr < lim && blanks[UCHAR (*ptr)])
      ++ptr;

  while (ptr < lim && echar--)
    ++ptr;
 }

  return ptr;
}

/* Find the lines in BUF, storing pointers and lengths in LINES.
   Also replace newlines with NULs. */

static void
findlines (buf, lines)
     struct buffer *buf;
     struct lines *lines;
{
  register char *beg = buf->buf, *lim = buf->buf + buf->used, *ptr;
  struct keyfield *key = keyhead.next;

  lines->used = 0;

#ifdef SAOMOD_BINARY
  if ( lim - beg < BinarySort ) {
	fprintf(stderr, "Odd sized records in buffer?\n");
	cleanup();
	abort();
  }
#else
  if ( lim - beg < 0 ) {
	fprintf(stderr, "Odd sized records in buffer?\n");
	cleanup();
	abort();
  }
#endif
	
#ifdef SAOMOD_BINARY
  if ( BinarySort ) {
      while ( beg + BinarySort <= lim )
	{

	  if (lines->used == lines->alloc)
	    {
	      lines->alloc *= 2;
	      lines->lines = (struct line *)
		xrealloc ((char *) lines->lines,
			  lines->alloc * sizeof (struct line));
	    }

	  lines->lines[lines->used].text = beg;
	  lines->lines[lines->used].length = BinarySort;
#ifdef SAOMOD_ASTRO
          lines->lines[lines->used].flag = 0;
#endif

	  beg += BinarySort;
	  lines->used++;
	}

  	buf->left = lim - beg;
	return;
  }
#endif
  
  while (beg < lim && (ptr = memchr (beg, '\n', lim - beg))
	 && lines->used < lines->limit)
    {
      /* There are various places in the code that rely on a NUL
	 being at the end of in-core lines; NULs inside the lines
	 will not cause trouble, though. */
      *ptr = '\0';

      if (lines->used == lines->alloc)
	{
	  lines->alloc *= 2;
	  lines->lines = (struct line *)
	    xrealloc ((char *) lines->lines,
		      lines->alloc * sizeof (struct line));
	}

      lines->lines[lines->used].text = beg;
      lines->lines[lines->used].length = ptr - beg;
#ifdef SAOMOD_ASTRO
      lines->lines[lines->used].flag = 0;
#endif

      /* Precompute the position of the first key for efficiency. */
      if (key)
	{
	  if ( key->eword >= 0
#ifdef SAOMOD_TABLE
 || table 
#endif
	       )
	    lines->lines[lines->used].keylim =
	      limfield (&lines->lines[lines->used], key);
	  else
	    lines->lines[lines->used].keylim = ptr;

          if (key->sword >= 0)
            lines->lines[lines->used].keybeg =
              begfield (&lines->lines[lines->used], key);
          else
            {
              if (key->skipsblanks
#ifdef SAOMOD_TABLE
||table
#endif
)
                while (blanks[UCHAR (*beg)])
                  ++beg;
              lines->lines[lines->used].keybeg = beg;
            }
	}
      else
	{
	  lines->lines[lines->used].keybeg = 0;
	  lines->lines[lines->used].keylim = 0;
	}

      ++lines->used;
      beg = ptr + 1;
    }

  buf->left = lim - beg;
}

/* Compare strings A and B containing decimal fractions < 1.  Each string
   should begin with a decimal point followed immediately by the digits
   of the fraction.  Strings not of this form are considered to be zero. */

static int
fraccompare (a, b)
     register char *a, *b;
{
  register int tmpa = UCHAR (*a), tmpb = UCHAR (*b);

  if (tmpa == '.' && tmpb == '.')
    {
      do
	tmpa = UCHAR (*++a), tmpb = UCHAR (*++b);
      while (tmpa == tmpb && digits[tmpa]);
      if (digits[tmpa] && digits[tmpb])
	return tmpa - tmpb;
      if (digits[tmpa])
	{
	  while (tmpa == '0')
	    tmpa = UCHAR (*++a);
	  if (digits[tmpa])
	    return 1;
	  return 0;
	}
      if (digits[tmpb])
	{
	  while (tmpb == '0')
	    tmpb = UCHAR (*++b);
	  if (digits[tmpb])
	    return -1;
	  return 0;
	}
      return 0;
    }
  else if (tmpa == '.')
    {
      do
	tmpa = UCHAR (*++a);
      while (tmpa == '0');
      if (digits[tmpa])
	return 1;
      return 0;
    }
  else if (tmpb == '.')
    {
      do
	tmpb = UCHAR (*++b);
      while (tmpb == '0');
      if (digits[tmpb])
	return -1;
      return 0;
    }
  return 0;
}

/* Compare strings A and B as numbers without explicitly converting them to
   machine numbers.  Comparatively slow for short strings, but asymptotically
   hideously fast. */

static int
numcompare (a, b)
     register char *a, *b;
{
  register int tmpa, tmpb, loga, logb, tmp;

  tmpa = UCHAR (*a), tmpb = UCHAR (*b);


  while (blanks[tmpa])
    tmpa = UCHAR (*++a);
  while (blanks[tmpb])
    tmpb = UCHAR (*++b);

  if (tmpa == '-')
    {
      tmpa = UCHAR (*++a);
      if (tmpb != '-')
	{
	  if (digits[tmpa] && digits[tmpb])
	    return -1;
	  return 0;
	}
      tmpb = UCHAR (*++b);

      while (tmpa == '0')
	tmpa = UCHAR (*++a);
      while (tmpb == '0')
	tmpb = UCHAR (*++b);

      while (tmpa == tmpb && digits[tmpa])
	tmpa = UCHAR (*++a), tmpb = UCHAR (*++b);

      if ((tmpa == '.' && !digits[tmpb]) || (tmpb == '.' && !digits[tmpa]))
	return -fraccompare (a, b);

      if (digits[tmpa])
	for (loga = 1; digits[UCHAR (*++a)]; ++loga)
	  ;
      else
	loga = 0;

      if (digits[tmpb])
	for (logb = 1; digits[UCHAR (*++b)]; ++logb)
	  ;
      else
	logb = 0;

      if ((tmp = logb - loga) != 0)
	return tmp;

      if (!loga)
	return 0;

      return tmpb - tmpa;
    }
  else if (tmpb == '-')
    {
      if (digits[UCHAR (tmpa)] && digits[UCHAR (*++b)])
	return 1;
      return 0;
    }
  else
    {
      while (tmpa == '0')
	tmpa = UCHAR (*++a);
      while (tmpb == '0')
	tmpb = UCHAR (*++b);

      while (tmpa == tmpb && digits[tmpa])
	tmpa = UCHAR (*++a), tmpb = UCHAR (*++b);

      if ((tmpa == '.' && !digits[tmpb]) || (tmpb == '.' && !digits[tmpa]))
	return fraccompare (a, b);

      if (digits[tmpa])
	for (loga = 1; digits[UCHAR (*++a)]; ++loga)
	  ;
      else
	loga = 0;

      if (digits[tmpb])
	for (logb = 1; digits[UCHAR (*++b)]; ++logb)
	  ;
      else
	logb = 0;

      if ((tmp = loga - logb) != 0)
	return tmp;

      if (!loga)
	return 0;

      return tmpa - tmpb;
    }
}

/* Return an integer <= 12 associated with month name S with length LEN,
   0 if the name in S is not recognized. */

static int
getmonth (s, len)
     char *s;
     int len;
{
  char month[4];
  register int i, lo = 0, hi = 12;

  while (len > 0 && blanks[UCHAR(*s)])
    ++s, --len;

  if (len < 3)
    return 0;

  for (i = 0; i < 3; ++i)
    month[i] = fold_toupper[UCHAR (s[i])];
  month[3] = '\0';

  while (hi - lo > 1)
    if (strcmp (month, monthtab[(lo + hi) / 2].name) < 0)
      hi = (lo + hi) / 2;
    else
      lo = (lo + hi) / 2;
  if (!strcmp (month, monthtab[lo].name))
    return monthtab[lo].val;
  return 0;
}

/* Compare two lines A and B trying every key in sequence until there
   are no more keys or a difference is found. */

static int
keycompare (a, b)
     struct line *a, *b;
{
  register char *texta, *textb, *lima, *limb, *translate;
  register int *ignore;
  struct keyfield *key;
  int diff = 0, iter = 0, lena, lenb;

  for (key = keyhead.next; key; key = key->next, ++iter)
    {
      ignore = key->ignore;
      translate = key->translate;

#ifdef SAOMOD_BINARY
      if ( BinarySort ) {
	switch ( key->btype ) {
	     case 'c' :
	     case 'b' : {
		char	va, vb;

		va = *((char *) a->text+key->sword);
		vb = *((char *) b->text+key->sword);

		if ( key->nzone ) {
		    va = (int) (va / key->dzone);
		    vb = (int) (vb / key->dzone);
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 'C' :
	     case 'B' : {
		unsigned char	va, vb;

		va = *((unsigned char *) a->text+key->sword);
		vb = *((unsigned char *) b->text+key->sword);

		if ( key->nzone ) {
		    va = (int) (va / key->dzone);
		    vb = (int) (vb / key->dzone);
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 's' : {
		short	va, vb;

		if ( !iter ) {
		    memcpy(&va, (void *) (a->text+key->sword), sizeof(short));
		    memcpy(&vb, (void *) (b->text+key->sword), sizeof(short));
		    if ( key->nzone ) {
			va = (int) (va / key->dzone);
			vb = (int) (vb / key->dzone);
		    }
		} else {
#ifdef SAOMOD_ASTRO
		    if ( a->flag ) va = a->value;
		    else {
#endif
		        memcpy(&va, (void *) (a->text+key->sword), sizeof(short));
		        if ( key->nzone ) va = (int) (va / key->dzone);
#ifdef SAOMOD_ASTRO
			a->flag = 1;
			a->value = va;
		    }
		    if ( b->flag ) vb = b->value;
		    else {
#endif
		        memcpy(&vb, (void *) (b->text+key->sword), sizeof(short));
		        if ( key->nzone ) va = (int) (vb / key->dzone);
#ifdef SAOMOD_ASTRO
			b->flag = 1;
			b->value = vb;
		    }
#endif
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 'S' : {
		unsigned short	va, vb;

		if ( !iter ) {
		    memcpy(&va, (void *) (a->text+key->sword), sizeof(short));
		    memcpy(&vb, (void *) (b->text+key->sword), sizeof(short));
		    if ( key->nzone ) {
			va = (int) (va / key->dzone);
			vb = (int) (vb / key->dzone);
		    }
		} else {
#ifdef SAOMOD_ASTRO
		    if ( a->flag ) va = a->value;
		    else {
#endif
		        memcpy(&va, (void *) (a->text+key->sword), sizeof(short));
		        if ( key->nzone ) va = (int) (va / key->dzone);
#ifdef SAOMOD_ASTRO
			a->flag = 1;
			a->value = va;
		    }
		    if ( b->flag ) vb = b->value;
		    else {
#endif
		        memcpy(&vb, (void *) (b->text+key->sword), sizeof(short));
		        if ( key->nzone ) va = (int) (vb / key->dzone);
#ifdef SAOMOD_ASTRO
			b->flag = 1;
			b->value = vb;
		    }
#endif
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 'i' : {
		int	va, vb;

		if ( !iter ) {
		    memcpy(&va, (void *) (a->text+key->sword), sizeof(int));
		    memcpy(&vb, (void *) (b->text+key->sword), sizeof(int));
		    if ( key->nzone ) {
			va = (int) (va / key->dzone);
			vb = (int) (vb / key->dzone);
		    }
		} else {
#ifdef SAOMOD_ASTRO
		    if ( a->flag ) va = a->value;
		    else {
#endif
		        memcpy(&va, (void *) (a->text+key->sword), sizeof(int));
		        if ( key->nzone ) va = (int) (va / key->dzone);
#ifdef SAOMOD_ASTRO
			a->flag = 1;
			a->value = va;
		    }
		    if ( b->flag ) vb = b->value;
		    else {
#endif
		        memcpy(&vb, (void *) (b->text+key->sword), sizeof(int));
		        if ( key->nzone ) va = (int) (vb / key->dzone);
#ifdef SAOMOD_ASTRO
			b->flag = 1;
			b->value = vb;
		    }
#endif
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 'l' : {
		longlong	va, vb;
#if HAVE_LONG_LONG == 0
		fprintf (stderr, "long long support was not built into this program\n");
		exit(1);
#endif
		if ( !iter ) {
		    memcpy(&va, (void *) (a->text+key->sword), sizeof(longlong));
		    memcpy(&vb, (void *) (b->text+key->sword), sizeof(longlong));
		    if ( key->nzone ) {
			va = (longlong) (va / key->dzone);
			vb = (longlong) (vb / key->dzone);
		    }
		} else {
#ifdef SAOMOD_ASTRO
		    if ( a->flag ) va = a->value;
		    else {
#endif
		        memcpy(&va, (void *) (a->text+key->sword), sizeof(longlong));
		        if ( key->nzone ) va = (longlong) (va / key->dzone);
#ifdef SAOMOD_ASTRO
			a->flag = 1;
			a->value = va;
		    }
		    if ( b->flag ) vb = b->value;
		    else {
#endif
		        memcpy(&vb, (void *) (b->text+key->sword), sizeof(longlong));
		        if ( key->nzone ) va = (longlong) (vb / key->dzone);
#ifdef SAOMOD_ASTRO
			b->flag = 1;
			b->value = vb;
		    }
#endif
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 'I' : {
		unsigned int	va, vb;

		if ( !iter ) {
		    memcpy(&va, (void *) (a->text+key->sword), sizeof(int));
		    memcpy(&vb, (void *) (b->text+key->sword), sizeof(int));
		    if ( key->nzone ) {
			va = (int) (va / key->dzone);
			vb = (int) (vb / key->dzone);
		    }
		} else {
#ifdef SAOMOD_ASTRO
		    if ( a->flag ) va = a->value;
		    else {
#endif
		        memcpy(&va, (void *) (a->text+key->sword), sizeof(int));
		        if ( key->nzone ) va = (int) (va / key->dzone);
#ifdef SAOMOD_ASTRO
			a->flag = 1;
			a->value = va;
		    }
		    if ( b->flag ) vb = b->value;
		    else {
#endif
		        memcpy(&vb, (void *) (b->text+key->sword), sizeof(int));
		        if ( key->nzone ) va = (int) (vb / key->dzone);
#ifdef SAOMOD_ASTRO
			b->flag = 1;
			b->value = vb;
		    }
#endif
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 'f' : {
		float	va, vb;

		if ( !iter ) {
		    memcpy(&va, (void *) (a->text+key->sword), sizeof(float));
		    memcpy(&vb, (void *) (b->text+key->sword), sizeof(float));
		    if ( key->nzone ) {
			va = (int) (va / key->dzone);
			vb = (int) (vb / key->dzone);
		    }
		} else {
#ifdef SAOMOD_ASTRO
		    if ( a->flag ) va = a->value;
		    else {
#endif
		        memcpy(&va, (void *) (a->text+key->sword), sizeof(float));
		        if ( key->nzone ) va = (int) (va / key->dzone);
#ifdef SAOMOD_ASTRO
			a->flag = 1;
			a->value = va;
		    }
		    if ( b->flag ) vb = b->value;
		    else {
#endif
		        memcpy(&vb, (void *) (b->text+key->sword), sizeof(float));
		        if ( key->nzone ) va = (int) (vb / key->dzone);
#ifdef SAOMOD_ASTRO
			b->flag = 1;
			b->value = vb;
		    }
#endif
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 'd' : {
		double	va, vb;

		if ( !iter ) {
		    memcpy(&va, (void *) (a->text+key->sword), sizeof(double));
		    memcpy(&vb, (void *) (b->text+key->sword), sizeof(double));
		    if ( key->nzone ) {
			va = (int) (va / key->dzone);
			vb = (int) (vb / key->dzone);
		    }
		} else {
#ifdef SAOMOD_ASTRO
		    if ( a->flag ) va = a->value;
		    else {
#endif
		        memcpy(&va, (void *) (a->text+key->sword), sizeof(double));
		        if ( key->nzone ) va = (int) (va / key->dzone);
#ifdef SAOMOD_ASTRO
			a->flag = 1;
			a->value = va;
		    }
		    if ( b->flag ) vb = b->value;
		    else {
#endif
		        memcpy(&vb, (void *) (b->text+key->sword), sizeof(double));
		        if ( key->nzone ) va = (int) (vb / key->dzone);
#ifdef SAOMOD_ASTRO
			b->flag = 1;
			b->value = vb;
		    }
#endif
		}

		diff = va == vb ? 0 : ( va < vb ? -1 : 1 );
		break;
	      }
	     case 't' : {
		diff = strncmp(a->text+key->sword, b->text+key->sword, key->schar);
		break;
	      }
	     default:
		fprintf(stderr, "Bad type in binary value compare\n");
		cleanup();
		abort();
	}

	if ( diff ) return diff;
	continue;
      }
#endif

      /* Find the beginning and limit of each field. */
      if (iter || a->keybeg == NULL || b->keybeg == NULL)
	{
	  if ( key->eword >= 0
#ifdef SAOMOD_TABLE
|| table
#endif
	       ) {
	    lima = limfield (a, key);
	    limb = limfield (b, key);
	  } else {
	    lima = a->text + a->length;
	    limb = b->text + b->length;
	  }

          if (key->sword >= 0) {
            texta = begfield (a, key); textb = begfield (b, key);
          } else {
              texta = a->text; textb = b->text;
              if (key->skipsblanks
#ifdef SAOMOD_TABLE
||table
#endif
)
                {
                  while (texta < lima && blanks[UCHAR (*texta)])
                    ++texta;
                  while (textb < limb && blanks[UCHAR (*textb)])
                    ++textb;
                }
            }
	}
      else
	{
	  /* For the first iteration only, the key positions have
	     been precomputed for us. */
	  texta = a->keybeg; lima = a->keylim;
	  textb = b->keybeg; limb = b->keylim;
	}

      /* Find the lengths. */
      lena = lima - texta; lenb = limb - textb;
      if (lena < 0)
	lena = 0;
      if (lenb < 0)
	lenb = 0;

      /* Actually compare the fields. */
      if ( key->numeric ) {
#ifdef SAOMOD_FIX
	  if ( *texta != '+' && *texta != '-' && !ISDIGIT((int)*texta) ) {
	    if ( *textb != '+' && *textb != '-' && !ISDIGIT((int)*textb) ) {
		diff = memcmp (texta, textb, min(lena, lenb));
	    } else {
		diff =  1;
	    }
	  } else
	      if ( *textb != '+' && *textb != '-' && !ISDIGIT((int)*textb) ) {
		 diff = -1;
	  } else
#endif
#ifdef SAOMOD_ASTRO
          if ( key->numeric == 2 || key->numeric == 3 ) {
		double	va;
		double	vb;

		static int x = 0;

	   if ( iter ) {
	    if (*lima || *limb) {
	      char savea = *lima; 
	      char saveb = *limb;

	      *lima = *limb = '\0';

	      if ( key->numeric == 2 ) {
	          va = SAOstrtod(texta, NULL);
	          vb = SAOstrtod(textb, NULL);
	      } else {
	          va = mjd(texta, 0);
	          vb = mjd(textb, 0);
	      }

	      *lima = savea; *limb = saveb;
            } else {
	      if ( key->numeric == 2 ) {
	          va = SAOstrtod(texta, NULL);
	          vb = SAOstrtod(textb, NULL);
	      } else {
	          va = mjd(texta, 0);
	          vb = mjd(textb, 0);
	      }
	    }
	   } else {
		  if ( a->flag ) va = a->value;
	          else {
			char savea = *lima;

	      	    *lima = '\0';
	      	    if ( key->numeric == 2 ) {
		        va = a->value = SAOstrtod(texta, NULL);
	      	    } else {
	                va = mjd(texta, 0);
		    }
		    *lima = savea;
		    a->flag++;

	          }
	          if ( b->flag ) vb = b->value;
		  else {
			char saveb = *limb;
  
	      	    *limb = '\0';
	      	    if ( key->numeric == 2 ) {
		        vb = b->value = SAOstrtod(textb, NULL);
	      	    } else {
	                vb = mjd(textb, 0);
		    }
		    *limb = saveb;
		    b->flag++;
	          }
	   }

	   if ( key->nzone ) {
	     va = (int) (va / key->dzone);
	     vb = (int) (vb / key->dzone);
	   }

	   diff = (va < vb) ? -1 : ((va == vb) ? 0 : 1);

	  if ( diff )
	    return key->reverse ? -diff : diff;
	  continue;
       } else
#endif
       if ( key->numeric == 1 )
	{
	   if (*lima || *limb)
	    {
	      char savea = *lima; char saveb = *limb;

	      *lima = *limb = '\0';

	      diff = numcompare (texta, textb);
	      *lima = savea, *limb = saveb;
	    } 
	    else {
	      diff = numcompare (texta, textb);
	}


	  if (diff)
	    return key->reverse ? -diff : diff;
	  continue;
	}
#ifdef SAOMOD_FIX
	  if (diff) /* This catches the text diffs */
	    return key->reverse ? -diff : diff;
#endif
      }
      else if (key->month)
	{
	  diff = getmonth (texta, lena) - getmonth (textb, lenb);
	  if (diff)
	    return key->reverse ? -diff : diff;
	  continue;
	}
      else if (ignore && translate)
	while (texta < lima && textb < limb)
	  {
	    while (texta < lima && ignore[UCHAR (*texta)])
	      ++texta;
	    while (textb < limb && ignore[UCHAR (*textb)])
	      ++textb;
	    if (texta < lima && textb < limb &&
		translate[UCHAR (*texta++)] != translate[UCHAR (*textb++)])
	      {
		diff = translate[UCHAR (*--texta)] - translate[UCHAR (*--textb)];
		break;
	      }
	    else if (texta == lima && textb < limb) diff = -1;
	    else if (texta < lima && textb == limb) diff = 1;
	  }
      else if (ignore)
	while (texta < lima && textb < limb)
	  {
	    while (texta < lima && ignore[UCHAR (*texta)])
	      ++texta;
	    while (textb < limb && ignore[UCHAR (*textb)])
	      ++textb;
	    if (texta < lima && textb < limb && *texta++ != *textb++)
	      {
		diff = *--texta - *--textb;
		break;
	      }
	    else if (texta == lima && textb < limb) diff = -1;
	    else if (texta < lima && textb == limb) diff = 1;
	  }
      else if (translate)
	while (texta < lima && textb < limb)
	  {
	    if (translate[UCHAR (*texta++)] != translate[UCHAR (*textb++)])
	      {
		diff = translate[UCHAR (*--texta)] - translate[UCHAR (*--textb)];
		break;
	      }
	  }
      else
	diff = memcmp (texta, textb, min (lena, lenb));

      if (diff)
	return key->reverse ? -diff : diff;
      if ((diff = lena - lenb) != 0)
	return key->reverse ? -diff : diff;
    }

  return 0;
}

/* Compare two lines A and B, returning negative, zero, or positive
   depending on whether A compares less than, equal to, or greater than B. */

static int
compare (a, b)
     register struct line *a, *b;
{
  int diff, tmpa, tmpb, mini;

  /* First try to compare on the specified keys (if any).
     The only two cases with no key at all are unadorned sort,
     and unadorned sort -r. */
  if (keyhead.next)
    {
      diff = keycompare (a, b);
      if (diff != 0)
	return diff;
      if (unique || stable)
	return 0;
    }

  /* If the keys all compare equal (or no keys were specified)
     fall through to the default byte-by-byte comparison. */
  tmpa = a->length, tmpb = b->length;
  mini = min (tmpa, tmpb);
  if (mini == 0)
    diff = tmpa - tmpb;
  else
    {
      char *ap = a->text, *bp = b->text;

      diff = UCHAR (*ap) - UCHAR (*bp);
      if (diff == 0)
	{
	  diff = memcmp (ap, bp, mini);
	  if (diff == 0)
	    diff = tmpa - tmpb;
	}
    }

  return reverse ? -diff : diff;
}

/* Check that the lines read from the given FP come in order.  Return
   1 if they do and 0 if there is a disorder. */

static int	line;
static int
checkfp (fp)
     FILE *fp;
{
  struct buffer buf;		/* Input buffer. */
  struct lines lines;		/* Lines scanned from the buffer. */
  struct line *prev_line;	/* Pointer to previous line. */
  struct line temp;		/* Copy of previous line. */
  int cc;			/* Character count. */
  int cmp;			/* Result of calling compare. */
  int alloc, i, success = 1;

  initbuf (&buf, mergealloc);
  initlines (&lines, mergealloc / linelength + 1,
	     LINEALLOC / ((NMERGE + NMERGE) * sizeof (struct line)));
  alloc = linelength;
  temp.text = xmalloc (alloc);

  cc = fillbuf (&buf, fp);
  findlines (&buf, &lines);

  if (cc)
    do
      {

	/* Compare each line in the buffer with its successor. */
	for (i = 0; i < lines.used - 1; ++i)
	  {
	    line++;
	    cmp = compare (&lines.lines[i], &lines.lines[i + 1]);
	    if ((unique && cmp >= 0) || (cmp > 0))
	      {
		success = 0;
		goto finish;
	      }
	  }

	/* Save the last line of the buffer and refill the buffer. */
	prev_line = lines.lines + lines.used - 1;
	if (prev_line->length > alloc)
	  {
	    while (prev_line->length + 1 > alloc)
	      alloc *= 2;
	    temp.text = xrealloc (temp.text, alloc);
	  }
	memcpy (temp.text, prev_line->text, prev_line->length + 1);
	temp.length = prev_line->length;
	temp.keybeg = temp.text + (prev_line->keybeg - prev_line->text);
	temp.keylim = temp.text + (prev_line->keylim - prev_line->text);
#ifdef SAOMOD_ASTRO
	temp.flag  = prev_line->flag;
	temp.value = prev_line->value;
#endif

	cc = fillbuf (&buf, fp);
	if (cc)
	  {
	    findlines (&buf, &lines);
	    /* Make sure the line saved from the old buffer contents is
	       less than or equal to the first line of the new buffer. */
	    cmp = compare (&temp, &lines.lines[0]);
	    if ((unique && cmp >= 0) || (cmp > 0))
	      {
		success = 0;
		break;
	      }
	  }
      }
    while (cc);

finish:
  xfclose (fp);
  free (buf.buf);
  free ((char *) lines.lines);
  free (temp.text);
  return success;
}

/* Merge lines from FPS onto OFP.  NFPS cannot be greater than NMERGE.
   Close FPS before returning. */

static void
mergefps (fps, nfps, ofp)
     FILE *fps[], *ofp;
     register int nfps;
{
  struct buffer buffer[NMERGE];	/* Input buffers for each file. */
  struct lines lines[NMERGE];	/* Line tables for each buffer. */
  struct line saved;		/* Saved line for unique check. */
  int savedflag = 0;		/* True if there is a saved line. */
  int savealloc = 0;		/* Size allocated for the saved line. */
  int cur[NMERGE];		/* Current line in each line table. */
  int ord[NMERGE];		/* Table representing a permutation of fps,
				   such that lines[ord[0]].lines[cur[ord[0]]]
				   is the smallest line and will be next
				   output. */
  register int i, j, t;

  /* Allocate space for a saved line if necessary. */
  if (unique)
    {
      savealloc = linelength;
      saved.text = xmalloc (savealloc);
#ifdef SAOMOD_ASTRO
      saved.flag = 0;
#endif
    }

  /* Read initial lines from each input file. */
  for (i = 0; i < nfps; ++i)
    {
      initbuf (&buffer[i], mergealloc);
      /* If a file is empty, eliminate it from future consideration. */
      while (i < nfps && !fillbuf (&buffer[i], fps[i]))
	{
	  xfclose (fps[i]);
	  --nfps;
	  for (j = i; j < nfps; ++j)
	    fps[j] = fps[j + 1];
	}
      if (i == nfps)
	free (buffer[i].buf);
      else
	{
	  initlines (&lines[i], mergealloc / linelength + 1,
		     LINEALLOC / ((NMERGE + NMERGE) * sizeof (struct line)));
	  findlines (&buffer[i], &lines[i]);
	  cur[i] = 0;
	}
    }

  /* Set up the ord table according to comparisons among input lines.
     Since this only reorders two items if one is strictly greater than
     the other, it is stable. */
  for (i = 0; i < nfps; ++i)
    ord[i] = i;
  for (i = 1; i < nfps; ++i)
    if (compare (&lines[ord[i - 1]].lines[cur[ord[i - 1]]],
		 &lines[ord[i]].lines[cur[ord[i]]]) > 0)
      t = ord[i - 1], ord[i - 1] = ord[i], ord[i] = t, i = 0;

  /* Repeatedly output the smallest line until no input remains. */
  while ( nfps )
    {
      /* If uniqified output is turned on, output only the last of
	 an identical series of lines. */
      if (unique)
	{	int cmp;

	  if ( savedflag ) {
		cmp = compare (&saved, &lines[ord[0]].lines[cur[ord[0]]]);

	      if ( !cmp ) {
		 savedflag++;
	      } else {
		  if ( savedflag >= 1 ) {
		   if ( !differ ) {
		      if ( countr )
			fprintf(ofp, "%d\t", savedflag);
		      xfwrite (saved.text, 1, saved.length, ofp);
#ifdef SAOMOD_BINARY
		      if ( !BinarySort ) putc ('\n', ofp);
#endif
		   } else {
		       if ( (differ == 1 && savedflag == 1)
			 || (differ == 2 && savedflag >= 2) ) {
			  xfwrite (saved.text, 1, saved.length, ofp);
#ifdef SAOMOD_BINARY
			  if ( !BinarySort ) putc ('\n', ofp);
#endif
		       }
		   }

		   if ( differ == 3 ) setcnt++;

		   savedflag = 0;
		  }
	      }
	  }

	  if ( !savedflag) {
	      if (savealloc < lines[ord[0]].lines[cur[ord[0]]].length + 1)
		{
		  while (savealloc < lines[ord[0]].lines[cur[ord[0]]].length + 1)
		    savealloc *= 2;
		  saved.text = xrealloc (saved.text, savealloc);
		}
	      saved.length = lines[ord[0]].lines[cur[ord[0]]].length;
	      memcpy (saved.text, lines[ord[0]].lines[cur[ord[0]]].text,
		     saved.length + 1);
	      if (lines[ord[0]].lines[cur[ord[0]]].keybeg != NULL)
		{
		  saved.keybeg = saved.text +
		    (lines[ord[0]].lines[cur[ord[0]]].keybeg
		     - lines[ord[0]].lines[cur[ord[0]]].text);
		}
	      if (lines[ord[0]].lines[cur[ord[0]]].keylim != NULL)
		{
		  saved.keylim = saved.text +
		    (lines[ord[0]].lines[cur[ord[0]]].keylim
		     - lines[ord[0]].lines[cur[ord[0]]].text);
		}

#ifdef SAOMOD_ASTRO
	      saved.flag  = lines[ord[0]].lines[cur[ord[0]]].flag;
	      saved.value = lines[ord[0]].lines[cur[ord[0]]].value;
#endif

	      savedflag = 1;
	  }

	  if ( differ == 3 ) {
	      fprintf(ofp, "%d\t", setcnt);
	      xfwrite (lines[ord[0]].lines[cur[ord[0]]].text, 1,
		       lines[ord[0]].lines[cur[ord[0]]].length, ofp);
#ifdef SAOMOD_BINARY
	      if ( !BinarySort ) putc ('\n', ofp);
#endif
	  }

	  if ( savedflag >= 2 && differ == 4 ) {
		  if ( savedflag == 2 ) {
		    xfwrite (saved.text, 1,
			     saved.length, ofp);
#ifdef SAOMOD_BINARY
		    if ( !BinarySort ) putc ('\n', ofp);
#endif
		  }
		  xfwrite (lines[ord[0]].lines[cur[ord[0]]].text, 1,
			   lines[ord[0]].lines[cur[ord[0]]].length, ofp);
#ifdef SAOMOD_BINARY
		  if ( !BinarySort ) putc ('\n', ofp);
#endif
	  }

	}

      else {
	  xfwrite (lines[ord[0]].lines[cur[ord[0]]].text, 1,
		   lines[ord[0]].lines[cur[ord[0]]].length, ofp);
#ifdef SAOMOD_BINARY
	  if ( !BinarySort ) putc ('\n', ofp);
#endif
      }

      /* Check if we need to read more lines into core. */
      if (++cur[ord[0]] == lines[ord[0]].used){
	if (fillbuf (&buffer[ord[0]], fps[ord[0]]))
	  {
	    findlines (&buffer[ord[0]], &lines[ord[0]]);
	    cur[ord[0]] = 0;
	  }
	else
	  {
	    /* We reached EOF on fps[ord[0]]. */
	    for (i = 1; i < nfps; ++i)
	      if (ord[i] > ord[0])
		--ord[i];
	    --nfps;
	    xfclose (fps[ord[0]]);
	    free (buffer[ord[0]].buf);
	    free ((char *) lines[ord[0]].lines);
	    for (i = ord[0]; i < nfps; ++i)
	      {
		fps[i] = fps[i + 1];
		buffer[i] = buffer[i + 1];
		lines[i] = lines[i + 1];
		cur[i] = cur[i + 1];
	      }
	    for (i = 0; i < nfps; ++i)
	      ord[i] = ord[i + 1];
	    continue;
	  }
      }
      /* The new line just read in may be larger than other lines
	 already in core; push it back in the queue until we encounter
	 a line larger than it. */
      for (i = 1; i < nfps; ++i)
	{
	  t = compare (&lines[ord[0]].lines[cur[ord[0]]],
		       &lines[ord[i]].lines[cur[ord[i]]]);
	  if (!t)
	    t = ord[0] - ord[i];
	  if (t < 0)
	    break;
	}
      t = ord[0];
      for (j = 1; j < i; ++j)
	ord[j - 1] = ord[j];
      ord[i - 1] = t;
    }

  if (unique && savedflag)
    {
      if ( !differ && savedflag >= 1 )
	{
	  if ( countr )
	    fprintf(ofp, "%d\t", savedflag);

	  xfwrite (saved.text, 1, saved.length, ofp);
#ifdef SAOMOD_BINARY
	  if ( !BinarySort ) putc ('\n', ofp);
#endif
	}

      if ( (differ == 1 && savedflag == 1)
        || (differ == 2 && savedflag >= 2) ) {
	  xfwrite (saved.text, 1,
		   saved.length, ofp);
#ifdef SAOMOD_BINARY
	  if ( !BinarySort ) putc ('\n', ofp);
#endif
      }

      free (saved.text);
    }
}

/* Sort the array LINES with NLINES members, using TEMP for temporary space. */

static void
sortlines (lines, nlines, temp)
     struct line *lines, *temp;
     int nlines;
{
  register struct line *lo, *hi, *t;
  register int nlo, nhi;

  if (nlines == 2)
    {
      if (compare (&lines[0], &lines[1]) > 0)
	*temp = lines[0], lines[0] = lines[1], lines[1] = *temp;
      return;
    }

  nlo = nlines / 2;
  lo = lines;
  nhi = nlines - nlo;
  hi = lines + nlo;

  if (nlo > 1)
    sortlines (lo, nlo, temp);

  if (nhi > 1)
    sortlines (hi, nhi, temp);

  t = temp;

  while (nlo && nhi)
    if (compare (lo, hi) <= 0)
      *t++ = *lo++, --nlo;
    else
      *t++ = *hi++, --nhi;
  while (nlo--)
    *t++ = *lo++;

  for (lo = lines, nlo = nlines - nhi, t = temp; nlo; --nlo)
    *lo++ = *t++;
}

/* Check that each of the NFILES FILES is ordered.
   Return a count of disordered files. */


static int
check (files, nfiles)
     char *files[];
     int nfiles;
{
  int i, disorders = 0;
  FILE *fp;

  for (i = 0; i < nfiles; ++i)
    {
      fp = xfopen (files[i], "r");
      line = 0;
      if (!checkfp (fp))
	{
	  printf ("%s: disorder on %s at line %d\n", program_name, files[i]
		, line);
	  ++disorders;
	}
    }
  return disorders;
}

/* Merge NFILES FILES onto OFP. */

static void
merge (files, nfiles, ofp)
     char *files[];
     int nfiles;
     FILE *ofp;
{
  int i, j, t;
  char *temp;
  FILE *fps[NMERGE], *tfp;

#ifdef SAOMOD_TABLE
  static TableHead	TH = NULL;
         TableHead	th;
#endif

  int	 saveunique = unique;

  unique = 0;

  while (nfiles > NMERGE)
    {
      t = 0;
      for (i = 0; i < nfiles / NMERGE; ++i)
	{
	  for (j = 0; j < NMERGE; ++j) {
	    fps[j] = xfopen (files[i * NMERGE + j], "r");
#ifdef SAOMOD_TABLE
	    if ( table == 2 ) {
		    if ( TH == NULL ) TH = table_header(fps[j], TABLE_PARSE);
		    else {
				int	k;

			th = table_header(fps[j], TABLE_PARSE);
			for ( k = 0; k < table_ncol(TH); k++ )
			    if ( strcmp(table_colnam(TH, k + 1), table_colnam(th, k + 1)) ) {
				fprintf(stderr, "sorttable: can't merge tables with different column definitions: \"%\"s != \"%s\"\n", table_colnam(TH, k+1), table_colnam(th, k+1));
				exit(1);
			    }
			table_hdrfree(th);
		    }
	    }
#endif
	  }


	  tfp = xfopen (temp = tempname (), "w");
	  mergefps (fps, NMERGE, tfp);
	  xfclose (tfp);
	  for (j = 0; j < NMERGE; ++j)
	    zaptemp (files[i * NMERGE + j]);
	  files[t++] = temp;
	}

      for (j = 0; j < nfiles % NMERGE; ++j) {
	fps[j] = xfopen (files[i * NMERGE + j], "r");
#ifdef SAOMOD_TABLE
	    if ( table == 2 ) {
		    if ( TH == NULL ) TH = table_header(fps[j], TABLE_PARSE);
		    else {
				int	k;

			th = table_header(fps[j], TABLE_PARSE);
			for ( k = 0; k < table_ncol(TH); k++ )
			    if ( strcmp(table_colnam(TH, k + 1), table_colnam(th, k + 1)) ) {
				fprintf(stderr, "sorttable: can't merge tables with different column definitions: \"%s\" != \"%s\"\n", table_colnam(TH, k+1), table_colnam(th, k+1));
				exit(1);
			    }
			table_hdrfree(th);
		    }
	    }
#endif
      }


      tfp = xfopen (temp = tempname (), "w");
      mergefps (fps, nfiles % NMERGE, tfp);
      xfclose (tfp);
      for (j = 0; j < nfiles % NMERGE; ++j)
	zaptemp (files[i * NMERGE + j]);
      files[t++] = temp;
      nfiles = t;
    }

  for (i = 0; i < nfiles; ++i) {
    fps[i] = xfopen (files[i], "r");
#ifdef SAOMOD_TABLE
	    if ( table == 2 ) {
		    if ( TH == NULL ) TH = table_header(fps[i], TABLE_PARSE);
		    else {
				int	k;

			th = table_header(fps[i], TABLE_PARSE);
			for ( k = 0; k < table_ncol(TH); k++ ) {
			    if ( strcmp(table_colnam(TH, k + 1), table_colnam(th, k + 1)) ) {
				fprintf(stderr, "sorttable: can't merge tables with different column definitions: \"%s\" != \"%s\"\n", table_colnam(TH, k+1), table_colnam(th, k+1));
				exit(1);
			    }
			}
			table_hdrfree(th);
		    }
	    }
#endif
  }

  unique = saveunique;
  mergefps (fps, i, ofp);
  for (i = 0; i < nfiles; ++i)
    zaptemp (files[i]);
}

/* Sort NFILES FILES onto OFP. */

static void
sort (files, nfiles, ofp)
     char **files;
     int nfiles;
     FILE *ofp;
{
  struct buffer buf;
  struct lines lines;
  struct line saved;		/* Saved line for unique check. */
  int	savedflag = 0;
  int savealloc = 0;		/* Size allocated for the saved line. */
  struct line *tmp;
  int i, ntmp;
  FILE *fp, *tfp;
  struct tempnode *node;
  int ntemp = 0;
  char **tempfiles;

  initbuf (&buf, sortalloc);
  initlines (&lines, sortalloc / linelength + 1,
	     LINEALLOC / sizeof (struct line));
  ntmp = lines.alloc;
  tmp = (struct line *) xmalloc (ntmp * sizeof (struct line));

  /* Allocate space for a saved line if necessary. */
  if (unique)
    {
      savealloc = linelength;
      saved.text = xmalloc (savealloc);
#ifdef SAOMOD_ASTRO
      saved.flag = 0;
#endif
    }

  while (nfiles--)
    {
      fp = xfopen (*files++, "r");
      while (fillbuf (&buf, fp))
	{
	  findlines (&buf, &lines);
	  if (lines.used > ntmp)
	    {
	      while (lines.used > ntmp)
		ntmp *= 2;
	      tmp = (struct line *)
		xrealloc ((char *) tmp, ntmp * sizeof (struct line));
	    }
	  sortlines (lines.lines, lines.used, tmp);
	  if (feof (fp) && !nfiles && !ntemp && !buf.left)
	    tfp = ofp;
	  else
	    {
	      ++ntemp;
	      tfp = xfopen (tempname (), "w");
	    }
	  if ( !unique || tfp != ofp )
	      for (i = 0; i < lines.used; ++i) {
		xfwrite (lines.lines[i].text, 1, lines.lines[i].length, tfp);
#ifdef SAOMOD_BINARY
		if ( !BinarySort ) putc ('\n', tfp);
#endif
	      }
	  else {
	    for (i = 0; i < lines.used; ++i) {
		int cmp;

	      if ( savedflag ) {
		    cmp = compare (&saved, &lines.lines[i]);

		  if ( !cmp ) {
		     savedflag++;
		  } else {
		      if ( savedflag >= 1 ) {
		       if ( !differ ) {
			  if ( countr )
			    fprintf(ofp, "%d\t", savedflag);
			  xfwrite (saved.text, 1, saved.length, ofp);
#ifdef SAOMOD_BINARY
			  if ( !BinarySort ) putc ('\n', ofp);
#endif
		       } else {
			   if ( (differ == 1 && savedflag == 1)
			     || (differ == 2 && savedflag >= 2) ) {
			      xfwrite (saved.text, 1, saved.length, ofp);
#ifdef SAOMOD_BINARY
			      if ( !BinarySort ) putc ('\n', ofp);
#endif
			   }
		       }

		       if ( differ == 3 ) setcnt++;
		       savedflag = 0;
		      }
		  }
	      }

	      if ( !savedflag) {
		  if (savealloc < lines.lines[i].length + 1)
		    {
		      while (savealloc < lines.lines[i].length + 1)
			savealloc *= 2;
		      saved.text = xrealloc (saved.text, savealloc);
		    }
		  saved.length = lines.lines[i].length;
		  memcpy (saved.text, lines.lines[i].text,
			 saved.length + 1);
		  if (lines.lines[i].keybeg != NULL)
		    {
		      saved.keybeg = saved.text +
			(lines.lines[i].keybeg - lines.lines[i].text);
		    }
		  if (lines.lines[i].keylim != NULL)
		    {
		      saved.keylim = saved.text +
			(lines.lines[i].keylim - lines.lines[i].text);
		    }

#ifdef SAOMOD_ASTRO
		  saved.flag  = lines.lines[i].flag;
		  saved.value = lines.lines[i].value;
#endif

		  savedflag = 1;
	      }

	      if ( differ == 3 ) {
		  fprintf(ofp, "%d\t", setcnt);
		  xfwrite (lines.lines[i].text, 1, lines.lines[i].length, ofp);
#ifdef SAOMOD_BINARY
		  if ( !BinarySort ) putc ('\n', ofp);
#endif
	      }

	      if ( savedflag >= 2 && differ == 4 ) {
		      if ( savedflag == 2 ) {
			xfwrite (saved.text, 1,
				 saved.length, ofp);
#ifdef SAOMOD_BINARY
			if ( !BinarySort ) putc ('\n', ofp);
#endif
		      }
		      xfwrite (lines.lines[i].text, 1, lines.lines[i].length, ofp);
#ifdef SAOMOD_BINARY
		      if ( !BinarySort ) putc ('\n', ofp);
#endif
	      }

	    }
          }
	  if (tfp != ofp)
	    xfclose (tfp);
	}
      xfclose (fp);
    }

  if (unique && savedflag)
    {
      if ( !differ && savedflag >= 1 )
	{
	  if ( countr )
	    fprintf(ofp, "%d\t", savedflag);

	  xfwrite (saved.text, 1, saved.length, ofp);
#ifdef SAOMOD_BINARY
	  if ( !BinarySort ) putc ('\n', ofp);
#endif
	}

      if ( (differ == 1 && savedflag == 1)
        || (differ == 2 && savedflag >= 2) ) {
	  xfwrite (saved.text, 1,
		   saved.length, ofp);
#ifdef SAOMOD_BINARY
	  if ( !BinarySort ) putc ('\n', ofp);
#endif
      }

      free (saved.text);
    }

  free (buf.buf);
  free ((char *) lines.lines);
  free ((char *) tmp);

  if (ntemp)
    {
      tempfiles = (char **) xmalloc (ntemp * sizeof (char *));
      i = ntemp;
      for (node = temphead.next; i > 0; node = node->next)
	tempfiles[--i] = node->name;
      merge (tempfiles, ntemp, ofp);
      free ((char *) tempfiles);
    }
}

/* Insert key KEY at the end of the list (`keyhead'). */

static void
insertkey (key)
     struct keyfield *key;
{
  struct keyfield *k = &keyhead;

  while (k->next)
    k = k->next;
  k->next = key;
  key->next = NULL;
}

static void
badfieldspec (s)
     char *s;
{
  fprintf (stderr, "invalid field specification `%s'", s);
  exit(2);
}

/* Handle interrupts and hangups. */

static void
sighandler (sig)
     int sig;
{
#ifdef _POSIX_VERSION
  struct sigaction sigact;

  sigact.sa_handler = SIG_DFL;
  sigemptyset (&sigact.sa_mask);
  sigact.sa_flags = 0;
  sigaction (sig, &sigact, NULL);
#else				/* !_POSIX_VERSION */
  signal (sig, SIG_DFL);
#endif				/* _POSIX_VERSION */
  cleanup ();
#if HAVE_MINGW32==0
  kill (getpid (), sig);
#else
  exit(1);
#endif
}

/* Set the ordering options for KEY specified in S.
   Return the address of the first character in S that
   is not a valid ordering option.
   BLANKTYPE is the kind of blanks that 'b' should skip. */

static char *
set_ordering (s, key, blanktype)
     char *s;
     struct keyfield *key;
     enum blanktype blanktype;
{
  while (*s)
    {
      switch (*s)
	{
	case 'b':
	  if (blanktype == bl_start || blanktype == bl_both)
	    key->skipsblanks = 1;
	  if (blanktype == bl_end || blanktype == bl_both)
	    key->skipeblanks = 1;
	  break;
	case 'd':
	  key->ignore = nondictionary;
	  break;
	case 'f':
	  key->translate = fold_toupper;
	  break;
#if 0
	case 'g':
	  /* Reserved for comparing floating-point numbers. */
	  break;
#endif
	case 'i':
	  key->ignore = nonprinting;
	  break;
	case 'M':
	  key->month = 1;
	  break;
	case 'n':
	  key->nzone   = 0;
	  key->numeric = 1;
	  break;
#ifdef SAOMOD_ASTRO
	case 'h':
	  key->nzone   = 0;
	  key->numeric = 2;
	  break;
#endif
	case 'q':
	  key->nzone   = 0;
	  key->numeric = 3;
	  break;
#ifdef SAOMOD_ASTRO
	case 'z':
	  key->nzone = 1;
	  key->numeric = 2;
	  s++;
	  key->dzone = SAOstrtod(s, &s);
	  s--;
	  break;
#endif
	case 'r':
	  key->reverse = 1;
	  break;
	default:
	  return s;
	}
      ++s;
    }
  return s;
}

int main (argc, argv)
     int argc;
     char *argv[];
{
  struct keyfield *key = NULL, gkey;
  char *s;
  int i, t, t2;
  int checkonly = 0, mergeonly = 0, nfiles = 0;
  char *minus = "-", *outfile = minus, **files, *tmp;
  FILE *ofp;
#ifdef _POSIX_VERSION
  struct sigaction oldact, newact;
#endif				/* _POSIX_VERSION */
#ifdef SAOMOD_FIX
  int pipes[4];
  char *ss=NULL, *tt=NULL, *uu=NULL;
#endif

  program_name = argv[0];

#ifdef SAOMOD_FIX
  /* Launch() sometimes rearranges passed pipes to be stdin/stdout */
  if( (ss=getenv("LAUNCH_PIPES")) ){
    tt = (char *)strdup(ss);
    for(i=0, uu=(char *)strtok(tt, ","); i<4 && uu; 
	i++, uu=(char *)strtok(NULL,",")){
      pipes[i] = atoi(uu);
    }
    if( tt ) free(tt);
    if( i < 4 ) return(1);
    close(pipes[0]);
    close(pipes[3]);
    dup2(pipes[2], 0);  close(pipes[2]);
    dup2(pipes[1], 1);  close(pipes[1]);
  }
#endif

#ifdef SAOMOD_FIX
  if ( (program_name = (char *)strrchr(program_name, '/')) )
    program_name++;
  else
    program_name = argv[0];
#endif

#ifdef SAOMOD_TABLE
  if ( strstr(program_name, "table") ) {
	table = 1;
	tab   = '\t';
  }
#endif

#ifdef SAOMOD_FIX
  /* Ask for a stable sort 
   */
  stable = 1;
#endif
  
  have_read_stdin = 0;
  inittables ();

  temp_file_prefix = getenv ("TMPDIR");
  if (temp_file_prefix == NULL)
    temp_file_prefix = DEFAULT_TMPDIR;

#ifdef _POSIX_VERSION
  newact.sa_handler = sighandler;
  sigemptyset (&newact.sa_mask);
  newact.sa_flags = 0;

  sigaction (SIGINT, NULL, &oldact);
  if (oldact.sa_handler != SIG_IGN)
    sigaction (SIGINT, &newact, NULL);
#if HAVE_MINGW32==0
  sigaction (SIGHUP, NULL, &oldact);
  if (oldact.sa_handler != SIG_IGN)
    sigaction (SIGHUP, &newact, NULL);
  sigaction (SIGPIPE, NULL, &oldact);
  if (oldact.sa_handler != SIG_IGN)
    sigaction (SIGPIPE, &newact, NULL);
#endif
  sigaction (SIGTERM, NULL, &oldact);
  if (oldact.sa_handler != SIG_IGN)
    sigaction (SIGTERM, &newact, NULL);
#else				/* !_POSIX_VERSION */
  if (signal (SIGINT, SIG_IGN) != SIG_IGN)
    signal (SIGINT, sighandler);
#if HAVE_MINGW32==0
  if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
    signal (SIGHUP, sighandler);
  if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
    signal (SIGPIPE, sighandler);
#endif
  if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
    signal (SIGTERM, sighandler);
#endif				/* !_POSIX_VERSION */

  gkey.sword = gkey.eword = -1;
  gkey.ignore = NULL;
  gkey.translate = NULL;
  gkey.nzone = gkey.numeric = gkey.month = gkey.reverse = 0;
  gkey.skipsblanks = gkey.skipeblanks = 0;

  files = (char **) xmalloc (sizeof (char *) * argc);

  for (i = 1; i < argc; ++i)
    {
      if( !strcasecmp(argv[1], "--help") ){
	usage(0);
      }
      if (argv[i][0] == '+')
	{
	  if (key)
	    insertkey (key);
	  key = (struct keyfield *) xmalloc (sizeof (struct keyfield));
	  key->eword = -1;
	  key->ignore = NULL;
	  key->translate = NULL;
	  key->skipsblanks = key->skipeblanks = 0;
	  key->nzone = key->numeric = key->month = key->reverse = 0;
	  s = argv[i] + 1;
	  if (!digits[UCHAR (*s)]) {
	    switch ( *s ) {
	     case 'c' :
	     case 'C' :
	     case 'b' :
	     case 'B' :
	     case 's' :
	     case 'S' :
	     case 'i' :
	     case 'I' :
	     case 'l' :
	     case 'f' :
	     case 'd' :
	     case 't' :
#ifdef SAOMOD_BINARY
		if ( !BinarySort ) BinarySort = -1;
#endif
		key->btype = *s;
		s++;

		break;
	    
	     default:
	    	badfieldspec (argv[i]);
	    }
	   }
	  for (t = 0; digits[UCHAR (*s)]; ++s)
	    t = 10 * t + *s - '0';
	  t2 = 0;
	  if (*s == '.')
	    for (++s; digits[UCHAR (*s)]; ++s)
	      t2 = 10 * t2 + *s - '0';
	  if (t2 || t)
	    {
	      key->sword = t;
	      key->schar = t2;
	    }
	  else {
#ifdef SAOMOD_BINARY
	    if ( BinarySort == 0 ) {
		key->sword = -1;
		key->schar = 0;
	    } else {
#endif
	      key->sword = t;
	      key->schar = t2;
#ifdef SAOMOD_BINARY
	    }
#endif
	  }
	  s = set_ordering (s, key, bl_start);
	  if (*s)
	    badfieldspec (argv[i]);
	}
      else if (argv[i][0] == '-' && argv[i][1])
	{
	  s = argv[i] + 1;
	  if (digits[UCHAR (*s)])
	    {
	      if (!key)
		usage (2);
	      for (t = 0; digits[UCHAR (*s)]; ++s)
		t = t * 10 + *s - '0';
	      t2 = 0;
	      if (*s == '.')
		for (++s; digits[UCHAR (*s)]; ++s)
		  t2 = t2 * 10 + *s - '0';
	      key->eword = t;
	      key->echar = t2;
	      s = set_ordering (s, key, bl_end);
	      if (*s)
		badfieldspec (argv[i]);
	      insertkey (key);
	      key = NULL;
	    }
	  else
	    while (*s)
	      {
		s = set_ordering (s, &gkey, bl_both);
		switch (*s)
		  {
#ifdef SAOMOD_BINARY
		  case 'B' :
		    s++;
		    BinarySort = strtol(s, &s, 10);
		    linelength = BinarySort;
		    break;
#endif
		  case '\0':
		    break;
		  case 'c':
		    checkonly = 1;
		    break;
		  case 'k':
		    if (s[1])
		      ++s;
		    else
		      {
			if (i == argc - 1){
			  fprintf (stderr, "option `-k' requires an argument");
			  exit(2);
			}
			else
			  s = argv[++i];
		      }
		    if (key)
		      insertkey (key);
		    key = (struct keyfield *)
		      xmalloc (sizeof (struct keyfield));
		    key->eword = -1;
		    key->echar =  0;
		    key->ignore = NULL;
		    key->translate = NULL;
		    key->skipsblanks = key->skipeblanks = 0;
		    key->nzone = key->numeric = key->month = key->reverse = 0;
		    /* Get POS1. */
		    if (!digits[UCHAR (*s)])
		      badfieldspec (argv[i]);
		    for (t = 0; digits[UCHAR (*s)]; ++s)
		      t = 10 * t + *s - '0';
		    if (t)
		      t--;
		    t2 = 0;
		    if (*s == '.')
		      {
			for (++s; digits[UCHAR (*s)]; ++s)
			  t2 = 10 * t2 + *s - '0';
			if (t2)
			  t2--;
		      }
		    if (t2 || t)
		      {
			key->sword = t;
			key->schar = t2;
		      }
		    else
		      key->sword = -1;
		    s = set_ordering (s, key, bl_start);
		    if (*s && *s != ',')
		      badfieldspec (argv[i]);
		    else if (*s++)
		      {
			/* Get POS2. */
			for (t = 0; digits[UCHAR (*s)]; ++s)
			  t = t * 10 + *s - '0';
			if (t)
			      t--;
			t2 = 0;
			if (*s == '.')
			  {
			    for (++s; digits[UCHAR (*s)]; ++s)
			      t2 = t2 * 10 + *s - '0';
			    if (t2)
			      t2--;
			  }
			key->eword = t;
			key->echar = t2;
			s = set_ordering (s, key, bl_end);
			if (*s)
			  badfieldspec (argv[i]);
		      }
		    insertkey (key);
		    key = NULL;
		    goto outer;
#ifdef SAOMOD_TABLE
		  case 'm':
		    mergeonly = 1;
		    if ( table ) table=2;
		    break;
#endif
		  case 'o':
		    if (s[1])
		      outfile = s + 1;
		    else
		      {
			if (i == argc - 1){
			  fprintf (stderr, "option `-o' requires an argument");
			  exit(2);
			}
			else
			  outfile = argv[++i];
		      }
		    goto outer;
		  case 's':
		    stable = 1;
		    break;
		  case 't':
		    if (s[1])
		      tab = *++s;
		    else if (i < argc - 1)
		      {
			tab = *argv[++i];
			goto outer;
		      }
		    else{
		      fprintf (stderr, "option `-t' requires an argument");
		      exit(2);
		    }
		    break;
		  case 'T':
		    if (s[1])
		      temp_file_prefix = ++s;
		    else
		      {
			if (i < argc - 1)
			  temp_file_prefix = argv[++i];
			else{
			  fprintf (stderr, "option `-T' requires an argument");
			  exit(2);
			}
		      }
		    goto outer;

		  case 'u': unique = 1; differ = 0; break;	/* One each only	*/
		  case 'U': unique = 1; differ = 1; break;	/* Unique lines only	*/
		  case 'D': unique = 1; differ = 2; break;	/* Duplic lines only	*/
		  case 'A': unique = 1; differ = 4; break;	/* All Duplic lines 	*/
		  case 'S': unique = 1; differ = 3; break;	/* Set counter		*/
		  case 'C': unique = 1; countr = 1; break;	/* Count same lines	*/
		  case 'y':
		    /* Accept and ignore e.g. -y0 for compatibility with
		       Solaris 2.  */
		    goto outer;
		  default:
		    fprintf (stderr, "%s: unrecognized option `-%c'\n",
			     argv[0], *s);
		    usage (2);
		  }
		if (*s)
		  ++s;
	      }
	}
      else			/* Not an option. */
	{
	  files[nfiles++] = argv[i];
	}
    outer:;
    }

  if (key)
    insertkey (key);

#ifdef SAOMOD_BINARY
  if ( BinarySort == -1 ) {
	fprintf (stderr, "No record length specified with binary file sort flags.\n");
	usage(2);
  }
  if ( BinarySort && key == NULL ) {
	fprintf (stderr, "Keys must be specified with binary file sort.\n");
	usage(2);
  }
#endif

#ifdef SAOMOD_BINARY
  /* Inheritance of global options to individual keys. */
if ( !BinarySort ) {
  for (key = keyhead.next; key; key = key->next)
    if (!key->ignore && !key->translate && !key->skipsblanks && !key->reverse
	&& !key->skipeblanks && !key->month && !key->numeric && !key->nzone)
      {
	key->ignore = gkey.ignore;
	key->translate = gkey.translate;
	key->skipsblanks = gkey.skipsblanks;
	key->skipeblanks = gkey.skipeblanks;
	key->month = gkey.month;
	key->numeric = gkey.numeric;
	key->reverse = gkey.reverse;
	key->nzone   = gkey.nzone;
	key->dzone   = gkey.dzone;

      }

  if (!keyhead.next && (gkey.ignore || gkey.translate || gkey.skipsblanks
			|| gkey.skipeblanks || gkey.month || gkey.numeric))
    insertkey (&gkey);
}
#endif

  reverse = gkey.reverse;

  if (nfiles == 0)
    {
      nfiles = 1;
      files = &minus;
    }

  if (checkonly)
    exit (check (files, nfiles) != 0);

  if (strcmp (outfile, "-"))
    {
      struct stat outstat;
      if (stat (outfile, &outstat) == 0)
	{
	  /* The following code prevents a race condition when
	     people use the brain dead shell programming idiom:
		  cat file | sort -o file
	     This feature is provided for historical compatibility,
	     but we strongly discourage ever relying on this in
	     new shell programs. */

	  /* Temporarily copy each input file that might be another name
	     for the output file.  When in doubt (e.g. a pipe), copy.  */
	  for (i = 0; i < nfiles; ++i)
	    {
	      char buf[8192];
	      FILE *fp;
	      int cc;

	      if (S_ISREG (outstat.st_mode) && strcmp (outfile, files[i]))
		{
		  struct stat instat;
		  if ((strcmp (files[i], "-")
		       ? stat (files[i], &instat)
		       : fstat (fileno (stdin), &instat)) != 0)
		    {
		      perror (files[i]);
		      cleanup ();
		      exit (2);
		    }
		  if (S_ISREG (instat.st_mode)
		      && (instat.st_ino != outstat.st_ino
			  || instat.st_dev != outstat.st_dev))
		    {
		      /* We know the files are distinct.  */
		      continue;
		    }
		}

	      fp = xfopen (files[i], "r");
	      tmp = tempname ();
	      ofp = xfopen (tmp, "w");
	      while ((cc = fread (buf, 1, sizeof buf, fp)) > 0)
		xfwrite (buf, 1, cc, ofp);
	      if (ferror (fp))
		{
  	          fprintf (stderr, "%s", files[i]);
		  cleanup ();
		  exit (2);
		}
	      xfclose (ofp);
	      xfclose (fp);
	      files[i] = tmp;
	    }
	}
      ofp = xfopen (outfile, "w");
    }
  else
    ofp = stdout;

  if (mergeonly)
    merge (files, nfiles, ofp);
  else
    sort (files, nfiles, ofp);
  cleanup ();

  /* If we wait for the implicit flush on exit, and the parent process
     has closed stdout (e.g., exec >&- in a shell), then the output file
     winds up empty.  I don't understand why.  This is under SunOS,
     Solaris, Ultrix, and Irix.  This premature fflush makes the output
     reappear. --karl@cs.umb.edu  */
  if (fflush (ofp) < 0)
    perror (outfile);

  if (have_read_stdin && fclose (stdin) == EOF)
    perror (outfile);
  if (ferror (stdout) || fclose (stdout) == EOF)
    perror (outfile);

  return(0);
}

static void
usage (status)
     int status;
{
  if (status != 0)
    fprintf (stderr, "Try `%s --help' for more information.\n",
	     program_name);
  else
    {
      fprintf(stderr,"Usage: %s [OPTION]... [FILE]...\n", program_name);
      fprintf(stderr,"Write sorted concatenation of all FILE(s) to standard output.\n");
      fprintf(stderr,"\n");
      fprintf(stderr,"+POS1 [-POS2]    start a key at POS1, end it before POS2\n");
      fprintf(stderr,"-M               compare (unknown) < `JAN' < ... < `DEC', imply -b\n");
      fprintf(stderr,"-T DIRECT        use DIRECT for temporary files, not $TMPDIR or %s\n", DEFAULT_TMPDIR);
      fprintf(stderr,"-b               ignore leading blanks in sort fields or keys\n");
      fprintf(stderr,"-c               check if given files already sorted, do not sort\n");
      fprintf(stderr,"-d               consider only [a-zA-Z0-9 ] characters in keys\n");
      fprintf(stderr,"-f               fold lower case to upper case characters in keys\n");
      fprintf(stderr,"-i               consider only [\\040-\\0176] characters in keys\n");
      fprintf(stderr,"-k POS1[,POS2]   same as +POS1 [-POS2], but all positions counted from 1\n");
      fprintf(stderr,"-m               merge already sorted files, do not sort\n");
      fprintf(stderr,"-n               compare according to string numerical value, imply -b\n");
      fprintf(stderr,"-o FILE          write result on FILE instead of standard output\n");
      fprintf(stderr,"-r               reverse the result of comparisons\n");
      fprintf(stderr,"-s               stabilize sort by disabling last resort comparison\n");
      fprintf(stderr,"-t SEP           use SEParator instead of non- to whitespace transition\n");
      fprintf(stderr,"-u               with -c, check for strict ordering\n");
      fprintf(stderr,"-u               with -m, only output the first of an equal sequence\n");
      fprintf(stderr,"-U		   output only unique records.\n");
      fprintf(stderr,"-D		   output only duplicate records.\n");
      fprintf(stderr,"--help       display this help and exit\n");
      fprintf(stderr,"--version    output version information and exit\n");
      fprintf(stderr,"\n");
      fprintf(stderr,"Binary File Options:\n");
      fprintf(stderr,"\n");
      fprintf(stderr,"-Blen		record length in bytes\n");
      fprintf(stderr,"\n");
      fprintf(stderr,"+<type1>offset1 +<type2>.offset2 ...\n");
      fprintf(stderr,"or\n");
      fprintf(stderr,"+<type1>offset1.len1 ... (+t text data only)\n");
      fprintf(stderr,"\n");
      fprintf(stderr,"where <type> can be:\n");
      fprintf(stderr,"\n");
      fprintf(stderr,"c		character data\n");
      fprintf(stderr,"C		unsigned character data\n");
      fprintf(stderr,"b		byte data\n");
      fprintf(stderr,"B		unsigned byte data\n");
      fprintf(stderr,"s		short data\n");
      fprintf(stderr,"S		unsigned short data\n");
      fprintf(stderr,"i		integer data\n");
      fprintf(stderr,"I		unsigned integer data\n");
      fprintf(stderr,"f		float data\n");
      fprintf(stderr,"d		double data\n");
      fprintf(stderr,"t		text data\n");
      fprintf(stderr,"\n");
      fprintf(stderr,"POS is F[.C][OPTS], where F is the field number and C the character\n");
      fprintf(stderr,"position in the field, both counted from zero.  OPTS is made up of one\n");
      fprintf(stderr,"or more of Mbdfinr; this effectively disables global -Mbdfinr settings\n");
      fprintf(stderr,"for that key.  If no key given, use the entire line as key.  With no\n");
      fprintf(stderr,"FILE, or when FILE is -, read standard input.\n");
      fprintf(stderr,"\n");
    }
  exit (status);
}

